类与对象（下）

2024-05-10 22:15:44

类与对象（下）

  1. 初始化列表

    1. 初始化列表

      1. 概念：初始化列表式每个成员变量定义初始化的位置

        1. 所有成员会先走初始化列表再走函数体
        2. 能用初始化列表尽量就用初始化列表（因为就算你用构造函数，他也会走初始化列表）

      2. 格式：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。

        class Date
{
public:
Date(int year, int month, int day)
  : _year(year)
     , _month(month)
     , _day(day)
 {}
private:
int _year;
int _month;
int _day;
};

    2. 类中的成员变量只是定义，它们在对象实例化的时候才定义（分配空间）；但是有些对象在声明的时候就需要定义（这些我们就所需要使用初始化列表，因为它们不能子啊函数体内初始化），那么我们要怎么做？

      1. 必须使用的：引用（引用必须在定义的时候初始化）；const成员变量；自定义类型成员（且该类没有默认构造函数）

      2. 对于自定义类型成员，即使我们不在初始化列表写它，也会调用它的默认构造函数；（如果自定义类型没有可用的默认构造函数，我们可以在初始化列表处对其进行初始化）

      3. 其他的成员，可以用初始化列表也可以用函数体

      4. 我们日常使用的时候建议使用初始化列表，因为即使我们在函数体内初始化，我们也会走初始化列表

      5. 初始化列表的括号中只能输入简单的语句，其他复杂的可以在函数体中写

      6. 示例：

        class A
{
public:
 A(int a)
 :_a(a)
 {}
private:
 int _a;
};
class B
{
public:
 B(int a, int ref)
 :_aobj(a)
 ,_ref(ref)
 ,_n(10)
 {}
private:
 A _aobj;  // 没有默认构造函数
 int& _ref;  // 引用
 const int _n; // const
};

    3. 缺省值

      1. 我们在声明处给的缺省值其实就是给初始化列表用的（所以缺省值的地方给的值与初始化列表中的值可以是一样的（比如说nullptr，动态开辟的位置等））

    4. 隐式类型转换

      1. 不想隐式类型转换发生：在初始化列表前加关键字explicit

    5. 初始化列表初始化的顺序

      1. 初始化列表的初始化的顺序是按照声明的顺序来的（所以声明的顺序最好与初始化的顺序一致）

  2. static成员

    1. 概念：

      1. 声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用 static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化

    2. 特性

      1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
      2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
      3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
      4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
      5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

  3. 友元

    1. 友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以 友元不宜多用。友元分为：友元函数和友元类

    2. 友元函数

      1. 友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在 类的内部声明，声明时需要加friend关键字。

      2. 说明：

        1. 友元函数可访问类的私有和保护成员，但不是类的成员函数
        2. 友元函数不能用const修饰
        3. 友元函数可以在类定义的任何地方声明，不受类访问限定符限制
        4. 一个函数可以是多个类的友元函数
        5. 友元函数的调用与普通函数的调用原理相同

      3. 示例：

        class Date
{
 friend ostream& operator<<(ostream& _cout, const Date& d);
 friend istream& operator>>(istream& _cin, Date& d);
public:
 Date(int year = 1900, int month = 1, int day = 1)
 : _year(year)
 , _month(month)
 , _day(day)
 {}
private:
 int _year;
 int _month;
 int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
 _cout << d._year << "-" << d._month << "-" << d._day;
 return _cout;
}
istream& operator>>(istream& _cin, Date& d)
{
 _cin >> d._year;
 _cin >> d._month;
 _cin >> d._day;
 return _cin;
}
int main()
{
 Date d;
 cin >> d;
 cout << d << endl;
 return 0;
}

    3. 友元类

      1. 友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。

      2. 说明：

        1. 友元关系是单向的，不具有交换性。

          1. 比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接 访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。

        2. 友元关系不能传递

          1. 如果C是B的友元 B是A的友元，则不能说明C时A的友元。

        3. 友元关系不能继承，在继承位置再给大家详细介绍。

      3. 示例：

        class Time
{
   friend class Date;   // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类
中的私有成员变量
public:
 Time(int hour = 0, int minute = 0, int second = 0)
 : _hour(hour)
 , _minute(minute)
 , _second(second)
 {}

private:
   int _hour;
   int _minute;
   int _second;
};
class Date
{
public:
   Date(int year = 1900, int month = 1, int day = 1)
       : _year(year)
       , _month(month)
       , _day(day)
   {}

   void SetTimeOfDate(int hour, int minute, int second)
   {
       // 直接访问时间类私有的成员变量
       _t._hour = hour;
       _t._minute = minute;
       _t._second = second;
   }

private:
   int _year;
   int _month;
   int _day;   Time _t;
};

  4. 内部类

    1. 概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越 的访问权限。

    2. 注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

    3. 特性：

      1. 内部类可以定义在外部类的public、protected、private都是可以的。
      2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
      3. sizeof(外部类)=外部类，和内部类没有任何关系。匿名对象

    4. 示例：

      class A
{
private:
 static int k;
 int h;
public:
 class B // B天生就是A的友元
 {
 public:
 void foo(const A& a)
 {
 cout << k << endl;//OK
 cout << a.h << endl;//OK
 }
 };
};
int A::k = 1;
int main()
{
    A::B b;
    b.foo(A());

    return 0;
}

  5. 匿名对象

    1. 特性：

      1. 匿名对象生命周期只有一行
      2. 即用即销毁，我们常用于传输参数，可以使代码简单一点

    2. 示例：

      class A
{
public:
 A(int a = 0)
 :_a(a)
 {
 cout << "A(int a)" << endl;
 }
 ~A()
 {
 cout << "~A()" << endl;
 }
private:
 int _a;
};
class Solution {
public:
 int Sum_Solution(int n) {
 //...
 return n;
 }
};
int main()
{
 A aa1;
 // 不能这么定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义
 //A aa1();
 // 但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，
 // 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数
 A();
 A aa2(2);
 // 匿名对象在这样场景下就很好用，当然还有一些其他使用场景，这个我们以后遇到了再说
 Solution().Sum_Solution(10);
 return 0;
}
上一篇：STM32 Flash