C++ 类与对象进阶：构造函数、静态成员与友元详解

这里 _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++ 代码。在实际开发中，合理运用初始化列表、控制类型转换、谨慎使用友元，都是提升代码质量的关键点。