C++ 类和对象进阶：初始化列表、static 成员与编译器优化

结果：输出 1 和一个随机垃圾值。 原因：_a2 先声明，先被初始化。此时 _a1 尚未初始化，值为随机。随后才初始化 _a1。

二、隐式类型转换与 explicit 关键字

单参数（或除第一个参数外其余都有默认值）的构造函数承担隐式类型转换作用。

class A {
public:
    A(int a) : _a(a) {}
private:
    int _a;
};
int main() {
    A obj1(2);       // 正常构造
    A obj2 = 3;      // 发生隐式类型转换
    return 0;
}

为禁止隐式转换，可在构造函数前加 explicit 关键字。

三、static 成员与面试题拆解

静态成员变量为所有类对象共享，不属于具体对象，存放在静态区，不计入 sizeof(对象)。

1. static 成员特性

• 存储：静态区，类外初始化。
• this 指针：静态成员函数没有 this 指针，不能访问非静态成员。
• 访问方式：推荐 类名::静态成员。

#include <iostream>
using namespace std;

class A {
public:
    A() { ++_scount; }
    A(const A& t) { ++_scount; }
    ~A() { --_scount; }
    static int GetACount() { return _scount; }
private:
    static int _scount;
};
// 静态成员变量必须类外初始化
int A::_scount = 0;

int main() {
    cout << A::GetACount() << endl;
    A a1, a2;
    A a3(a1);
    cout << A::GetACount() << endl;
    return 0;
}

2. 高频题：求 1+2+...+n

题目限制：不能使用乘除法、for、while、if、else、switch、case 等。 思路：利用对象生命周期，实例化 n 个对象触发 n 次构造函数累加。

class Sum {
public:
    Sum() { _ret += _i; ++_i; }
    static int GetRet() { return _ret; }
private:
    static int _i;
    static int _ret;
};
int Sum::_i = 1;
int Sum::_ret = 0;

class Solution {
public:
    int Sum_Solution(int n) {
        Sum arr[n];
        return Sum::GetRet();
    }
};

四、全局、局部、静态对象的构造与析构顺序

假设代码：

C c;
int main() {
    A a;
    B b;
    static D d;
    return 0;
}

• 构造顺序：全局对象最先（main 前），局部对象按顺序（main 内），静态局部对象首次执行到语句时。
  • 结论：C -> A -> B -> D
• 析构顺序：后构造的先析构（栈 LIFO）。局部对象先销毁，静态/全局对象最后销毁。
  • 结论：B -> A -> D -> C

五、友元：打破封装的'合法后门'

友元分为友元函数和友元类，允许外部访问私有成员。

1. 友元函数

class A {
    friend void func(const A& aa);
    int _a1 = 1;
};
void func(const A& aa) {
    cout << aa._a1 << endl;
}

2. 友元类

class A {
    friend class B;
    int _a1 = 1;
};
class B {
public:
    void PrintA(const A& aa) {
        cout << aa._a1 << endl;
    }
};

注意：友元具有单向性和不可传递性。工程中慎用，避免破坏封装。

六、内部类

内部类是定义在另一个类内部的类，完全独立，不影响外部类大小。

• 权限：内部类默认是外部类的友元，可访问外部类所有成员。
• 专属内部类：将内部类置于 private 区域，成为外部类专属。

class Solution {
private:
    class Sum {
    public:
        Sum() { _ret += _i; ++_i; }
    };
    static int _i;
    static int _ret;
public:
    int Sum_Solution(int n) {
        Sum arr[n];
        return _ret;
    }
};
int Solution::_i = 1;
int Solution::_ret = 0;

七、匿名对象和有名对象

• 有名对象：类型 对象名 (实参)，生命周期贯穿作用域。
• 匿名对象：类型 (实参)，生命周期仅限当前行。

// 高级写法
Solution().Sum_Solution(10);

八、对象拷贝时的编译器优化

现代编译器会优化传值和返回时的拷贝开销。

场景 A：参数传递优化

void f1(A aa) {}
int main() {
    f1(1);       // 优化为直接构造
    f1(A(2));    // 优化为直接构造
    return 0;
}

场景 B：传值返回优化 (RVO/NRVO)

A f2() {
    A aa;
    return aa;
}
int main() {
    A obj = f2();
    return 0;
}

• 无优化：1 次构造 + 2 次拷贝。
• NRVO 优化：直接在外部 obj 空间构造，0 次拷贝，仅 1 次构造。 建议：若必须传值返回，放心交给编译器优化，无需手动规避。