【初阶C++】类和对象（下）

目录

1. 再探构造函数：初始化列表核心机制 1.1 初始化列表基础语法与底层逻辑 1.2 三类必须使用初始化列表的成员（编译报错根源） 1.3 C++11 类内成员缺省值规则 1.4 致命坑：初始化顺序由声明顺序决定（真题解析） 1.5 成员初始化完整流程总结
2. 构造函数隐式类型转换 & explicit 关键字
3. static 静态成员（变量 + 函数）全解 3.1 静态成员变量特性、初始化规则 3.2 静态成员函数限制（无 this 指针） 3.3 实战 1：统计程序创建对象总个数 3.4 面试题：1+2+…+n（静态变量 + 构造函数巧解）
4. 友元机制（友元函数、友元类） 4.1 全局友元函数、多类共用友元 4.2 友元类三大特性：单向、不传递、不继承 4.3 友元优缺点与使用规范
5. 内部类（嵌套类） 5.1 核心特性：内部类独立、默认是外部类友元 5.2 访问权限控制（private 专属内部类）
6. 匿名对象 6.1 生命周期：仅当前一行，用完立即析构 6.2 业务场景：临时调用类方法简化代码
7. 对象拷贝编译器优化（RVO/NRVO 返回值优化） 7.1 传参优化：隐式转换、匿名对象传参 7.2 返回值优化：g++/VS2019/VS2022 差异说明 7.3 Linux 关闭拷贝优化编译命令
8. 全文面试速记总结

---

1 再探构造函数：初始化列表核心机制

1.1 初始化列表基础语法

之前写构造函数，我们习惯在函数体内赋值，但 C++ 提供更底层、高效的初始化方式：初始化列表。 语法规则：

1. 构造函数参数列表后加 : 冒号开头
2. 逗号分隔成员列表，格式 成员名(初始值/表达式)
3. 执行时机：内存开辟完成后、构造函数体执行前
4. 每个成员在初始化列表只能出现一次（只能初始化一次）

基础示例代码：

cpp

运行

#include<iostream>
using namespace std;
class Date
{
public:
    // 初始化列表初始化三个成员
    Date(int year, int month, int day)
        :_year(year)
        ,_month(month)
        ,_day(day)
    {
        // 函数体内此时成员已经初始化完成，这里仅能赋值
    }
    void Print() const
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};

底层本质区别（面试必背）

• 初始化列表：对象刚分配内存，直接给成员赋初始值，仅执行一次构造，效率更高
• 函数体内赋值：成员先默认初始化，再覆盖赋值；内置类型无明显损耗，自定义类型会多一次拷贝，性能较差

开发规范：所有成员优先使用初始化列表初始化

1.2 三类必须写在初始化列表的成员（不写直接编译报错）

C++ 语法硬性规定，以下成员无法在构造函数体内赋值，只能在初始化列表初始化：

1. 引用成员变量：引用创建时必须绑定有效变量，不存在 “空引用”，无法后期赋值
2. const 修饰成员变量：const 对象创建后值不可修改，仅初始化阶段能赋值
3. 无默认构造函数的自定义类型成员：创建对象时会自动调用成员无参默认构造，无默认构造则直接报错，必须手动在初始化列表调用带参构造

报错复现完整代码（PPT 原题）

cpp

运行

#include<iostream>
using namespace std;

class Time
{
public:
    // Time只有带参构造，无默认构造Time()
    Time(int hour)
        :_hour(hour)
    {
        cout << "Time构造" << endl;
    }
private:
    int _hour;
};

class Date
{
public:
    // 错误写法：未初始化_t、_ref、_n，触发三个编译错误
    Date(int& x, int year = 1, int month = 1, int day = 1)
        :_year(year)
        ,_month(month)
        ,_day(day)
    {
        // 三个报错原文：
        // error C2512: “Time”: 没有合适的默认构造函数可用
        // error C2530 : “Date::_ref” : 必须初始化引用
        // error C2789 : “Date::_n” : 必须初始化常量限定类型的对象
        _ref = x;    // ❌ 引用不能赋值，只能初始化绑定
        _n = 1;      // ❌ const变量不可修改
    }
private:
    int _year;
    int _month;
    int _day;
    Time _t;       // 无默认构造的自定义成员
    int& _ref;     // 引用成员
    const int _n;  // const常量成员
};

int main()
{
    int i = 0;
    Date d1(i);
    d1.Print();
    return 0;
}

修复后的正确构造函数

cpp

运行

Date(int& x, int year = 1, int month = 1, int day = 1)
    :_year(year)
    ,_month(month)
    ,_day(day)
    ,_t(12)      // 手动调用Time带参构造
    ,_ref(x)     // 引用绑定外部变量x
    ,_n(1)       // const成员初始化赋值
{}

补充说明：参数 int& x 核心作用 —— 接收外部左值变量，用来初始化内部引用成员_ref；如果传值int x，x 是函数局部变量，绑定后会形成悬空引用，程序运行崩溃。

1.3 C++11 类内成员缺省值规则

C++11 新增特性：可以在类声明成员时直接给默认值，这个值仅作为初始化列表的后备方案：

1. 如果成员在初始化列表显式初始化：优先使用列表的值，类内缺省值失效
2. 如果初始化列表未显式初始化该成员：自动使用类内写的缺省值初始化
3. 静态成员变量不支持类内缺省值（静态成员不属于对象，不走对象初始化流程）

完整测试代码（PPT 选择题原题）

cpp

运行

#include<iostream>
using namespace std;
class Time
{
public:
    Time(int hour)
        :_hour(hour)
    {
        cout << "Time()" << endl;
    }
private:
    int _hour;
};

class Date
{
public:
    // 初始化列表只显式初始化_month
    Date()
        :_month(2)
    {
        cout << "Date()" << endl;
    }
    void Print() const
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
private:
    int _year = 1;    // 类内缺省值
    int _month = 1;   // 列表显式初始化为2，覆盖缺省值
    int _day;         // 无缺省值、无列表初始化，内置随机垃圾值
    Time _t = 1;      // 等价_t(1)，自动调用Time(int)构造
    const int _n = 1; // const成员类内缺省值合法
};

int main()
{
    Date d1;
    d1.Print(); // 输出：1-2-随机值，选择题正确答案：E
    return 0;
}

选择题解析：

• _year：列表未初始化，使用缺省值1
• _month：列表显式赋值2，覆盖类内默认1
• _day：无缺省值、无列表初始化，内置类型随机垃圾值 对应选项：E. 输出 1 2

1.4 致命坑：初始化顺序由类内声明顺序决定（真题）

核心规则

成员初始化顺序 = 成员在类中从上到下声明顺序，和初始化列表书写顺序完全无关 错误写法极易使用未初始化变量，产生未定义行为，是高频面试坑。

真题完整代码

cpp

运行

#include<iostream>
using namespace std;
class A
{
public:
    A(int a)
        :_a1(a)
        , _a2(_a1) // 视觉上先初始化_a1再_a2，实际执行顺序相反
    {}
    void Print() {
        cout << _a1 << " " << _a2 << endl;
    }
private:
    int _a2 = 2; // 声明顺序1：最先初始化_a2
    int _a1 = 2; // 声明顺序2：后初始化_a1
};

int main()
{
    A aa(1);
    aa.Print();
    return 0;
}

执行流程拆解

1. 类内声明顺序：先_a2，再_a1
2. 初始化顺序固定：先构造_a2，再构造_a1
3. _a2(_a1)执行时，_a1还未初始化，使用类内缺省值2赋值给_a2
4. 之后_a1(a)用传入参数1赋值

最终输出结果：1 2

开发规范：初始化列表书写顺序，严格和类内成员声明顺序保持一致，规避隐藏 bug

1.5 成员初始化完整流程总结

1. 优先判断是否在初始化列表显式初始化成员：是 → 直接使用列表值初始化
2. 未显式初始化分两条分支： 2.1 类内声明写了缺省值：使用缺省值初始化 2.2 类内无缺省值：
   • 内置类型：随机垃圾值（C++ 标准未规定，不同编译器结果不同）
   • 自定义类型：调用默认构造函数，无默认构造直接报错
   • 引用 /const/ 无默认构造成员：必须显式初始化，否则编译报错

---

2 构造函数隐式类型转换 & explicit 关键字

2.1 隐式转换规则

单参数构造函数（C++11 支持多参数{}列表），支持内置类型隐式转为类对象：

cpp

运行

#include<iostream>
using namespace std;
class A
{
public:
    // 单参数构造，默认允许隐式转换
    A(int a1)
        :_a1(a1)
    {}
    int Get() const
    {
        return _a1;
    }
private:
    int _a1 = 1;
};

int main()
{
    A aa1 = 1; // 隐式转换：1生成A临时对象，编译器优化直接构造aa1
    const A& aa2 = 1; // 临时对象绑定const左值引用，语法合法
    return 0;
}

多参数构造 C++11 列表初始化隐式转换：

cpp

运行

class A
{
public:
    A(int a1, int a2)
        :_a1(a1),_a2(a2)
    {}
private:
    int _a1,_a2;
};
A aa3 = {2,2}; // 隐式转换，匹配双参构造

类之间隐式转换示例：

cpp

运行

class B
{
public:
    // 参数为A对象，支持A隐式转B
    B(const A& a)
        :_b(a.Get())
    {}
private:
    int _b = 0;
};
A aa3(5);
B b = aa3; // aa3(A)隐式转换为B对象

2.2 explicit 关键字禁止隐式转换

在构造函数前加explicit，关闭隐式转换，仅能显式调用构造创建对象：

cpp

运行

explicit A(int a1)
    :_a1(a1)
{}
// A aa1 = 1;  // 编译报错，禁止隐式转换
A aa1(1);      // 合法，显式构造调用

开发规范：所有单参数构造函数统一添加explicit，杜绝无意隐式转换引发的隐藏 bug

---

3 static 静态成员（变量 + 函数）全解

3.1 静态成员变量核心特性

1. 不属于任何对象，属于整个类：所有对象共享同一份内存，存储在静态全局区，不在对象栈 / 堆内存中
2. 必须在类外初始化：类内只是声明，不会分配内存；类外定义分配内存，初始化语句不能带static关键字
3. 访问权限遵循public/protected/private，私有静态成员无法在类外直接访问
4. 不支持类内缺省值、不能写入初始化列表（不走对象初始化流程）

基础示例：

cpp

运行

class Sum
{
private:
    static int _i;   // 类内声明，无内存分配
    static int _ret; // 类内声明
};
// 类外初始化，全局仅执行一次
int Sum::_i = 1;
int Sum::_ret = 0;

3.2 静态成员函数规则

1. 无隐藏 this 指针：this 指针指向当前实例对象，静态函数不属于对象，因此不存在 this
2. 仅能访问静态成员变量 / 静态函数，无法访问非静态成员（无 this 无法获取对象普通成员）
3. 两种调用方式：类名::静态函数() / 对象.静态函数()，推荐类名调用可读性更强

cpp

运行

static int GetRet()
{
    return _ret; // 仅能访问静态_i、_ret
    // cout << _year; ❌ 非法，_year是非静态成员，无this指针
}

3.3 实战 1：统计程序创建对象总个数

实现思路：静态计数器，普通构造、拷贝构造每创建对象计数器自增，析构函数自减

cpp

运行

#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; // 初始0
    A a1, a2;    // 2次构造，计数=2
    A a3(a1);    // 拷贝构造，计数=3
    cout << A::GetACount() << endl; // 输出3
    cout << a1.GetACount() << endl; // 对象也可调用静态函数
    // cout << A::_scount << endl; ❌ _scount私有，外部无法直接访问
    return 0;
}

3.4 面试经典题：求 1+2+…+n（禁止循环 /if/ 递归判断）

解题思路

1. 静态变量_i记录当前累加数字，_ret存储累加总和
2. 创建 n 个 Sum 对象，每个对象构造函数执行一次累加，用构造函数替代循环
3. Sum arr[n];变长数组 VLA：仅 GCC 编译器扩展，标准 C++ 不支持，VS 编译报错；兼容写法new Sum[n]

完整可复用代码（修复重复调用 bug）

cpp

运行

#include<iostream>
using namespace std;
class Sum
{
public:
    Sum()
    {
        _ret += _i;
        ++_i;
    }
    static int GetRet()
    {
        return _ret;
    }
    // 重置静态变量，支持多次调用求和函数
    static void Reset()
    {
        _i = 1;
        _ret = 0;
    }
private:
    static int _i;
    static int _ret;
};
int Sum::_i = 1;
int Sum::_ret = 0;

class Solution {
public:
    int Sum_Solution(int n) {
        Sum::Reset();
        // Sum arr[n]; // 变长数组VLA，非标准C++，VS直接报错
        Sum* arr = new Sum[n];
        delete[] arr;
        return Sum::GetRet();
    }
};

int main()
{
    Solution s;
    cout << s.Sum_Solution(3) << endl;  // 输出6 (1+2+3)
    cout << s.Sum_Solution(5) << endl;  // 输出15
    return 0;
}

关键缺陷说明

1. VLA 变长数组仅 GCC 支持，MSVC (VS) 不识别，必须用 new 堆数组替代
2. 静态变量全局只初始化一次，多次调用求和函数必须手动重置_i、_ret，否则累加数值错乱
3. 底层原理：数组有 n 个元素，创建时自动调用 n 次无参构造函数，用构造函数逻辑替代循环

拓展：内部类版本求和（PPT 补充写法）

cpp

运行

class Solution {
    // Sum是Solution私有内部类
    class Sum
    {
    public:
        Sum()
        {
            _ret += _i;
            ++_i;
        }
    };
public:
    static int _i;
    static int _ret;
    int Sum_Solution(int n) {
        _i = 1;
        _ret = 0;
        Sum* arr = new Sum[n];
        delete[] arr;
        return _ret;
    }
};
int Solution::_i = 1;
int Solution::_ret = 0;

---

4 友元机制（友元函数、友元类）

友元核心作用：临时突破类封装，让外部函数 / 其他类直接访问当前类private/protected私有成员；破坏面向对象封装，非必要不使用

4.1 全局友元函数

1. 友元声明写在类内部任意位置（public/private/protected 不影响友元生效）
2. 友元函数不是类成员函数，无 this 指针，访问成员必须传入对象参数
3. 一个函数可以同时作为多个类的友元

完整示例代码

cpp

运行

#include<iostream>
using namespace std;
// 前置声明B，否则A中友元无法识别B类
class B;

class A
{
    // 全局函数func是A的友元
    friend void func(const A& aa, const B& bb);
private:
    int _a1 = 1;
    int _a2 = 2;
};

class B
{
    // 同一个func也是B的友元
    friend void func(const A& aa, const B& bb);
private:
    int _b1 = 3;
    int _b2 = 4;
};

// 友元函数，可直接访问A、B私有成员
void func(const A& aa, const B& bb)
{
    cout << aa._a1 << endl;
    cout << bb._b1 << endl;
}

int main()
{
    A aa;
    B bb;
    func(aa, bb);
    return 0;
}

4.2 友元类 & 三大核心必背特性

语法：friend class 类名;，声明后目标类所有成员函数都能访问当前类私有成员 三大特性：

1. 单向性：A 声明 B 为友元，B 能访问 A，A 不能访问 B
2. 不可传递：B 是 A 友元、C 是 B 友元，C≠A 友元（朋友的朋友不是朋友）
3. 不可继承：友元关系不会被子类继承

示例代码：

cpp

运行

#include<iostream>
using namespace std;
class A
{
    friend class B; // B是A的友元类
private:
    int _a1 = 1;
    int _a2 = 2;
};

class B
{
public:
    void func1(const A& aa)
    {
        cout << aa._a1 << endl; // ✅ B可访问A私有成员
    }
private:
    int _b1 = 3;
};

int main()
{
    A aa;
    B bb;
    bb.func1(aa);
    return 0;
}

4.3 友元优缺点总结

优点：简化跨类数据访问，运算符重载场景经常使用友元 缺点：破坏面向对象封装，提高代码耦合度，降低后期代码可维护性 开发规范：优先提供 public Get/Set 接口替代友元，仅运算符重载等特殊场景使用

---

5 内部类（嵌套类）

定义在另一个类内部的类称为内部类，外部包裹的类称为外部类

5.1 核心特性

1. 内部类是完全独立的类：外部类对象内存中不包含内部类，sizeof(外部类)大小不受内部类影响
2. 内部类默认是外部类的友元：可直接访问外部类所有私有 / 静态成员
3. 受外部类访问限定符控制：
   • public 内部类：类外可通过外部类::内部类创建对象
   • private 内部类：仅外部类内部可用，外部无法访问，适合做专属工具类
4. 外部类不能直接访问内部类私有成员，无天然友元关系

完整测试代码

cpp

运行

#include<iostream>
using namespace std;
class A
{
private:
    static int _k;  // 外部类静态私有成员
    int _h = 1;     // 外部类普通私有成员
public:
    // public内部类B
    class B
    {
    public:
        void foo(const A& a)
        {
            cout << _k << endl;    // ✅ 直接访问外部类静态私有
            cout << a._h << endl;  // ✅ 内部类默认友元，访问普通私有
        }
    private:
        int _b1;
    };
    void test()
    {
        B b; // 外部类内部可创建私有/公有内部类对象
    }
};
// 外部类静态成员初始化
int A::_k = 1;

int main()
{
    cout << sizeof(A) << endl; // 仅4字节(_h)，不含内部类B
    A::B b; // public内部类，类外可创建
    A aa;
    b.foo(aa);
    return 0;
}

5.2 使用场景

两个类高度耦合，内部类仅为外部类服务时，定义为private内部类，隐藏内部实现细节，减少全局类污染；前文求和题的内部类 Sum 就是典型应用场景。

---

6 匿名对象

6.1 定义与生命周期

语法：类名(实参)，无对象名的临时对象 核心特点：生命周期仅当前一行代码，本行执行完毕立即调用析构销毁 对比有名对象：生命周期为当前{}代码块，代码块结束才析构

示例代码：

cpp

运行

#include<iostream>
using namespace std;
class A
{
public:
    A(int a = 0)
        :_a(a)
    {
        cout << "构造A()" << endl;
    }
    ~A()
    {
        cout << "析构~A()" << endl;
    }
private:
    int _a;
};

int main()
{
    A aa1; // 有名对象，main函数结束才析构
    cout << "----分割线----" << endl;
    A();   // 匿名对象，本行结束立即析构
    A(1);  // 带参匿名对象，本行销毁
    cout << "----分割线----" << endl;
    return 0;
}

6.2 实用场景：临时调用类方法，无需创建变量

仅调用一次类函数，不需要保存对象时，匿名对象简化代码：

cpp

运行

class Solution {
public:
    int Sum_Solution(int n) {
        return n*(n+1)/2;
    }
};

int main()
{
    // 传统写法：创建有名对象再调用
    Solution s;
    cout << s.Sum_Solution(10) << endl;
    // 匿名对象简化写法，用完直接销毁
    cout << Solution().Sum_Solution(10) << endl;
    return 0;
}

补充限制

A aa1(); 不是匿名对象，编译器识别为无参函数声明；想要创建无参匿名对象只能写A();

---

7 对象拷贝编译器优化（RVO/NRVO 返回值优化）

现代编译器自动优化拷贝构造，减少临时对象拷贝开销；C++ 标准未规定优化细节，不同编译器行为存在差异

7.1 传参场景优化

1. f1(1)：内置类型隐式构造临时对象，连续构造 + 拷贝构造，编译器优化为直接构造，无多余拷贝
2. f1(A(2))：匿名对象传参，同一表达式内连续构造拷贝，优化为直接构造，不生成临时拷贝

7.2 返回值场景优化说明

1. g++ 关闭优化 -fno-elide-constructors：完整执行构造→拷贝临时→拷贝给外部对象，两次拷贝构造
2. VS2019 Debug：优化一次，减少一次拷贝构造
3. VS2022 Debug：极致优化，直接在外部对象内存构造局部对象，无任何拷贝

完整测试代码

cpp

运行

#include<iostream>
using namespace std;
class A
{
public:
    A(int a = 0)
        :_a1(a)
    {
        cout << "A(int a) 构造" << endl;
    }
    A(const A& aa)
        :_a1(aa._a1)
    {
        cout << "A(const A&) 拷贝构造" << endl;
    }
    A& operator=(const A& aa)
    {
        cout << "operator= 赋值重载" << endl;
        if (this != &aa)
            _a1 = aa._a1;
        return *this;
    }
    ~A()
    {
        cout << "~A() 析构" << endl;
    }
private:
    int _a1 = 1;
};

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

int main()
{
    A aa1;
    f1(aa1); // 传入有名对象，触发拷贝构造
    cout << endl;

    f1(1);    // 隐式转换优化，无拷贝
    f1(A(2)); // 匿名对象传参优化
    cout << endl;

    cout << "====返回值测试====" << endl;
    f2();
    A aa2 = f2();
    aa1 = f2();
    return 0;
}

Linux g++ 关闭拷贝优化编译命令

bash

g++ test.cpp -o test -fno-elide-constructors

关闭优化后可以完整观察拷贝构造调用流程，方便理解底层对象创建销毁逻辑

7.3 优化总结

1. 同一表达式内连续构造 + 拷贝，编译器一定会合并优化，消除临时对象
2. 赋值场景aa1 = f2()无法完全消除拷贝，会调用赋值运算符重载
3. 优化仅提升程序运行性能，不会改变代码逻辑；开发无需手动处理，了解原理应对面试即可

---

全文面试速记清单

1. 初始化列表：引用 /const/ 无默认构造成员必须列表初始化，初始化顺序只看类内声明顺序
2. explicit 关键字：禁止单参数构造隐式类型转换，规范开发必加
3. static 静态成员：类外初始化、无 this 指针、全类对象共享，可实现对象计数、求和巧解
4. 友元：单向、不可传递、不可继承，破坏封装，谨慎使用
5. 内部类：完全独立，默认是外部类友元，适合封装专属工具逻辑
6. 匿名对象：生命周期仅一行，临时调用类方法简化代码
7. 返回值 RVO 优化：编译器自动消除多余拷贝，不同编译器优化程度不同