【C++入门】类和对象（完）

前言

        在谈论C++时，常常会涉及到一些高级特性和概念，比如初始化列表、static成员、友元、内部类、匿名对象等。这些概念在C++编程中起着非常重要的作用，对于想要深入了解C++语言的开发者来说，掌握这些知识是至关重要的。本文，我们将深入探讨这些概念，探讨它们的作用以及如何在实际中的应用。

 1. 再谈构造函数

 1.1 初始化列表

        提到初始化列表，那就要再次谈及构造函数，初始化列表属于构造函数进行初始化的一种方式。

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

        这是最开始所说的构造函数初始化的一种方法，这种方法实质上不能被成为初始化，构造函数体中的语句只能将其称为赋初值，初始化只能初始化一次，而构造函数体内可以多次赋值。

 回到初始化列表。

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

 比如：

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

 定义一个类的对象时是这样的：

Date d1(2023,11,20);

这是对象的整体定义，成员变量的定义在哪儿？就是在初始化列表。

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

对于一些特殊情况，就必须要使用初始化列表进行初始化：

• 引用成员变量
• const成员变量
• 自定义类型成员(且该类没有默认构造函数时)

 初始化列表也可以与构造函数函数体内初始化结合使用：

 这个是一个测试样例：

class A
{
public:A(int a):_a(a){}
private:int _a;
};Date(int year, int month, int day)
{_year = year;_month = month;_day = day;_n = 1;    //报错：error C2530: “Date::_ref”: 必须初始化引用_ref = year;    //报错：error C2789: “Date::_n”: 必须初始化常量限定类型的对象
}
private:int _year;int _month;int _day;int& _ref;const int _n;};

 _ref和_n如果在函数体内初始化就会报错，const修饰会让其具备常属性，也就是说该变量只能在定义时初始化，引用类型也是，在定义时必须要初始化。

 正确的构造函数写法应该是：

Date(int year, int month, int day): _n(1), _ref(_year)
{_year = year;_month = month;_day = day;
}

 接下来就是它在C++语法设计时的细节问题：

class Date
{
public:Date(int year, int month, int day): _n(1)    //类成员定义, _ref(year){_year = year;_month = month;_day = day;}
private:int _year;int _month;int _day;int& _ref;const int _n;
};int main()
{Date d1(2023, 11, 20);// 对象整体定义return 0;
}

 这里C++语法设计的有点过于复杂，构造函数执行完初始化列表内容之后，函数体内的成员变量也已经被定义

 在没有执行赋值初始化操作之前，内置类型默认的随机值（但此时的全部成员变量都是已经被定义了的）。

其次就是自定义类型：

测试代码，比如：

class A
{
public:A(int a = 0) //注意这里给了缺省值:_a(a){}
private:int _a;
};class Date
{
public:Date(int year, int month, int day): _n(1), _ref(year){_year = year;_month = month;_day = day;}
private:int _year;int _month;int _day;int& _ref;const int _n;A   _obj;
};int main()
{Date d1(2023, 11, 20);return 0;
}

 注意观察以下调试过程：

 在初始化列表进行初始化时，自定义类型会自动调用默认构造函数。

注意：自定义类型A在构造函数中给了缺省值！！！

 如果不给缺省值，就会直接报错（没有默认构造函数）： error C2512: “A”: 没有合适的默认构造函数可用

 解决方法有两种：

1. 在A的构造函数中给缺省值
2. 使用初始化列表

Date(int year, int month, int day): _n(1), _ref(year), _obj(10)
{_year = year;_month = month;_day = day;
}

 之前我们提到C++打补丁支持声明时给缺省值：

class Date
{
public:Date(int year, int month, int day): _n(1), _ref(year), _obj(10){_year = year;_month = month;_day = day;}
private:int _year = 1; //在声明中给缺省值int _month;int _day;int& _ref;const int _n;A   _obj;
};

这个缺省值其实就是给初始化列表的，在初始化列表中如果没有显示要求初始化就会使用这里的缺省值。

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

 当然也有初始化列表无法完成的情况：

有些初始化或检查的任务，初始化列表无法完成，比如：

class Stack
{
public:Stack(int n = 2):_a((int*)malloc(sizeof(int)*n)),_top(0),_capacity(n){if (_a == nullptr){perror("malloc fail");exit(-1);}memset(_a, 0, sizeof(int) * n);}
private:int* _a;int _top;int _capacity;
};

 使用函数初始化数组的值，或者是开空间失败后的异常处理。

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

 看以下这个代码：

class A
{
public:A(int a):_a1(a), _a2(_a1){}void Print() {cout << _a1 << " " << _a2 << endl;}
private:int _a2;int _a1;
};int main() 
{A aa(1);aa.Print();
}

 它的输出结果是什么？

答案是_a1 = 1和_a2 = 随机值，声明次序就是其在初始化列表中的初始化顺序。所以它先初始化的是_a2，_a2使用_a1的值进行初始化，但此时_a1还未执行初始化，此时的_a1为随机值。

1.2 explicit关键字

看下面这段代码：

class A
{
public:A(int a):_a(a){}int _a = 0;};
void Test()
{A a1(1);A a2 = 2;// 内置类型隐式转换成自定义类型}

 a2在进行初始化时发生了隐式转换：实际编译器背后会用2构造一个无名对象，最后用无名对象给a2对象进行赋值。

 能支持整形2转换，是有A的int 单参数构造函数支持，如果使用int* 类型就不支持隐式类型转换了。

想要支持可以添加一个含int* 的单参数构造函数：

class A
{
public:A(int a):_a(a){}A(int* p){}int _a = 0;};

 如果不想让这个隐式类型转换（强制类型转换还是可以的），就可以使用explicit关键字来修饰构造函数。

class A
{
public:explicit A(int a):_a(a){}int _a = 0;};

 前边的示例是单参数，那多参数呢？

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

 如上，也是可以的，支持一个传参的半缺省（全缺省也可以）也是可以隐式类型转换。那可不可以支持多个内置类型隐式转换，C++11是可以的：

Date d1 = { 2023, 11, 10 };

 但是只能如上这种写法。

 多参数也是一样，如果不想要隐式类型转换，可以给构造函数加explicit。

2. static成员

 static修饰有什么作用？

static修饰的成员变量或成员函数在类加载时执行，并且只会执行一次。

 问题：实现一个类，计算程序中创建出了多少个类对象

 使用全局变量计算：

int n = 0;class A
{
public:A() { ++n; }A(const A& t) { ++n; }~A() {}private:};A func()
{A aa;return aa;
}int main()
{n++;A aa;func();n++;cout << n << endl;return 0;
}

当前边存在修改n的情况，结果就不准确了，其次就是每次使用时都要将n置为0（其他类也可能使用过n）；那有没有专属这个类的计数变量呢？使用static就可以很好的解决这个问题。

2.1 概念

用static修饰的成员变量，称之为静态成员变量；

用static修饰的成员函数，称之为静态成员函数。

静态成员变量一定要在类外进行初始化

class A
{
public:A() { ++count; }A(const A& t) { ++count; }~A() {}static int GetACount() { return count; }
private:static int count;
};int A::count = 0;
A func()
{A aa;return aa;
}int main()
{A aa;func();cout << A::GetACount() << endl;return 0;
}

 2.2 特点

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

总结：静态成员变量和静态成员函数，可以理解为受限制的全局变量和全局函数。专属于某个类，受类域和访问限定符的限制。

 3. 匿名对象

匿名对象其实很简单我们看下面这个代码：

class Date
{
public:Date(int year, int month = 1, int day = 1): _year(year), _month(month), _day(day){}private:int _year;int _month;int _day;
};int main()
{vector<Date> v;Date d1(2023, 11, 1);v.push_back(d1);return 0;
}

在C++中的STL容器中我们要存储日期类的对象。每次存储还要创建一个对象，然后再存储，这样很麻烦，这里我们就可以使用匿名函数：

v.push_back(Date(2023, 10, 31));

匿名对象在这样场景下就很好用。匿名对象的生命周期只有这一行，执行完之后自动调用析构函数。

4. 友元

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

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

 4.1 友元函数

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

 前边在实现Date类的流插入、流提取中提到过。

友元函数的特点：

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

 4.2 友元类

 友元类（friend class）是指一个类可以访问另一个类的私有成员和保护成员。

比如：

class A {
private:int privateData;
protected:int protectedData;friend class B; // B是A的友元类
};class B {
public:void accessA(A& a) {// 友元类B可以访问A的私有成员和保护成员a.privateData = 10;a.protectedData = 20;}
};

注意：

• 友元关系是单向的

比如：类A声明类B为友元类，那么类B可以访问类A的私有成员和保护成员，但类A不能访问类B的私有成员和保护成员。

• 友元关系不能传递

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

• 友元关系不能继承

 5. 内部类

什么是内部类？

一个类定义在另一个类的内部

内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限

 比如：

class A
{
private:int h;
public:class B // B天生就是A的友元{public:void fun(const A& a){cout << a.h << endl;//OK}};
};

 A于B的关系：

可以理解为B就是一个普通类，它只受A的类域和访问限定符限制，

int main()
{A aa;//B bb //error C2065: “B”: 未声明的标识符A::B bb;cout << sizeof(A) << endl; // 4return 0;
}

内部类天生就是外部类的友元

 *6. 拷贝构造时的一些优化

 在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝。

比如：

class A
{
public:A(int a = 0):_a(a){cout << "A(int a)" << endl;}A(const A& aa):_a(aa._a){cout << "A(const A& aa)" << endl;}A& operator=(const A& aa){cout << "A& operator=(const A& aa)" << endl;if (this != &aa){_a = aa._a;}return *this;}~A(){cout << "~A()" << endl;}
private:int _a;
};int main()
{A aa1 = 1;  return 0;
}

A aa1 = 1; 

它的过程是什么样的？它的过程其实分为两步

1、先用1构造一个临时对象  2、再用临时对象拷贝构造aa1

 但我们在调试时会发现最终编译器显示的是一次构造。这其实就是由于编译器的优化。

同一个表达式中，连续构造+构造 / 构造+拷贝构造 / 拷贝构造+拷贝构造 会合二为一

 合并规则如下：

• 构造+构造->构造
• 构造+拷贝构造->构造
• 拷贝构造+拷贝构造->拷贝构造

 编译器不同优化效果也不同，老的编译器不会怎么优化，但新的编译器基本都会做这样的优化，甚至优化的比这个更厉害。

---

总结

         在C++编程中，掌握初始化列表、static成员、友元和内部类等相关知识是非常重要的。这些概念不仅能够帮助我们更好地理解C++语言的特性，还能够提高我们的编程效率和代码质量，以上便是本文全部内容，希望可以对你有所帮助，感谢阅读！