C++构造析构赋值运算函数应用详解

什么是构造函数、析构函数和赋值运算函数

在C++语言中，构造函数、析构函数和赋值运算函数都是面向对象编程中的重要概念。

• 构造函数：用于对象的初始化工作，它在对象被创建时自动调用，一般不需要手动调用。
• 析构函数：用于对象的销毁工作，它在对象被删除时自动调用，同样也不需要手动调用。
• 赋值运算函数：用于对象的赋值操作，即将一个对象的值赋给另一个对象。

它们都属于特殊的成员函数，它们的定义方式都与普通成员函数不同。下面是它们的一些定义示例：

// 构造函数
class CExample{
public:
    CExample(string s);
};

CExample::CExample(string s){
    // 对象的初始化工作
}

// 析构函数
class CExample{
public:
    ~CExample();
};

CExample::~CExample(){
    // 对象的销毁工作
}

// 赋值运算函数
class CExample{
public:
    CExample& operator=(const CExample &ce);
};

CExample& CExample::operator=(const CExample &ce){
    if(this != &ce){
        // 对象的赋值操作
    }
    return *this;
}

如何应用构造函数、析构函数和赋值运算函数

构造函数的应用

构造函数的主要作用是在对象创建时进行初始化工作。一般情况下，构造函数的初始化工作包括以下几个方面：

• 对象的值初始化
• 分配和初始化动态内存
• 默认参数的初始化
• 数据成员和类成员对象的初始化

下面是构造函数的一个简单示例：

class CExample{
public:
    CExample(int nValue);
private:
    int m_nValue;
};

CExample::CExample(int nValue):m_nValue(nValue) {
    // 对象的初始化工作
}

int main(){
    CExample objExample(10);
    return 0;
}

上述示例展示了一个构造函数的基本应用。它接收一个整数类型的参数，并将这个参数赋值给类的成员变量。

析构函数的应用

和构造函数相对的是析构函数，它的作用是在对象被销毁时释放对象占用的资源。与构造函数不同的是，析构函数不会接收任何参数，也不会返回任何值。

下面是析构函数的一个简单示例：

class CExample{
public:
    ~CExample();
private:
    int *m_pBuffer;
};

CExample::~CExample(){
    delete m_pBuffer;
}

上例中，析构函数定义了对象被销毁时的行为，它会将指向动态内存的指针m_pBuffer所指向的内存释放。

赋值运算函数的应用

赋值运算函数用于将一个对象的值赋给另一个对象。一般情况下，赋值运算符应该以引用的方式传递参数，并返回该类的引用。

下面是赋值运算函数的一个简单示例：

class CExample{
public:
    CExample& operator=(const CExample &ce);
private:
    int m_nValue;
};

CExample& CExample::operator=(const CExample &ce){
    if(this != &ce){
        this->m_nValue = ce.m_nValue;
    }
    return *this;
}

int main(){
    CExample objExample1(10);
    CExample objExample2(20);
    objExample1 = objExample2;
    return 0;
}

上例中，赋值运算函数接收的参数是常量引用，赋值运算函数的返回值是该类的引用。在这个例子中，我们将两个对象进行赋值操作，即将objExample2的值赋给objExample1。

示例说明

示例一

class Person {
public:
    Person(int age, string name):m_age(age), m_name(name) {};
    Person(const Person& p):m_age(p.m_age), m_name(p.m_name) {};
    Person& operator=(const Person& p) {
        if (this != &p) {
            m_age = p.m_age;
            m_name = p.m_name;
        }

        return *this;
    }
private:
    int m_age;
    string m_name;
};

上述代码中，定义了一个Person类，该类接收两个构造函数参数age和name，并提供了拷贝构造函数和赋值运算函数。它们分别用于初始化、复制对象和赋值对象。在赋值运算函数中，我们使用了“自赋值判断”，即当对象在进行自我赋值时，我们仅需返回*this即可。

示例二

class Buffer {
public:
    Buffer(int nSize) {
        m_pBuffer = new char[nSize];
        m_nSize = nSize;
    }
    ~Buffer() {
        if(m_pBuffer != NULL) {
            delete[] m_pBuffer;
            m_pBuffer = NULL;
            m_nSize = 0;
        }
    }
    Buffer(const Buffer& buffer) {
        m_pBuffer = new char[buffer.m_nSize];
        m_nSize = buffer.m_nSize;
        memcpy(m_pBuffer, buffer.m_pBuffer, buffer.m_nSize);
    }
    Buffer& operator=(const Buffer& buffer) {
        if (this != &buffer) {
            if (m_pBuffer != NULL) {
                delete[] m_pBuffer;
            }

            m_pBuffer = new char[buffer.m_nSize];
            m_nSize = buffer.m_nSize;
            memcpy(m_pBuffer, buffer.m_pBuffer, buffer.m_nSize);
        }

        return *this;
    }
private:
    int m_nSize;
    char* m_pBuffer;
};

上述代码中，我们定义了一个Buffer类，它的构造函数负责为Buffer类的成员变量m_pBuffer分配内存。在Copy Constructor中，我们实现了深拷贝。在赋值运算函数中，我们先释放了m_pBuffer，然后进行深拷贝，并返回*this。

总结

本文中，我们详细讲解了C++中构造函数、析构函数和赋值运算函数的应用。在实际编程中，它们是不可或缺的成员函数。我们应该思考对象的初始化和销毁，以及对象之间的赋值操作，来理解和应用这些成员函数。