编辑
引言
在上一篇博客中，我们学习了C++的基础类与对象概念，包括类的定义、对象的使用和构造函数的作用。在这一篇，我们将深入探讨C++类的一些重要特性，如构造函数的高级用法、类型转换、static成员、友元、内部类、匿名对象，以及对象拷贝优化等。这些内容可以帮助你更好地理解和应用面向对象编程的核心理念，提升代码的健壮性、灵活性和可维护性。
无论你是C++的初学者还是有一定基础的开发者，本文都将为你提供详细的解释和实用的示例代码，帮助你掌握C++中的类与对象的高级用法。
一、再谈构造函数
构造函数是 C++ 中用于初始化对象的特殊函数。每次创建类的实例时，构造函数都会自动调用，用来为对象的成员变量赋初值。本篇将深入探讨构造函数的一些高级用法与技巧。
1.1 构造函数的初始化方式
在 C++ 中，构造函数可以通过两种方式为类的成员变量赋值：构造函数体内赋值和初始化列表。
(1). 构造函数体内赋值
传统方式是通过构造函数体来对成员变量赋值：
class Person { public: Person(int age) { _age = age; // 在构造函数体内赋值 } private: int _age; };
这种方式虽然常见，但可能带来效率问题，因为成员变量会经历两次赋值——默认初始化后再赋值。
(2).初始化列表
初始化列表可以更高效地为成员变量赋值。其语法是在构造函数的参数列表后面使用冒号 :，直接对成员变量进行初始化：
class Person { public: Person(int age) : _age(age) {} // 使用初始化列表 private: int _age; };
使用初始化列表可以避免默认初始化后的重复赋值，因而效率更高。
1.2 必须使用初始化列表的场景
在某些情况下，初始化列表是唯一可行的选择：
1.引用成员变量
引用类型必须在初始化时绑定对象，因此需要通过初始化列表来进行初始化，不能在构造函数体内赋值。
2.常量成员变量
常量成员变量一旦被赋值便不能修改，必须在初始化列表中赋值，不能在构造函数体内赋值。
3.没有默认构造函数的类类型成员
如果成员是其他类的对象且没有默认构造函数，则必须通过初始化列表进行初始化。否则，编译器无法为其分配默认初值，导致编译错误。
示例：
class Date { public: Date(int& year, int month = 1, int day = 1) : _year(year), _month(month), _day(day), _constValue(100) {} private: int& _year; // 引用类型成员变量 const int _constValue; // 常量成员变量 int _month; int _day; };
在上述代码中，_year 是引用类型，_constValue 是常量，都必须在初始化列表中进行初始化。
1.3 初始化列表的优势
1.提升性能
使用初始化列表避免了构造函数体内赋值的额外开销，尤其对于包含大量成员变量的类，能够显著提升性能。
2.必须使用的场合
某些成员（如引用和常量）只能在初始化列表中进行初始化，这是 C++ 语言规范的要求。
1.4 成员变量的缺省值
在 C++11 中，可以在类内为成员变量赋予缺省值，这样即使构造函数没有显式赋值，也会使用这些默认值：
class Person { private: int _age = 18; // 缺省值 std::string _name = "Unnamed"; // 缺省值 };
这种方式简化了构造函数，提高了代码的灵活性。
1.5 初始化列表的顺序规则
(1).成员变量初始化顺序
尽管初始化列表的书写顺序可以自由选择，但成员变量的初始化顺序是由它们在类中声明的顺序决定的。
示例：
class Example { private: int _x; int _y; public: Example(int x, int y) : _y(y), _x(x) {} // _x 仍会先于 _y 初始化 };
(2).成员变量初始化的逻辑
在初始化列表中，成员变量的初始化遵循以下逻辑：
- 如果成员变量在初始化列表中显式初始化，则按照提供的值进行初始化。
- 如果成员变量未在初始化列表中显式初始化，则有两种情况：
- 成员变量在类中声明时有缺省值：按照缺省值初始化。
- 成员变量在类中声明时没有缺省值：
- 对于内置类型成员，初始化为随机值，可能是默认值 0 等，具体行为依赖于编译器。
- 对于自定义类型成员，如果没有默认构造函数且无法自动初始化，将导致编译错误。
此外，引用类型成员、
const成员以及没有默认构造函数的类类型成员，必须在初始化列表中进行显式初始化，无法在构造函数体内赋值。
编辑
建议始终保持初始化列表中的顺序与成员变量声明顺序一致，以避免潜在的未定义行为。
1.6 常见错误
(1).忘记初始化引用或常量成员
引用类型和常量成员必须通过初始化列表进行初始化，否则编译器会报错。
(2).初始化顺序不一致
初始化顺序与成员变量声明顺序不一致时，可能导致未定义行为，尤其在成员变量之间存在依赖关系时更需谨慎。
二、类型转换
2.1 C++ 中的类型转换概述
在C++中，类型转换是一个非常强大的功能。它允许我们在不同类型之间进行转换。在类中，类型转换通常通过构造函数或者类型转换运算符来实现。C++支持隐式和显式类型转换，这在开发复杂系统时非常有用。
2.2 隐式类型转换
如果一个类有一个接受单个参数的构造函数，那么该类的对象可以通过传递该类型的参数进行隐式构造。例如，假设我们有一个类A，它有一个接受int类型参数的构造函数。
class A { public: A(int a) : _a(a) {} void print() { cout << "A: " << _a << endl; } private: int _a; }; int main() { A obj = 10; // 隐式类型转换：int 被转换为 A obj.print(); // 输出 A: 10 }
在上面的代码中，整数10被隐式地转换为A类的对象，并调用了A的构造函数。这个过程称为隐式类型转换。然而，隐式类型转换可能会导致意外的行为，因此我们通常希望控制这种行为。
2.3 使用explicit关键字阻止隐式类型转换
为了避免隐式类型转换导致的错误，我们可以使用explicit关键字来标记构造函数，这样该构造函数将不再允许隐式转换。
class A { public: explicit A(int a) : _a(a) {} void print() { cout << "A: " << _a << endl; } private: int _a; }; int main() { // A obj = 10; // 编译错误，因为构造函数是 explicit 的 A obj(10); // 必须显式调用构造函数 obj.print(); }
在这个例子中，explicit关键字阻止了int到A的隐式转换，因此必须通过显式地调用构造函数来创建对象。
2.4 类型转换运算符
除了构造函数，C++还支持类型转换运算符，它允许我们将类类型的对象转换为其他类型。类型转换运算符的定义形式如下：
operator 类型() { // 转换逻辑 } 例如： class A { public: A(int a) : _a(a) {} // 定义 int 类型的转换运算符 operator int() { return _a; } private: int _a; }; int main() { A obj(10); int num = obj; // 隐式调用转换运算符，将 A 对象转换为 int cout << "num: " << num << endl; // 输出 num: 10 }
在上面的代码中，类A提供了一个将A对象转换为int的运算符，因此可以直接将A对象赋值给一个int类型的变量。
三、静态成员 (static)
3.1 静态成员变量
static成员变量是属于类本身的，而不是类的某个对象。也就是说，所有类的对象都共享同一个static成员变量。静态成员变量在类的所有对象之间共享，并且必须在类外部进行初始化。
示例代码：
class Counter { public: Counter() { ++_count; } ~Counter() { --_count; } static int getCount() { return _count; } private: static int _count; // 静态成员变量 }; int Counter::_count = 0; // 必须在类外初始化 int main() { Counter c1, c2; cout << "Current count: " << Counter::getCount() << endl; // 输出 2 return 0; }
在这个例子中，_count是一个静态成员变量，用来计数创建的对象数量。由于它是静态的，所有Counter对象共享同一个计数器。
3.2 静态成员函数
静态成员函数与普通成员函数的主要区别在于，它们不能访问非静态的成员变量或成员函数。因为静态成员函数没有this指针，不能与具体的对象绑定。
示例代码：
class Example { public: static void staticFunc() { cout << "This is a static function." << endl; } }; int main() { Example::staticFunc(); // 静态成员函数可以通过类名直接调用 return 0; }
在上面的例子中，静态成员函数staticFunc是通过类名直接调用的，而不需要通过对象。
四、友元（Friend）
4.1 什么是友元？
C++中的友元（friend）是一种特殊机制，它允许一个函数或类访问另一个类的私有成员。通常，类的私有成员只能通过公共接口（如公共成员函数）访问，但有时候我们希望让另一个类或函数直接访问这些私有数据。友元就是为此设计的。
- 友元函数：允许某个外部函数访问类的私有和保护成员。
- 友元类：允许另一个类访问当前类的私有和保护成员。
4.2 友元函数的使用
友元函数并不是类的成员函数，但它有权访问类的私有成员。友元函数在类内部通过friend关键字声明。
class Box { friend void showBox(const Box& b); // 友元函数声明 private: int _length = 10; int _width = 5; }; void showBox(const Box& b) { std::cout << "Box length: " << b._length << ", width: " << b._width << std::endl; } int main() { Box b; showBox(b); // 输出：Box length: 10, width: 5 return 0; }
4.3 友元类的使用
友元类中的所有成员函数都可以访问另一个类的私有成员。友元类的关系是单向的，即A类是B类的友元，但B类并不能访问A类的私有成员。
class Engine; class Car { friend class Engine; // Engine 是 Car 的友元类 private: int _horsePower = 300; }; class Engine { public: void showHorsePower(const Car& c) { std::cout << "Car's horsepower: " << c._horsePower << std::endl; // 访问 Car 的私有成员 } }; int main() { Car myCar; Engine myEngine; myEngine.showHorsePower(myCar); // 输出：Car's horsepower: 300 return 0; }
4.4 友元的优缺点
友元提供了一种方便的方式来访问类的私有数据，增加了类之间的合作性。然而，它也会破坏类的封装性和数据安全性。因此，使用友元时要慎重，不宜过度使用。
五、内部类
内部类是定义在另一个类中的类。它通常用于封装两者之间的紧密关系，外部类可以控制内部类的行为。内部类在外部类中定义时，默认情况下可以访问外部类的私有成员。
示例代码：
class Outer { private: int _data = 42; public: class Inner { public: void show(const Outer& o) { cout << "Outer::_data = " << o._data << endl; // 访问外部类的私有成员 } }; }; int main() { Outer outer; Outer::Inner inner; inner.show(outer); // 输出 Outer::_data = 42 return 0; }
在这个例子中，Inner类是Outer类的内部类，它可以访问Outer类的私有成员_data。
六、匿名对象
匿名对象是没有名字的临时对象，它们的生命周期非常短暂，只在当前语句中存在。匿名对象经常用于简化临时操作，不需要为它们显式命名。
示例代码：
class A {
public:
A() { cout << "A()" << endl; }
~A() { cout << "~A()" << endl; }
};
int main() {
A(); // 创建匿名对象
return 0; // 匿名对象在这一行结束时自动销毁
}
在上面的代码中，匿名对象在创建后立即被销毁。匿名对象的使用使代码更简洁，但需要注意它们的生命周期。
七、对象拷贝时的编译器优化
在C++中，编译器会进行一些优化，减少对象拷贝次数，从而提高性能。这些优化包括返回值优化（RVO）和拷贝省略。当一个函数返回一个对象时，编译器会尝试直接构造返回值，而不是先构造临时对象再拷贝。
示例代码：
class A { public: A() { cout << "A()" << endl; } A(const A&) { cout << "A(const A&)" << endl; } ~A() { cout << "~A()" << endl; } }; A createObject() { A obj; return obj; // 返回时优化 } int main() { A a = createObject(); // 返回值优化 return 0; }
在这个例子中，编译器会进行优化，避免多次调用拷贝构造函数。
总结
本篇博客详细介绍了C++类与对象的高级特性，包括构造函数的初始化列表、类型转换、静态成员、友元、内部类、匿名对象以及对象拷贝时的编译器优化。这些特性不仅增强了代码的灵活性，也帮助开发者编写出更加高效的程序。理解这些内容将大大提升你对C++面向对象编程的理解能力，同时为编写健壮的应用程序奠定基础。
希望本文的详细讲解对你有帮助！如果有任何疑问或需要进一步的解释，欢迎在评论区留言讨论。
编辑
