构造函数和析构函数实例

构造函数和析构函数的例子可以帮助理解它们的工作原理：

**构造函数**：

class MyClass {
public:
    // 构造函数，接受一个整数作为参数
    MyClass(int value) {
        myValue = value;  // 初始化实例变量
        std::cout << "MyClass constructed with value: " << value << std::endl;
    }

private:
    int myValue;
};

在这个例子中，当我们创建 `MyClass` 对象时，如 `MyClass obj(10);`，构造函数会被自动调用，传入的 `10` 会被存储在 `myValue` 变量中。

**析构函数**：

class MyClass {
public:
    ~MyClass() {  // 析构函数前有波浪线 ~ 表示这是析构函数
        std::cout << "MyClass is being destructed." << std::endl;
        // 可能的资源清理操作，例如这里仅打印消息
    }
};

// 创建对象，然后销毁
MyClass obj;
// 对象 obj 现在处于已构造状态，当离开其作用域（比如在这里结束代码块）时，析构函数会被调用

析构函数会在对象生命周期结束后自动调用，即使程序崩溃也不例外，确保了资源的正确释放。

相关问题

定义一个rectangle类，编写构造函数和析构函数，定义一个circle类，编写构造函数和析构函数，定义二者的一个友元函数getTotalArea(),计算二者的面积和

首先，让我们定义一个Rectangle类，它包含长和宽属性以及相应的构造函数和析构函数：

class Rectangle {
private:
    double length;
    double width;

public:
    // 构造函数
    Rectangle(double l, double w) : length(l), width(w) {}

    // 计算矩形面积的成员函数
    double getArea() const { return length * width; }

    // 析构函数，无特别操作，这里默认不显示
    ~Rectangle() {}

    // 友元函数，用于获取总面积
    friend double getTotalArea(Rectangle rect, Circle circle);
};

接下来，我们定义Circle类，同样包含半径属性以及构造函数和析构函数：

class Circle {
private:
    double radius;

public:
    Circle(double r) : radius(r) {}

    // 计算圆面积的成员函数
    double getArea() const { return M_PI * radius * radius; }

    // 析构函数，同上，默认不显示
    ~Circle() {}

    // 友元函数，用于获取总面积
    friend double getTotalArea(Rectangle rect, Circle circle);
};

最后，友元函数`getTotalArea()`负责计算两者面积之和：

// 友元函数，计算矩形和圆的总面积
double getTotalArea(Rectangle rect, Circle circle) {
    return rect.getArea() + circle.getArea();
}

使用这两个类时，你可以创建实例并调用`getTotalArea`来获取总面积：

int main() {
    Rectangle rectangle(5, 3);
    Circle circle(2.5);

    double total_area = getTotalArea(rectangle, circle);
    std::cout << "Total area of rectangle and circle: " << total_area << std::endl;

    return 0;
}

参考实验指导书第七章的实验步骤2、3： 编写程序声明一个基类 BaseClass，构造其派生类 DerivedClass，在构造函数和析构函数中用 cout 输出提示信息，观察构造函数和析构函数的执行情况。

在C++中，你可以按照以下步骤编写程序来实现这个实验：

首先，创建一个名为`BaseClass.h`的头文件，定义基类：

// BaseClass.h
class BaseClass {
public:
    BaseClass() { cout << "BaseClass 构造函数" << endl; }
    ~BaseClass() { cout << "BaseClass 析构函数" << endl; }

protected:
private:
};

然后，在`DerivedClass.h`中定义派生类并继承`BaseClass`：

// DerivedClass.h
#include "BaseClass.h"

class DerivedClass : public BaseClass {
public:
    DerivedClass() : BaseClass() { cout << "DerivedClass 构造函数" << endl; } // 调用基类构造函数
    ~DerivedClass() { cout << "DerivedClass 析构函数" << endl; } // 调用基类析构函数

private:
};

接下来，将这两个类放到一个源文件`main.cpp`中，并创建一个主函数来进行测试：

// main.cpp
#include <iostream>
#include "DerivedClass.h"

int main() {
    DerivedClass obj; // 创建 DerivedClass 的实例
    return 0;
}

当你运行`main.cpp`时，将会看到如下输出：

BaseClass 构造函数
DerivedClass 构造函数
DerivedClass 析构函数
BaseClass 析构函数

这说明了当`DerivedClass`的对象被创建和销毁时，它的构造函数和析构函数都会被正确地调用，以及它如何继承了`BaseClass`中的相应函数。