C++构造函数与拷贝控制成员函数详解

1. 构造函数深度解析：从原理到实战

1.1 构造函数的本质与作用

构造函数是C++中用于初始化类对象的特殊成员函数。它的核心价值在于将对象的创建和初始化过程合二为一，彻底改变了C语言中"先分配内存再手动初始化"的繁琐模式。想象一下建筑工地：构造函数就像一支专业的施工队，在打好地基（分配内存）后自动完成房屋的主体建造（初始化），而不是只给你一块空地让你自己从头开始。

构造函数的关键特性体现在几个方面：

• 自动触发机制：对象实例化时由编译器自动调用，无需手动干预
• 重载能力：支持多种初始化方式，适应不同场景需求
• 默认生成：编译器会提供基础版本，但允许自定义实现

1.2 默认构造函数的三种形态

在C++中，默认构造函数实际上有三种合法形式，但三者不能共存：

1. 编译器生成的隐式默认构造

cpp复制class Widget {
    // 编译器自动生成默认构造函数
};

2. 显式定义的无参构造

cpp复制class Widget {
public:
    Widget() { /*...*/ }  // 手动定义无参版本
};

3. 全缺省参数的构造

cpp复制class Widget {
public:
    Widget(int x = 0, int y = 0) { /*...*/ }  // 所有参数都有默认值
};

重要提示：无参构造和全缺省构造虽然语法上构成重载，但实际调用时会产生歧义。编译器无法区分Widget()和Widget(0,0)的调用意图，因此实践中应当只选择其中一种形式。

1.3 内置类型与自定义类型的初始化差异

构造函数对不同类型的成员变量处理方式截然不同：

典型问题示例：

cpp复制class Inner {
public:
    Inner(int x) {}  // 非默认构造
};

class Outer {
    Inner obj;  // 错误！Inner缺少默认构造
    int num;    // 可能未初始化
};

解决方法是通过初始化列表显式初始化：

cpp复制class Outer {
public:
    Outer() : obj(0), num(0) {}  // 初始化列表
private:
    Inner obj;
    int num;
};

1.4 构造函数的实战应用

栈类的构造实现

cpp复制class Stack {
public:
    Stack(int capacity = 4)  // 带默认值的参数
        : _top(0), _capacity(capacity) {
        _data = new int[capacity];
        if(!_data) throw std::bad_alloc();
    }
    
private:
    int* _data;
    size_t _top;
    size_t _capacity;
};

关键技巧：

• 使用默认参数提供灵活性
• 在初始化列表中初始化基本类型
• 动态内存分配放在函数体内以便错误处理
• 通过异常处理分配失败情况

日期类的多版本构造

cpp复制class Date {
public:
    // 无参版本设置默认日期
    Date() : _year(1970), _month(1), _day(1) {}
    
    // 带参版本允许自定义日期
    Date(int y, int m, int d) {
        if(!isValid(y,m,d)) throw InvalidDate();
        _year = y;
        _month = m;
        _day = d;
    }
    
    // 带缺省参数的版本
    Date(int y=2000, int m=1) : _year(y), _month(m), _day(1) {}

private:
    bool isValid(int y, int m, int d) { /*...*/ }
    int _year, _month, _day;
};

2. 拷贝控制成员函数详解

2.1 拷贝构造函数的实现要点

拷贝构造函数用于通过已有对象创建新对象，其典型特征为：

• 参数为本类常引用
• 不修改源对象状态
• 实现深拷贝避免资源冲突

cpp复制class String {
public:
    String(const String& other) 
        : _size(other._size) {
        _data = new char[_size + 1];
        std::copy(other._data, other._data + _size + 1, _data);
    }
    
private:
    char* _data;
    size_t _size;
};

2.2 移动构造与右值引用

现代C++引入移动语义，通过转移资源所有权而非复制来提升效率：

cpp复制class String {
public:
    String(String&& other) noexcept
        : _data(other._data), _size(other._size) {
        other._data = nullptr;  // 置空源对象
        other._size = 0;
    }
};

使用场景：

• 临时对象传递时自动触发
• 显式通过std::move转换

2.3 赋值运算符的重载规则

赋值运算符需要处理自赋值情况并返回引用：

cpp复制String& operator=(const String& rhs) {
    if(this != &rhs) {  // 自赋值检查
        delete[] _data;
        _size = rhs._size;
        _data = new char[_size + 1];
        std::copy(rhs._data, rhs._data + _size + 1, _data);
    }
    return *this;
}

3. 特殊成员函数的综合应用

3.1 资源管理类的五法则

对于管理资源的类，通常需要定义以下五个特殊成员函数：

1. 析构函数
2. 拷贝构造函数
3. 拷贝赋值运算符
4. 移动构造函数
5. 移动赋值运算符

cpp复制class FileHandle {
public:
    ~FileHandle() { if(_handle) fclose(_handle); }
    
    FileHandle(const FileHandle&) = delete;  // 禁止拷贝
    
    FileHandle& operator=(const FileHandle&) = delete;
    
    FileHandle(FileHandle&& other) noexcept
        : _handle(other._handle) {
        other._handle = nullptr;
    }
    
    FileHandle& operator=(FileHandle&& rhs) noexcept {
        if(this != &rhs) {
            if(_handle) fclose(_handle);
            _handle = rhs._handle;
            rhs._handle = nullptr;
        }
        return *this;
    }
    
private:
    FILE* _handle;
};

3.2 现代C++的简化写法

C++11后可用=default和=delete简化特殊成员函数的声明：

cpp复制class Widget {
public:
    Widget() = default;  // 使用编译器生成版本
    ~Widget() = default;
    
    Widget(const Widget&) = delete;  // 禁止拷贝
    Widget& operator=(const Widget&) = delete;
    
    Widget(Widget&&) = default;  // 允许移动
    Widget& operator=(Widget&&) = default;
};

4. 实战经验与常见陷阱

4.1 构造函数中的异常处理

构造函数执行失败时，已构造的成员会被自动销毁：

cpp复制class ResourceHolder {
public:
    ResourceHolder() 
        : res1(new Resource),  // 可能抛出异常
          res2(new Resource) { // 如果这里抛出，res1会被自动释放
        // ...
    }
    
private:
    std::unique_ptr<Resource> res1;
    std::unique_ptr<Resource> res2;
};

最佳实践：

• 使用RAII对象管理资源
• 避免在构造函数中做复杂操作
• 考虑工厂函数替代直接构造

4.2 继承体系中的构造顺序

派生类构造时成员的初始化顺序：

1. 基类构造（按继承顺序）
2. 成员变量构造（按声明顺序）
3. 派生类构造体

cpp复制class Base {
public:
    Base() { cout << "Base\n"; }
};

class Member {
public:
    Member() { cout << "Member\n"; }
};

class Derived : public Base {
    Member m;
public:
    Derived() { cout << "Derived\n"; }
};

// 输出顺序：Base → Member → Derived

4.3 移动语义的注意事项

移动操作后源对象应处于有效但未定义状态：

cpp复制vector<int> createData() {
    vector<int> temp(1000000);
    // ...填充数据...
    return temp;  // 触发移动构造
}

void process() {
    auto data = createData();  // 高效移动而非复制
    // 此时temp已被移空但仍是合法状态
}

关键原则：

• 移动后源对象应可析构
• 不应假设源对象的具体值
• 可重新赋值继续使用