当前位置：首页 > news >正文

5、类的6个默认成员函数和特性--类的新功能

news 来源：原创 2025/5/17 10:44:03

一、首先要了解构造函数6大类【不是特性】

1. 构造函数 (Constructor)

class MyClass {
public:
    // 默认构造函数
    MyClass() : data(0) {}
    
    // 带参数构造函数
    MyClass(int val) : data(val) {}
    
private:
    int data;
};

2. 析构函数 (Destructor)

class MyClass {
public:
    ~MyClass() {
        // 清理资源
    }
};

3. 拷贝构造函数 (Copy Constructor)

class MyClass {
public:
    // 拷贝构造函数
    MyClass(const MyClass& other) : data(other.data) {}
    
private:
    int data;
};

拷贝构造函数的参数只有一个且必须使用引用传参，否则使用传值方式会引发无穷递归调用。
- 这里的理解可能比较困难。你可以想象，你使用一个带参数的函数，就要先传参再使用函数。下图的Date(const Date d)参数是另一个新的函数const Date d ，为了获得这个const Date d ，就需要构造这个const Date d ，又要传入一个const Date d，反反复复就导致递归了。
调用拷贝构造的方式是 MyClass new_object(old_object)或MyClass new_object = old_object的写法 。把旧对象的传入到新的对象里。
其过程，如下图

4. 拷贝赋值函数 (Copy Assignment Operator)

class MyClass {
public:
    // 拷贝赋值运算符
    MyClass& operator=(const MyClass& other) {
        if (this != &other) {  // 防止自赋值
            data = other.data;
        }
        return *this;
    }
    
private:
    int data;
};

那么如何区分拷贝构造和拷贝复制呢？
如下图：

5. 取地址重载函数 (Address-of Operator)

class MyClass {
public:
    // 取地址运算符重载
    MyClass* operator&() {
        return this;// 返回假地址
    }
};

6. const 取地址重载函数 (const Address-of Operator)

class MyClass {
public:
    // const 取地址运算符重载
    const MyClass* operator&() const {
        return this;// const同样返回假地址
    }
};

7、完整示例

#include <iostream>

class Example {
public:
    // 1. 构造函数
    Example() : data(0) { std::cout << "Default Constructor\n"; }
    Example(int d) : data(d) { std::cout << "Param Constructor\n"; }
    
    // 2. 析构函数
    ~Example() { std::cout << "Destructor\n"; }
    
    // 3. 拷贝构造函数
    Example(const Example& other) : data(other.data) {
        std::cout << "Copy Constructor\n";
    }
    
    // 4. 拷贝赋值函数
    Example& operator=(const Example& other) {
        std::cout << "Copy Assignment\n";
        if (this != &other) {
            data = other.data;
        }
        return *this;
    }
    
    // 5. 取地址重载
    Example* operator&() {
        std::cout << "Non-const Address-of\n";
        return this;
    }
    
    // 6. const取地址重载
    const Example* operator&() const {
        std::cout << "Const Address-of\n";
        return this;
    }
    
private:
    int data;
};

int main() {
    Example e1;          // 默认构造函数
    Example e2(10);      // 参数构造函数
    Example e3 = e2;     // 拷贝构造函数
    e1 = e3;             // 拷贝赋值函数
    
    Example* p1 = &e1;   // 非const取地址
    const Example* p2 = &e2;  // const取地址
    
    return 0;
}

关键点说明：

构造函数：对象创建时调用，可以有多个重载版本
析构函数：对象销毁时调用，用于资源清理
拷贝构造函数：用已有对象创建新对象时调用
拷贝赋值函数：已有对象间赋值时调用
取地址重载：通常不需要重载，除非需要特殊行为
const版本：为const对象提供操作

二、类的新功能【11特性】

1、default

强制生成默认函数的关键字default
也就是运行默认实现

class MyClass {
public:
    MyClass() = default;                      // 默认构造函数
    MyClass(const MyClass&) = default;       // 默认拷贝构造
    MyClass& operator=(const MyClass&) = default;  // 默认拷贝赋值
    ~MyClass() = default;                    // 默认析构函数
};

2、delete

禁止生成默认函数的关键字delete
也就是禁止默认实现
例如，要让一个类不能被拷贝，可以用=delete修饰将该类的拷贝构造和拷贝赋值。

class CopyBan
{
public:
	CopyBan()
	{}
private:
	CopyBan(const CopyBan&) = delete;
	CopyBan& operator=(const CopyBan&) = delete;
};

3、override

override修饰子类的虚函数。
子类继承父类虚函数时，子类是否正确重写了虚函数。没有就会编译错误。

class Base {
public:
    virtual void foo() { std::cout << "Base::foo\n"; }
    virtual void bar() const { std::cout << "Base::bar\n"; }
};

class Derived : public Base {
public:
    void foo() override {  // 正确：重写 Base::foo
        std::cout << "Derived::foo\n";
    }
    // void bar() override { ... }  // 错误！签名不匹配（缺少 const）
    void bar() const override {     // 正确：重写 Base::bar
        std::cout << "Derived::bar\n";
    }
};

4、final

4.1、修饰类

被final修饰的类叫做最终类，最终类无法被继承。

class NoHeritage final //被final修饰，该类不能再被继承
{
	//...
};

4.2、修饰虚函数

表示该虚函数不能再被重写，如果子类继承后重写了该虚函数则编译报错。

class Base {
public:
    virtual void foo() final {  // 派生类不能重写 foo
        std::cout << "Base::foo\n";
    }
};

class Derived : public Base {
public:
    // void foo() override { ... }  // 错误！foo 是 final
};