在前文基础上，我们继续深入 C++ 类的高级特性。这部分内容涵盖了构造函数的初始化细节、类型转换机制、静态成员管理、友元权限控制以及对象生命周期优化。掌握这些知识点，能让你的面向对象设计更加稳健高效。
一、再谈构造函数
构造函数负责对象的初始化。每次实例化时它都会自动调用。除了基础用法，这里有一些高级技巧值得注意。
1.1 初始化方式的选择
给成员变量赋值主要有两种方式：构造函数体内赋值和初始化列表。
传统方式是在函数体内直接赋值：
class Person {
public:
Person(int age) { _age = age; }
private:
int _age;
};
这种方式虽然直观，但效率稍低。因为成员变量会先经历默认初始化，再在函数体内被赋值，相当于做了两次操作。
推荐使用初始化列表。语法上在参数列表后加冒号 :，直接在创建阶段完成初始化：
class Person {
public:
Person(int age) : _age(age) {}
private:
int _age;
};
这样能避免不必要的默认初始化开销，性能更好。
1.2 必须使用初始化列表的场景
有些情况初始化列表是唯一选择，否则编译会报错：
- 引用成员变量：引用必须在定义时绑定，不能后续赋值。
- 常量成员变量：
const成员一旦初始化就不能修改。 - 无默认构造函数的类类型成员：如果成员是另一个类且该类没有默认构造函数，必须显式初始化。
示例如下：
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 初始化顺序规则
虽然你在初始化列表中写的顺序可以随意，但实际执行顺序严格遵循成员变量在类中声明的顺序。
class Example {
private:
int _x;
int _y;
public:
Example(int x, int y) : _y(y), _x(x) {} // 实际上 _x 仍会先于 _y 初始化
};
这可能导致依赖关系混乱。建议保持初始化列表顺序与声明顺序一致，避免潜在风险。
1.4 成员变量的缺省值
C++11 支持在类内直接为成员赋初值，简化了构造函数逻辑：
class Person {
private:
int _age = 18;
std::string _name = "Unnamed";
};
即使构造函数不传参，这些默认值也会生效，增加了灵活性。
二、类型转换
C++ 允许在不同类型间进行转换，主要通过构造函数或转换运算符实现。理解隐式和显式转换的控制对防止 Bug 很重要。
2.1 隐式类型转换
如果一个类有接受单个参数的构造函数，编译器会自动将参数转换为该类的对象：
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
}
这种便利有时会带来隐患，比如意外触发转换导致逻辑错误。
2.2 使用 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; // 编译错误
A obj(10); // 必须显式调用
obj.print();
}
加上 explicit 后，必须显式构造对象，代码意图更明确。
2.3 类型转换运算符
反过来，也可以定义将类对象转换为其他类型的运算符：
class A {
public:
A(int a) : _a(a) {}
operator int() { return _a; }
private:
int _a;
};
int main() {
A obj(10);
int num = obj; // 隐式调用 operator int()
cout << "num: " << num << endl;
}
三、静态成员 (static)
静态成员属于类本身，而非某个具体对象。所有对象共享同一份静态数据。
3.1 静态成员变量
静态变量必须在类外初始化：
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
}
3.2 静态成员函数
静态函数没有 this 指针，只能访问静态成员，不能访问非静态成员。通常通过类名直接调用：
class Example {
public:
static void staticFunc() { cout << "Static function." << endl; }
};
int main() {
Example::staticFunc();
return 0;
}
四、友元 (Friend)
友元机制打破了封装限制，允许特定函数或类访问私有成员。使用时需谨慎，以免破坏安全性。
4.1 友元函数
外部函数声明为友元后，可访问类的私有数据：
class Box {
friend void showBox(const Box& b);
private:
int _length = 10;
int _width = 5;
};
void showBox(const Box& b) {
cout << "Length: " << b._length << ", Width: " << b._width << endl;
}
4.2 友元类
一个类声明为另一个类的友元后，其所有成员函数都能访问对方的私有成员。注意这是单向的：
class Engine;
class Car {
friend class Engine;
private:
int _horsePower = 300;
};
class Engine {
public:
void showHorsePower(const Car& c) {
cout << "HP: " << c._horsePower << endl;
}
};
int main() {
Car myCar;
Engine myEngine;
myEngine.showHorsePower(myCar);
}
五、内部类
内部类定义在另一个类中，用于紧密关联的逻辑封装。内部类默认可以访问外部类的私有成员：
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);
}
六、匿名对象
匿名对象是没有名称的临时对象，生命周期仅限于当前语句。常用于简化临时计算：
class A {
public:
A() { cout << "A()" << endl; }
~A() { cout << "~A()" << endl; }
};
int main() {
A(); // 创建后立即销毁
return 0;
}
七、对象拷贝优化
编译器会对返回值进行优化（RVO），减少拷贝构造函数的调用，提升性能：
class A {
public:
A() { cout << "A()" << endl; }
A(const A&) { cout << "Copy" << endl; }
~A() { cout << "~A()" << endl; }
};
A createObject() {
A obj;
return obj; // 编译器可能省略拷贝
}
int main() {
A a = createObject();
return 0;
}
理解这些机制有助于编写更高效、安全的 C++ 代码。在实际开发中，合理运用初始化列表、控制类型转换、谨慎使用友元，都是提升代码质量的关键点。
