类与对象(下)

类与对象(下)

  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