[ C++ ] 类与对象(下) 初始化列表，友元，static成员，内部类

本篇是C++类与对象最后的部分知识，主要是对类的更深层次理解和使用。

1.再谈构造函数

1.1 构造函数体赋值

在之前我们讨论过，类会默认生成构造函数，我们把构造函数也叫做初始化函数。所以在创建对象时，编译器通过调用构造函数给对象中各个成员变量一个合适的初始值。

class Date
{
public:
  Date(int year = 1 , int month = 1, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
private:
  //声明
  int _year;
  int _month;
  int _day;
};

int main()
{
  //对象
  Date d1(2022, 5, 22);
  Date d2;//未定义无参的默认构造  写成全缺省就ok
  return 0;
}

我们如果未定义无参的构造函数，尽量将构造函数写成全缺省的，这样即使有无参的对象也可以使用构造函数，否则就会报错：不存在默认构造函数。

除了这种初始化方式之外，还有一种方式是通过初始化列表进行初始化。

1.2 初始化列表

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

例如：我们上面的Date类用初始化列表初始化如下

class Date
{
public:

  //初始化列表
  Date(int year = 1, int month = 1, int day = 1)
    :_year(year)
    ,_month(month)
    ,_day(day)
  { 
  }

private:
  //声明
  int _year;
  int _month;
  int _day;
};

int main()
{
  //对象
  Date d1(2022, 5, 22);
  Date d2;
  return 0;
}

1.2.1初始化列表的价值：

1.初始化列表是对象的成员定义的地方。

有些成员必须在定义的地方初始化，那么那些成员必须在定义是初始化呢？

(a) 引用成员变量  （b）const成员变量  （c）自定义类型（无默认构造函数）

class A
{
public:
  A(int a)
    :_a(a)
  {
  }
private:
  int _a;
};

class Date
{
public:
  
  //只能在初始化列表初始化
  Date(int year, int n, int ref,int a)
    :_n(n)
    ,_ref(ref)
    ,_aa(a)
  {
    _year = year;
  }
   


private:
  //声明
  //可以在定义时初始化;也可以定义时不初始化，后面再赋值修改
  int _year;

  //只能在定义的时候初始化
  const int _n;
  int& _ref;
  A _aa;
};

注意：

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

​

2. 类中包含以下成员，必须放在初始化列表位置进行初始化：

（a）引用成员变量 （b）const成员变量 （c）自定义类型成员(该类没有默认构造函数)

​

3. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。

​

4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。

1.3 explicit关键字

构造函数不仅可以构造与初始化对象，对于单个参数的构造函数，还具有类型转换的作用。

class Date
{
public:
    Date(int year)
        :_year(year)
    {
        cout << "Date(int year)" << endl;
    }

    Date(const Date& d)
    {
        cout << "Date(const Date& d)" << endl;
    }

private:
    int _year;
};

int main()
{
    Date d1(2022);//构造
    //隐士类型的抓换
    Date d2 = 2022;//构造+拷贝构造 -》优化

    return 0;
}

我们可以发现2022是int类型，而d2是Date类型，因此这里发生了隐式转换。如果不想发生类型转换在构造函数前加上explicit即可。 

class Date
{
public:
  explicit Date(int year)
    :_year(year)
  {
    cout << "Date(int year)" << endl;
  }

private:
  int _year;
};

int main()
{
  Date d1(2022);//构造
  //隐士类型的抓换
  Date d2 = 2022;//构造+拷贝构造 -》优化

  return 0;
}

此时就会发生错误：

 上述代码可读性不是很好，用explicit修饰构造函数，将会禁止单参构造函数的隐式转换。

2.static成员

2.1问题的引入

Q：统计A类型创造了多少个？ 

方法一：全局变量（不提倡） 

//全局变量  -- 不提倡
int num = 0;
class A
{

};
A Func(A a)
{
  A copy(a);
  return copy;
}
int main()
{
  A a1;
  A a2 = Func(a1);

  cout << num << endl;

}

这里我们直接判断来找很麻烦，而且也不好找。

因此我们可以在A类中把通过构造的和通过拷贝的分别记录打印就好了，我们分别用不同的两个变量来进行记录

int num1 = 0;
int num2 = 0;
class A
{
public:
  A()
  {
    ++num1;
  }
  A(const A& aa)
  {
    ++num2;
  }
};
A Func(A a)
{
  A copy(a);
  return copy;
}
int main()
{
  A a1;
  A a2 = Func(a1);

  cout << num1 << endl;
  cout << num2 << endl;

}

注意：全局变量在一些简单的程序中不会有问题，但是在项目中可能会出现错误。如果在.h中定义，就有可能发生链接错误。并且放成全局也不利于封装性。

方法二：静态成员变量

class A
{
public:
    A()
    {
        ++_count1;
    }
    A(const A& aa)
    {
        ++_count2;
    }

    //静态成员变量属于整个类
    static int _count1;//声明
    static int _count2;

    int _a;

};
A Func(A a)
{
    A copy(a);
    return copy;
}
//定义
int A::_count1 = 0;
int A::_count2 = 0;

int main()
{
    A a1;
    A a2 = Func(a1);
    cout << sizeof(a1) << endl;

    cout << a1._count1 << endl;
    cout << a2._count1 << endl;

    cout << a1._count2 << endl;
    cout << a2._count2 << endl;

    cout << A::_count1 << endl;
    cout << A::_count1 << endl;


    return 0;
}

这里我们发现sizeof这个类，计算大小是不会计算静态成员的。因为静态成员为所有类对象所共享(在静态区)，不属于某个具体的实例，所以不会纳入类内的计算。

其次：在类内静态成员只是声明，静态成员变量必须在类外定义，定义时不添加static关键字。

如果静态成员是私有的就需要Get（）函数提供接口来访问

class A
{
public:
    A()
    {
        ++_count1;
    }
    A(const A& aa)
    {
        ++_count2;
    }
     
    int  GetCount1()
    {

        return _count1;
    }
    int  GetCount2()
    {
        return _count2;
    }
private:

    static int _count1;//声明
    static int _count2;

    int _a;

};
A Func(A a)
{
    A copy(a);
    return copy;
}
//定义
int A::_count1 = 0;
int A::_count2 = 0;

int main()
{
    A a1;
    A a2 = Func(a1);

    cout << a1.GetCount1() << endl;
    cout << a2.GetCount2() << endl;

    return 0;
}

 我们要使用对象调用Get()函数，那假如没有对象，我们可以把函数写成静态成员函数

class A
{
public:
  A()
  {
    ++_count1;
  }
  A(const A& aa)
  {
    ++_count2;
  }


  //成员函数也可以是静态的
  static int  GetCount1()
  {
    return _count1;
  }
  static int  GetCount2()
  {
    return _count2;
  }
private:
  //静态成员变量属于整个类
  static int _count1;//声明
  static int _count2;

  int _a;

};
A Func(A a)
{
  A copy(a);
  return copy;
}
//定义
int A::_count1 = 0;
int A::_count2 = 0;

int main()
{
  A a1;
  A a2 = Func(a1);

  cout << a1.GetCount1() << endl;
  cout << a2.GetCount2() << endl;

  cout << A::GetCount1() << endl;
  cout << A::GetCount2() << endl;

  return 0;
}

但是需要注意的是static成员函数没有this指针，因此不能访问非静态成员

 2.2特性

1. 静态成员为所有类对象所共享，不属于某个具体的实例。2. 静态成员变量必须在类外定义，定义时不添加static关键字。3. 类静态成员即可用类名::静态成员或者对象.静态成员来访问。4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员。5. 静态成员和类的普通成员一样，也有public、protected、private3种访问级别，也可以具有返回值。

3.C++11 的成员初始化新玩法。

C++11支持非静态成员变量在声明时进行初始化赋值，但是要注意这里不是初始化，这里是给声明的成员变量缺省值。

class B
{
public:
  B(int b = 0)
    :_b(b)
  {
  }
private:
  int _b;
};
class A
{
public:


private:
  //非静态成员变量，可以在成员声明时给缺省值
  int a = 10;
  B b = 20;//隐士类型转换
  int* p = (int*)malloc(4);
};

注意：静态成员不能在此赋值，因为静态成员不会在初始化列表初始化。

4. 友元

友元分为：友元函数和友元类

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

4.1友元函数

在上一篇文章中我们其实已经提前使用了一下友元函数。那么现在我们再来重温一遍友元函数的用法和注意事项吧。

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

class Date
{
  //友元函数
  friend ostream& operator<<(ostream& out, const Date& d);
public:

private:
  int _year;
  int _month;
  int _day;
};
ostream& operator<<(ostream& out, const Date& d)
{
  out << d._year << "-" << d._month << "-" << d._day << endl;
  return out;
}

说明：

1.友元函数可访问类的私有和保护成员，但不是类的成员函数。

2.友元函数不能用const修饰。

3.友元函数可以在类定义的任何地方声明，不受类访问限定符限制。

4.一个函数可以是多个类的友元函数。5.友元函数的调用与普通函数的调用和原理相同。

 4.2 友元类

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

//友元
class Date;//Date类的声明

class Time
{
    //友元类
    friend class Date;
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
{
    友元函数
    friend ostream& operator<<(ostream& out, const Date& d);
public:
    
    要访问Time类内的成员，使用友元类
    void SetDateTime(int hour,int minute,int second)
    {
        _t._hour = hour;
        _t._minute = minute;
        _t._second = second;
    }
private:
    int _year;
    int _month;
    int _day;

    Time _t;
};
ostream& operator<<(ostream& out, const Date& d)
{
    out << d._year << "-" << d._month << "-" << d._day << endl;
    return out;
}

我们发现如果我们需要在Date类内要访问Time类内的成员，就要使用友元类。

注意：

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

2.友元关系不能传递 如果B是A的友元，C是B的友元，则不能说明C时A的友元。

5.内部类

5.1概念及特性

概念：内部类说白了就是在一个类里面再去定义一个类。所以如果一个类定义在另一个类的内部，这个内部类就叫做内部类。注意此时这个内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。

class A
{
private:
    static int k;
    int h;
public:

    //内部类
    class B
    {
    public:

    private:
        int _b;
    };
};
int main()
{
    A aa;//只有A的成员 
    cout << sizeof(A) << endl;
    return 0;
}

如这段代码，我们在类A中定义了内部类B。我们sizeof（A）发现只有A自己的成员。

因此：sizeof(外部类)=外部类，和内部类没有任何关系。

​

此外，内部类天生就是外部类的友元.

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

class A
{
private:
  static int k;
  int h;
public:
  //内部类
  class B//B天生是A的有友元
  {
  public:
    void foo(const A& a)
    {
      cout << k << endl;
      cout << a.h << endl;
    }
  private:
    int _b;
  };
};

外部类不是内部类的友元

class A
{
private:
  static int k;
  int h;
public:
  //内部类
  class B//B天生是A的有友元
  {
  public:
    void foo(const A& a)
    {
      cout << k << endl;
      cout << a.h << endl;
    }
  private:
    int _b;
  };
  void Print(const B&b)
  {
    b._b;//访问不到
  }
};

特性：

1. 内部类可以定义在外部类的public、protected、private都是可以的。

2. 注意内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。

3. sizeof(外部类)=外部类，和内部类没有任何关系。

（本篇完）