C++中返回不同形式对象时析构函数调用行为的疑问

问题代码 #

class Vec
{
public:
    unsigned int dim;
    float* elements;

    // Constructors
    Vec() : dim(0), elements(nullptr) {}

    Vec(unsigned int dim, ...) : dim(dim), elements(new float[dim])
    {
        va_list args;
        va_start(args, dim);

        for (unsigned int i = 0; i < dim; i++)
        {
            // C/C++ promotes floats passed as variable arguments to double,
            // so you need to use va_arg(args, double) and cast it to float
            elements[i] = static_cast<float>(va_arg(args, double));
        }

        va_end(args);
    }

    Vec(unsigned int dim, float value) : dim(dim), elements(new float[dim])
    {
        for (unsigned int i = 0; i < dim; i++)
        {
            elements[i] = value;
        }
    }

    // Destructor
    ~Vec()
    {
        delete[] elements;
    }
};


Vec vecAdd(Vec* v1, Vec* v2)
{
    if (v1->dim != v2->dim)
    {
        //Vec VEC_UNDEFINED;
        //return VEC_UNDEFINED;
        return Vec;
    }

    Vec ret(v1->dim);

    for (unsigned int i = 0; i < ret.dim; i++)
    {
        ret.elements[i] = v1->elements[i] + v2->elements[i];
    }

    return ret;
}

问题描述 #

调用vecAdd函数返回ret对象时，析构函数会被调用，导致ret.elements被释放，不符合预期；但如果注释掉边界检查中的return Vec;，改为取消注释//Vec VEC_UNDEFINED; //return VEC_UNDEFINED;，此时析构函数不会被调用，代码能正常工作。请问C++为何会有这样的行为？

解答 #

核心问题：浅拷贝引发的未定义行为

你的Vec类只定义了构造函数和析构函数，但没有自定义拷贝构造函数和赋值运算符重载。C++编译器会自动生成默认版本，但默认版本是浅拷贝——直接复制elements指针的地址，而非重新分配内存拷贝数组内容。这会导致多个Vec对象共享同一块堆内存，任何一个对象析构时都会释放这块内存，剩下的对象的elements会变成野指针，后续操作全是未定义行为。

关于返回ret时的析构调用

函数返回局部对象ret时，理论上会经历“拷贝ret到返回值临时对象→销毁ret（调用析构释放内存）”的过程，但现代编译器通常会做返回值优化（RVO），直接在调用方栈帧上构造ret，避免拷贝和销毁。如果编译器未开启优化或优化未生效，ret的析构就会触发，导致返回的临时对象的elements指向已释放的内存，自然不符合预期。

return Vec;是非法代码

这行代码不符合C++语法规范，正确返回默认构造对象的写法是return Vec();。如果你的编译器未报错，是它的非标准扩展在起作用，此时返回的对象状态不确定。你看到的析构调用，其实是局部变量ret的正常销毁——函数执行到return后，所有局部变量都会被销毁，和返回值无关。

返回VEC_UNDEFINED的“正常”是假象

当你改成Vec VEC_UNDEFINED; return VEC_UNDEFINED;时，VEC_UNDEFINED作为局部变量，函数返回后必然会被销毁，析构函数一定会被调用。你觉得“正常工作”只是未定义行为的巧合：被释放的内存暂时没被操作系统回收或覆盖，看起来能正常访问，但本质上已经是非法操作，随时可能崩溃。

解决办法

为Vec类添加深拷贝的拷贝构造函数和赋值运算符重载：

// 拷贝构造函数
Vec(const Vec& other) : dim(other.dim), elements(new float[other.dim])
{
    for (unsigned int i = 0; i < dim; i++)
    {
        elements[i] = other.elements[i];
    }
}

// 赋值运算符重载
Vec& operator=(const Vec& other)
{
    if (this != &other) // 防止自赋值
    {
        delete[] elements; // 释放当前内存
        dim = other.dim;
        elements = new float[dim];
        for (unsigned int i = 0; i < dim; i++)
        {
            elements[i] = other.elements[i];
        }
    }
    return *this;
}

或者直接用std::vector<float>代替手动管理的动态数组，它会自动处理拷贝、析构等问题，避免手动内存管理的错误。

内容的提问来源于stack exchange，提问作者lucas