C++类和对象（三）：核心特性与实战技巧

在 C++ 面向对象编程中，类与对象的进阶特性是写出高效、规范代码的关键。本文将聚焦构造函数细节、静态成员、友元、内部类、匿名对象及编译器优化等核心知识点，结合实例拆解原理，帮你彻底吃透这些易混淆的重点。

一、再谈构造函数：初始化列表的核心规则

构造函数是对象创建的 "蓝图"，而初始化列表则是对象成员初始化的核心战场，掌握以下规则能避免大部分编译报错：

1. 初始化列表的本质

每个构造函数都隐含初始化列表，哪怕你没显式写出 ------所有成员变量都会通过初始化列表完成初始化，构造函数体中的赋值只是后续修改，并非真正的初始化。

初始化列表的语法格式：

cpp 复制代码

类名(参数列表)
    : 成员变量1(初始值1), 成员变量2(初始值2), ...
{
    // 构造函数体（可选赋值操作）
}

2. 必须在初始化列表初始化的成员

以下三类成员因 "必须在定义时初始化" 的特性，强制要求在初始化列表中显式初始化：

const 成员变量（如const int _n）：常量一旦定义无法修改

引用成员变量（如int& _ref）：引用必须绑定初始对象

无默认构造的自定义类型成员（如Time _t）：编译器无法自动调用默认构造

示例代码：

cpp 复制代码

class Time {
public:
    Time(int hour) : _hour(hour) {} // 无默认构造
private:
    int _hour;
};

class Date {
public:
    Date(int& xx, int year, int month, int day)
        : _year(year)
        , _month(month)
        , _day(day)
        , _n(5)          // const成员
        , _ref(xx)       // 引用成员
        , _t(1)          // 无默认构造的自定义类型
    {}
private:
    int _year;
    int _month;
    int _day;
    const int _n;
    int& _ref;
    Time _t;
};

3. 初始化顺序的关键注意

初始化列表的初始化顺序完全遵循成员变量在类中的声明顺序，与列表中的书写顺序无关。建议声明顺序与列表顺序保持一致，避免逻辑错误：

cpp 复制代码

class A {
public:
    A(int a)
        : _a1(a)
        , _a2(_a1) // 声明顺序是_a2在前，_a1在后，实际先初始化_a2
    {}
private:
    int _a2 = 2; // 先声明，先初始化
    int _a1 = 2; // 后声明，后初始化
};
// 输出：_a1=1，_a2=随机值（初始化_a2时_a1尚未初始化）

4. 成员变量的缺省值规则

C++11 支持在成员声明时指定缺省值，该值的作用是：当成员未在初始化列表显式初始化时，自动使用缺省值。注意这并非定义（仅声明阶段），内存分配仍在对象创建时进行：

cpp 复制代码

class Date {
private:
    int _year = 1; // 缺省值，初始化列表未写时使用
    int _month = 1;
    int _day = 1;
};

二、static 成员

static 修饰的成员属于整个类，而非单个对象，是实现类级共享数据的核心工具。

1. 静态成员变量的核心特性

存储位置：位于静态区，不占用对象内存（sizeof(类)不计入静态成员）

初始化：必须在类外初始化（类内仅声明），且不走构造函数初始化列表

共享性：所有对象共享同一实例，修改一个对象的静态成员会影响所有对象

访问权限：受 public/protected/private 限制，突破类域即可访问（类名::成员或对象.成员）

示例代码：

cpp 复制代码

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; // 类外初始化

// 访问示例
cout << A::GetACount() << endl; // 0（无需创建对象）
A a1, a2;
cout << a1.GetACount() << endl; // 2（对象访问）

2. 静态成员函数的限制

无 this 指针，无法访问非静态成员（非静态成员依赖具体对象）

可访问其他静态成员（静态成员属于类，全局唯一）

非静态成员函数可访问静态成员（拥有 this 指针，可间接访问类级资源）

3. 经典实战：静态成员实现累加求和

求 1+2+...+n，不使用循环、判断等关键字

cpp 复制代码

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 a[n]; // 创建n个对象，触发n次构造累加
        return Sum::GetRet();
    }
};

三、友元

友元提供了一种突破类访问权限的方式，允许外部函数或类访问私有 / 保护成员，但会破坏封装，需谨慎使用。

1. 友元函数

声明方式：在类内添加friend 函数声明，不受访问限定符限制

特性：不是类的成员函数，可访问多个类的私有成员

示例：

cpp 复制代码

class B; // 前置声明
class A {
    friend void func(const A& aa, const B& bb); // 友元声明
private:
    int _a1 = 1;
};
class B {
    friend void func(const A& aa, const B& bb);
private:
    int _b1 = 3;
};
void func(const A& aa, const B& bb) {
    cout << aa._a1 << endl; // 合法访问私有成员
    cout << bb._b1 << endl;
}

2. 友元类

声明方式：friend class 类名;

特性：友元类的所有成员函数都可访问当前类的私有成员，关系单向且不可传递

示例：

cpp 复制代码

class A {
    friend class B; // B是A的友元，A不是B的友元
private:
    int _a1 = 1;
};
class B {
public:
    void func(const A& aa) {
        cout << aa._a1 << endl; // 合法访问
    }
};

四、内部类

内部类是定义在另一个类内部的类，本质是独立的类，仅受外部类的类域和访问权限限制。

核心特性

独立性：外部类对象不包含内部类成员，sizeof(外部类)不计入内部类

友元关系：内部类默认是外部类的友元，可访问外部类的所有成员

访问限制：内部类的访问权限由外部类的访问限定符控制（如 private 内部类仅外部类可用）

示例：

cpp 复制代码

class A {
private:
    static int _k;
    int _h = 1;
public:
    class B { // 内部类，默认是A的友元
    public:
        void foo(const A& a) {
            cout << _k << endl; // 访问外部类静态成员
            cout << a._h << endl; // 访问外部类非静态成员
        }
    };
};
int A::_k = 1;

// 使用方式
A::B b; // 需通过外部类类域访问
A aa;
b.foo(aa);

五、匿名对象

匿名对象是无名称的对象，语法为类名(实参)，核心特点是生命周期仅当前行，适用于临时使用的场景。

示例：

cpp 复制代码

class A {
public:
    A(int a = 0) : _a(a) {}
    ~A() { cout << "~A()" << endl; }
private:
    int _a;
};

int main() {
    A(1); // 匿名对象，行尾自动析构
    Solution().Sum_Solution(10); // 临时对象调用成员函数，无需定义变量
}

六、对象拷贝的编译器优化

现代编译器会在不影响正确性的前提下，省略传参和返回值过程中的无意义拷贝，核心是优化连续的拷贝构造操作。

优化规则

优化场景：连续的 "构造 + 拷贝构造" 可合并为一次构造

不可优化：赋值重载（=）无法优化，需经历 "构造 + 拷贝构造 + 赋值" 流程

关闭优化：Linux 下使用g++ test.cpp -fno-elideconstructors编译，可观察完整拷贝流程

示例代码：

cpp 复制代码

A f2() { A aa; return aa; }

// 可优化：连续拷贝构造合并为一次构造
A aa2 = f2(); 

// 不可优化：赋值重载无法省略
A aa1;
aa1 = f2();

七、类型转换

C++ 支持内置类型与类类型的隐式转换，核心依赖对应构造函数：

隐式转换：当类有单参数构造函数时，内置类型可自动转换为类对象

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

多参数转换：C++11 支持A aa = {1,2};形式的多参数隐式转换

示例：

cpp 复制代码

class A {
public:
    // explicit A(int a) // 禁用隐式转换
    A(int a = 0) : _a1(a) {}
};

A aa1 = 1; // 隐式转换：1→临时对象→aa1（优化为直接构造）
const A& raa2 = 2; // 临时对象具有常性，需const引用接收