C++ 构造函数接受自己的类型？

我目前正在尝试为一个项目编制一个.cpp文件，但每当我尝试使用提供给met的测试文件运行它时，就会遇到seg错误。我怀疑我已经找到了错误发生的地方，但我一辈子都找不到解决办法

基本上，类产品在测试文件中初始化，如下所示

Product * orderItem = new Product(*wonkaBar_retail);

wonkaBar_retail是一个指向产品对象的指针-所以基本上，产品的构造函数接受自己类型的对象。。。我甚至不确定这是否有效。正如我所说的，这段代码，包括实例化wonkaBar_retail的部分都是提供的，所以我尝试通过创建这样的构造函数来进行补偿

Product(Product) {
//Constructor in the header file
}

Product(const Product&) {
//Other style
}

甚至像这样

Product(Product) {
//Constructor in the header file
}

Product(const Product&) {
//Other style
}

这只是给了我一些编译器错误，编译器甚至懒得解释

---

有人能解释一下这应该是如何工作的，以及这是否会首先导致segfault吗？

您提供的这一行使用了类

产品的复制构造函数，这是完全合法的。事实上，如果您不为类提供自己的复制构造函数，编译器将为您生成一个

复制构造函数引用同一类型的另一个对象，并将新对象初始化为与另一个对象相同的状态。复制构造函数签名通常如下所示：

Product(const Product& other);

Buffer::Buffer(const Buffer& other)
{
    m_dataSize = other.m_dataSize;
    m_data = other.m_data;

}

Buffer::Buffer(const Buffer& other)
{
    m_dataSize = other.m_dataSize;
    m_data = new char[m_dataSize];
    for (int i = 0; i < m_dataSize; ++i)
    {
        m_data[i] = other.m_data[i];
    }
}

对于简单类，编译器生成的复制构造函数可以正常工作，但是对于非平凡类，例如包含指向动态分配对象的指针的类，您应该实现自己的类

考虑以下类别：

class Buffer
{
public:
    Buffer(int dataSize) : m_dataSize(dataSize) { m_data = new char[m_dataSize]; }
    ~Buffer() { delete[] m_data; }

private:
    int m_dataSize;
    char* m_data;
};

此类的默认复制构造函数如下所示：

Product(const Product& other);

Buffer::Buffer(const Buffer& other)
{
    m_dataSize = other.m_dataSize;
    m_data = other.m_data;

}

Buffer::Buffer(const Buffer& other)
{
    m_dataSize = other.m_dataSize;
    m_data = new char[m_dataSize];
    for (int i = 0; i < m_dataSize; ++i)
    {
        m_data[i] = other.m_data[i];
    }
}

这显然不是你想要的。首先，如果复制的对象被删除，新对象指向的数据也将被删除。当你删除新对象时，你会尝试删除相同的数据两次，这是非常糟糕的

然后，您真正想要做的是为您的新对象分配新的
m_数据
，并从另一个对象复制数据，如下所示：

Product(const Product& other);

Buffer::Buffer(const Buffer& other)
{
    m_dataSize = other.m_dataSize;
    m_data = other.m_data;

}

Buffer::Buffer(const Buffer& other)
{
    m_dataSize = other.m_dataSize;
    m_data = new char[m_dataSize];
    for (int i = 0; i < m_dataSize; ++i)
    {
        m_data[i] = other.m_data[i];
    }
}

Buffer:：Buffer（常量缓冲区和其他）
{
m_数据大小=其他.m_数据大小；
m_数据=新字符[m_数据大小]；
对于（int i=0；i
您提供的行使用类
产品的复制构造函数，这是完全合法的。事实上，如果您不为类提供自己的复制构造函数，编译器将为您生成一个

复制构造函数引用同一类型的另一个对象，并将新对象初始化为与另一个对象相同的状态。复制构造函数签名通常如下所示：

Product(const Product& other);

Buffer::Buffer(const Buffer& other)
{
    m_dataSize = other.m_dataSize;
    m_data = other.m_data;

}

Buffer::Buffer(const Buffer& other)
{
    m_dataSize = other.m_dataSize;
    m_data = new char[m_dataSize];
    for (int i = 0; i < m_dataSize; ++i)
    {
        m_data[i] = other.m_data[i];
    }
}

对于简单类，编译器生成的复制构造函数可以正常工作，但是对于非平凡类，例如包含指向动态分配对象的指针的类，您应该实现自己的类

考虑以下类别：

class Buffer
{
public:
    Buffer(int dataSize) : m_dataSize(dataSize) { m_data = new char[m_dataSize]; }
    ~Buffer() { delete[] m_data; }

private:
    int m_dataSize;
    char* m_data;
};

此类的默认复制构造函数如下所示：

Product(const Product& other);

Buffer::Buffer(const Buffer& other)
{
    m_dataSize = other.m_dataSize;
    m_data = other.m_data;

}

Buffer::Buffer(const Buffer& other)
{
    m_dataSize = other.m_dataSize;
    m_data = new char[m_dataSize];
    for (int i = 0; i < m_dataSize; ++i)
    {
        m_data[i] = other.m_data[i];
    }
}

这显然不是你想要的。首先，如果复制的对象被删除，新对象指向的数据也将被删除。当你删除新对象时，你会尝试删除相同的数据两次，这是非常糟糕的

然后，您真正想要做的是为您的新对象分配新的
m_数据
，并从另一个对象复制数据，如下所示：

Product(const Product& other);

Buffer::Buffer(const Buffer& other)
{
    m_dataSize = other.m_dataSize;
    m_data = other.m_data;

}

Buffer::Buffer(const Buffer& other)
{
    m_dataSize = other.m_dataSize;
    m_data = new char[m_dataSize];
    for (int i = 0; i < m_dataSize; ++i)
    {
        m_data[i] = other.m_data[i];
    }
}

Buffer:：Buffer（常量缓冲区和其他）
{
m_数据大小=其他.m_数据大小；
m_数据=新字符[m_数据大小]；
对于（int i=0；i
您提供的行使用类
产品的复制构造函数，这是完全合法的。事实上，如果您不为类提供自己的复制构造函数，编译器将为您生成一个

复制构造函数引用同一类型的另一个对象，并将新对象初始化为与另一个对象相同的状态。复制构造函数签名通常如下所示：

Product(const Product& other);

Buffer::Buffer(const Buffer& other)
{
    m_dataSize = other.m_dataSize;
    m_data = other.m_data;

}

Buffer::Buffer(const Buffer& other)
{
    m_dataSize = other.m_dataSize;
    m_data = new char[m_dataSize];
    for (int i = 0; i < m_dataSize; ++i)
    {
        m_data[i] = other.m_data[i];
    }
}

对于简单类，编译器生成的复制构造函数可以正常工作，但是对于非平凡类，例如包含指向动态分配对象的指针的类，您应该实现自己的类

考虑以下类别：

class Buffer
{
public:
    Buffer(int dataSize) : m_dataSize(dataSize) { m_data = new char[m_dataSize]; }
    ~Buffer() { delete[] m_data; }

private:
    int m_dataSize;
    char* m_data;
};

此类的默认复制构造函数如下所示：

Product(const Product& other);

Buffer::Buffer(const Buffer& other)
{
    m_dataSize = other.m_dataSize;
    m_data = other.m_data;

}

Buffer::Buffer(const Buffer& other)
{
    m_dataSize = other.m_dataSize;
    m_data = new char[m_dataSize];
    for (int i = 0; i < m_dataSize; ++i)
    {
        m_data[i] = other.m_data[i];
    }
}

这显然不是你想要的。首先，如果复制的对象被删除，新对象指向的数据也将被删除。当你删除新对象时，你会尝试删除相同的数据两次，这是非常糟糕的

然后，您真正想要做的是为您的新对象分配新的
m_数据
，并从另一个对象复制数据，如下所示：

Product(const Product& other);

Buffer::Buffer(const Buffer& other)
{
    m_dataSize = other.m_dataSize;
    m_data = other.m_data;

}

Buffer::Buffer(const Buffer& other)
{
    m_dataSize = other.m_dataSize;
    m_data = new char[m_dataSize];
    for (int i = 0; i < m_dataSize; ++i)
    {
        m_data[i] = other.m_data[i];
    }
}

Buffer:：Buffer（常量缓冲区和其他）
{
m_数据大小=其他.m_数据大小；
m_数据=新字符[m_数据大小]；
对于（int i=0；i
您提供的行使用类
产品的复制构造函数，这是完全合法的。事实上，如果您不为类提供自己的复制构造函数，编译器将为您生成一个

复制构造函数引用同一类型的另一个对象，并将新对象初始化为与另一个对象相同的状态。复制构造函数签名通常如下所示：

Product(const Product& other);

Buffer::Buffer(const Buffer& other)
{
    m_dataSize = other.m_dataSize;
    m_data = other.m_data;

}

Buffer::Buffer(const Buffer& other)
{
    m_dataSize = other.m_dataSize;
    m_data = new char[m_dataSize];
    for (int i = 0; i < m_dataSize; ++i)
    {
        m_data[i] = other.m_data[i];
    }
}

对于简单类，编译器生成的复制构造函数可以正常工作，但是对于非平凡类，例如包含指向动态分配对象的指针的类，您应该实现自己的类

考虑以下类别：

class Buffer
{
public:
    Buffer(int dataSize) : m_dataSize(dataSize) { m_data = new char[m_dataSize]; }
    ~Buffer() { delete[] m_data; }

private:
    int m_dataSize;
    char* m_data;
};

此类的默认复制构造函数如下所示：

Product(const Product& other);

Buffer::Buffer(const Buffer& other)
{
    m_dataSize = other.m_dataSize;
    m_data = other.m_data;

}

Buffer::Buffer(const Buffer& other)
{
    m_dataSize = other.m_dataSize;
    m_data = new char[m_dataSize];
    for (int i = 0; i < m_dataSize; ++i)
    {
        m_data[i] = other.m_data[i];
    }
}

这显然不是你想要的。首先，如果复制的对象被删除，新对象指向的数据也将被删除。然后，当你删除新对象时，你会尝试删除相同的数据两次，而