c++ - 为什么当这些对象中的任何一个不超出范围时调用析构函数？

Question

当我从代码中删除析构函数时，输出如我所愿，但如果我手动释放空间，程序就会变得疯狂:(请有人帮助我，我正在使用 Code::Blocks IDE 并在 Linux 中运行薄荷操作系统

#include<iostream>
#include<cstring>
using namespace std;
class str
{
    char *p;
    int len;
public:
    str() {
        len=0;
        p=NULL;
    }
    str(const char *s);
    str(const str &s);
    ~str() {
        cout<<" Distructor Called ";
        delete p;
    }
    friend str operator+(const str &s,const str &t);
    friend bool operator<=(const str &s,const str &t);
    friend void show(str &s);
};

str::str(const char *s)
{
    len=strlen(s);
    p=new char[len+1];
    strcpy(p,s);
}
str::str(const str &s)
{
    len=s.len;
    p=new char[len+1];
    strcpy(p,s.p);
}

void show(str &s)
{
    cout<<s.p;
}
str operator+(const str &s,const str &t)
{
    str tem;
    tem.len=s.len+t.len;
    tem.p=new char[tem.len+1];
    strcpy(tem.p,s.p);
    strcat(tem.p,t.p);
    return tem;
}
bool operator<=(const str &s,const str &t)
{
    if(s.len<=t.len)
        return true;
    else
        return false;
}

int main()
{
    str s1="New ";
    str s2="York";
    str s3="Delhi";
    str string1,string2,string3;
    string1=s1;
    string2=s1+s2;
    string3=s1+s3;

    cout<<"\nString1 = ";
    show(string1);
    cout<<"\nString2 = ";
    show(string2);
    cout<<"\nString3 = ";
    show(string3);
    cout<<"\n\n";
    if(string1<=string2) {
        show(string1);
        cout<<" Smaller Than ";
        show(string2);
        cout<<"\n";
    } else {
        show(string3);
        cout<<"Smaller Than ";
        show(string1);
        cout<<"\n";
    }
    return 0;
}

Answer 1

了解 Rule of Three .当您不声明赋值运算符时，编译器会生成一个默认运算符，它会执行以下操作:

Assign all the object's members from the corresponding members of the assignment operator's argument, calling the copy assignment operators of the object's class-type members, and doing a plain assignment of all non-class type (e.g. int or pointer) data members.

首先，上面的粗体文字适用于你类(class)中的char *p。在您的 operator+ 函数中， tem 是堆栈上的一个对象。当函数结束时，tem 超出范围，并调用其析构函数。因此，根据编译器生成的默认赋值运算符，string1 的 p 被分配给 tem 的 p，这意味着 string1 的 p 指向与 tem 的 p 相同的内存位置，后者在超出范围后被释放!因此，string1 没有预期的值。后来，当 string1 超出范围并调用其析构函数时，第二次在同一内存位置调用 delete，从而导致显示的错误。同样，对于 string2。

如果你像这样重载赋值运算符，一切都会好起来的:

void str::operator=(const str&s) {
    delete[] p;
    len=s.len;
    p=new char[len+1];
    strcpy(p,s.p);
}

在这种情况下，tem 的 p 将在调用其析构函数之前被复制。

注意:

1. 它在你删除析构函数时起作用，因为默认编译器生成的析构函数不会释放分配内存，但这会泄漏内存，这是不好的。
2. 您的代码中还有另一个重大缺陷。使用 delete[] 用于取消分配数组。