原来 C++ 这么简单：每日十题轻松学（Day 3 构造与对象行为篇）-CSDN博客

本文链接：https://blog.csdn.net/Interview_TC/article/details/146802087

📘 本篇围绕 C++ 中对象的构造、初始化、资源管理、函数行为、内存模型等展开深入讲解，含丰富示例与最佳实践，帮你真正吃透构造函数背后的原理与规律。

在这里插入图片描述

🔁 Day 2 快速回顾：继承 & 多态核心复盘

知识点	核心要点
运算符重载	提升类的“原生可操作性”，注意语义一致性
公有继承	表示 is-a，组合表示 has-a
多态	虚函数 + 父类指针/引用 + override 实现
抽象类	包含纯虚函数，无法直接实例化
深拷贝	独立资源复制，避免共享资源引发悬空或重复释放

✨ Day 3 目标：构造语义、explicit 限制、友元、静态与内存模型

✅ 1. 构造函数有哪些类型？如何正确使用？

核心问题：

构造函数有哪几种类型？
它们分别在什么场景被自动调用？
如何写出合理、健壮的构造函数组合？

解答结构：

类型	特征	使用场景
默认构造函数	无参或所有参数都有默认值	容器创建对象、数组初始化
有参构造函数	接受参数，初始化成员	明确初始化成员、提供灵活构造方式
拷贝构造函数	`ClassName(const ClassName &)`	值传递、函数返回
移动构造函数	`ClassName(ClassName &&)`（右值引用）	用于优化临时对象的资源转移

示例：

class Book {
    std::string title;
public:
    Book();                              // 默认
    Book(const std::string &title);      // 有参
    Book(const Book &b);                 // 拷贝
    Book(Book &&b) noexcept;             // 移动
};

建议：

构造函数参数应尽量使用 const &
如果类涉及资源管理，优先实现拷贝/移动构造和赋值函数（Rule of 5）

✅ 2. 拷贝构造函数的作用是什么？有哪些典型陷阱？

延伸问： 哪些场景会“隐式调用”拷贝构造函数？

核心用途：

初始化新对象：

Book b1("C++");
Book b2 = b1; // 拷贝构造

函数按值传参、返回值：

void func(Book b); // 传参时拷贝
return b1;         // 返回时拷贝（可能优化）

典型陷阱：

忘记自定义拷贝构造导致浅拷贝问题，特别是类含指针资源时。
自定义拷贝构造函数时，不小心复制不完整、丢失资源。

反例：

class Buffer {
    char* data;
public:
    Buffer(const Buffer &b) {
        data = b.data; // ❌ 浅拷贝，两个对象共享一块内存
    }
};

✅ 3. 移动构造函数是如何提升性能的？

延伸问： 哪些操作会触发移动构造而不是拷贝构造？

移动构造函数的本质： 把“资源所有权”从一个对象搬给另一个，而不是复制内容。

语法：

Book(Book &&other) noexcept;

典型场景：

返回局部对象时
std::vector 重新分配元素时
使用 std::move() 进行手动触发

性能优势：

减少堆资源分配/释放
减少数据复制操作

使用建议：

移动构造应加 noexcept 以便 STL 优化使用

✅ 4. 为什么需要 `explicit` 构造函数？

延伸问： 不加 explicit 会出现什么意想不到的行为？

问题演示：

class Meter {
public:
    Meter(double val); // 非 explicit
};

void print(Meter m);

print(5.0); // 隐式构造 Meter(5.0)

可能导致的错误：

构造函数被当作隐式类型转换，可能引起不清晰、甚至危险的行为。

推荐做法：

explicit Meter(double val); // 强制显示构造

✅ 5. 构造函数初始化列表与构造体赋值的区别？

延伸问： 哪些成员只能通过初始化列表初始化？

初始化列表的优势：

const 成员只能用初始化列表
引用成员也必须在初始化列表中初始化
避免构造后再赋值（更高效）

反例：

class A {
    const int x;
public:
    A(int val) { x = val; } // ❌ 错，const 无法赋值
};

改为：

A(int val) : x(val) {} // ✅

✅ 6. 友元函数是什么？是否违反封装原则？

延伸问： 什么时候该用友元？什么时候应避免？

定义：
友元函数可访问类的私有/保护成员。

典型应用：

operator<< 重载：

friend std::ostream& operator<<(std::ostream &os, const Book &b);

封装角度：

虽然破坏封装，但如果函数是“类外行为”，使用友元比开公共接口更清晰。

使用建议：

合理使用友元是高级设计技巧，但应避免成为懒人接口。

✅ 7. 静态成员变量和函数的作用？

延伸问： 静态成员是否属于对象？能否访问非静态成员？

特性	静态成员
归属	属于类，不属于对象
初始化	类外初始化（或 C++17 内部初始化）
访问方式	可通过类名或对象访问
限制	静态函数不能访问非静态成员

示例：

class Counter {
    static int count;
public:
    Counter() { ++count; }
    static int getCount() { return count; }
};
int Counter::count = 0;

✅ 8. 对象的内存布局是怎样的？

延伸问： 对象的成员顺序、对齐规则会影响什么？

对象布局特点：

按成员声明顺序排列
编译器可能插入“填充字节”进行对齐
存在虚函数时，会有隐藏的虚表指针（通常在对象开头）

示例：

class A {
    char c;   // 1 字节
    int x;    // 4 字节（对齐）
};

sizeof(A) 通常为 8（1+3填充 + 4）

建议：

注意字节对齐带来的空间浪费
多数时候不必优化，但对内存敏感场景（嵌入式）需注意

✅ 9. new/delete 与构造/析构的调用关系？

延伸问： 如果 new 失败，构造函数会执行吗？

机制：

new 做两件事：1）分配内存 → 2）调用构造函数
delete：先调用析构函数 → 然后释放内存

示例：

Book* p = new Book(); // 调构造
delete p;             // 调析构

注意：

若构造函数抛异常，内存将自动释放，但析构不会被调用

✅ 10. Rule of Three / Five：资源安全的守则

核心规则：

条件	推荐操作
类中包含指针/手动资源管理	实现拷贝构造、赋值运算符、析构函数
需要高性能、支持移动语义（如 STL 容器）	加上移动构造、移动赋值

完整示例：

class Buffer {
    char* data;
public:
    Buffer(const Buffer&);
    Buffer& operator=(const Buffer&);
    ~Buffer();
    Buffer(Buffer&&) noexcept;
    Buffer& operator=(Buffer&&) noexcept;
};

建议：

如果不希望类被复制，明确删除拷贝构造和赋值函数（C++11）：

Buffer(const Buffer&) = delete;
Buffer& operator=(const Buffer&) = delete;

📚 总结口诀（加强版）

构造四大类：默认、有参、拷贝、移动；
拷贝慎资源，移动更高效；
explicit 防暗转，类型清晰妙；
列表初始化，效率安全高；
友元慎开放，语义得思考；
静态类共享，函数非成员；
内存有对齐，对象有顺序；
new delete 成对走，异常无析构；
规则三与五，管理不可少；
delete 明态度，拒绝乱复制。