Question

我很好奇为什么复制构造函数对于我自己定义的类的动态分配非常重要。

我正在使用动态分配实现低级c-string类，这里是我的类的快速视图

class String
{
private:
    char * buf;
    bool inBounds( int i )
    {
        return i >= 0 && i < strlen(buf);
    }
    static int strlen(const char *src)
    {
        int count = 0;
        while (*(src+count))
            ++count;
        return count;
    }
    static char *strcpy(char *dest, const char *src)
    {
        char *p = dest;
        while( (*p++ = *src++));
        return dest;
    }
    static char* strdup(const char *src)
    {
        char * res = new_char_array(strlen(src)+1);
        strcpy(res,src);
        return res;
    }
    static char * new_char_array(int n_bytes)
    {
        return new char[n_bytes];
    }
    static void delete_char_array( char* p)
    {
        delete[] p;
    }

public:
    /// Both constructors should construct
    /// this String from the parameter s
    String( const char * s = "")
    {
        buf = strdup(s);
    }
    String( String & s)
    {
        buf = strdup(s.buf);
    }
    void reverse()
    {
    }
    void print( ostream & out )
    {
        out << buf;
    }
    ~String()
    {
        delete_char_array(buf);
    }
};
ostream & operator << ( ostream & out, String str )
{
    str.print(out);
    return out;
}

我知道strdup（）函数的部分不是很正确，但我只是做了一些测试。

我的问题是如果我没有复制构造函数而我的main（）是

int main()
{
    String b("abc");
    String a(b);
    cout << b << endl;
    return 0;
}

编译器会告诉我double free or corruption (fasttop)，我会找到关于这个问题的一些答案，并查看三大规则。

如果我有复制构造函数以及双重免费或损坏（fasttop）的错误意味着什么，你们能告诉我为什么我的代码可以正常工作而没有任何错误吗？

Answer 1

如果您没有定义复制构造函数，编译器将为您插入一个。此默认复制构造函数将简单地复制所有数据成员，因此String的两个实例将指向相同的内存区域。 buf变量将在每个实例中保持相同的值。

因此，当实例超出范围并被销毁时，它们都会尝试释放相同的内存区域，并导致错误。

Copy构造函数为动态分配做了什么

1 个答案: