Question

这已经摧毁了我一段时间。我确定这是有原因的：

chain operator+(chain c)
{
    chain<Object> result;
    for (int i = 0; i < length(); i++)
    {
        result.insert(*(Object*)(memory+(i*sizeof(Object))));
    }
    for (int i = 0; i < c.length(); i++)
    {
        result.insert(c[i]);
    }
    for (int i = 0; i < result.length(); i++) // This for loop successfully shows all objects in result
    {
        cout << result[i];
    }
    return result;
}

返回值时，即：

chain<int> a;
cin >> a; // enter "5 6 7 8"
chain<int> b;
cin >> b; // enter "9 10 11 12"
chain <int> c = a+b;

cout << c; // Returns "0 0 7 8 9 10 11 12"

前两个数字总是0.我无法弄清楚原因。只有在将两个链一起添加时才会发生如果我输入a或b，我会得到所有的值。

如果有人有任何信息要分享我真的很感激：）

编辑**

完整来源

#ifndef CHAIN_H
#define CHAIN_H

#include <iostream>
#include <stdlib.h>

using namespace std;

template <class Object>
class chain
{
    public:
            chain(){
                    memorySize = 8;
                    memory = calloc(memorySize, sizeof(Object));
                    count = 0;
            }
            chain(Object item){
                    memorySize = 8;
                    memory = calloc(memorySize, sizeof(Object));
                    count = 0;
                    insert(item);
            }
            chain(chain & original){
                    memorySize = 8;
                    memory = calloc(memorySize, sizeof(Object));
                    count = 0;
                    for (int i = 0; i < original.length(); i++)
                    {
                            insert(original[i]);
                    }
            }
            ~chain(){
                    free(memory);
            }
                chain operator+(chain c){
                    chain<Object> result;
                    for (int i = 0; i < length(); i++)
                    {
                            result.insert(this->operator[](i));
                    }
                    for (int i = 0; i < c.length(); i++)
                    {
                            result.insert(c[i]);
                    }
                    for (int i = 0; i < result.length(); i++)
                    {
                            cout << result[i];
                    }
                    return result;
            }
            Object & operator[](int pos){
                    return *(Object*)(memory+(pos*sizeof(Object)));
            }
            int length(){
                    return count;
            }
            void insert(Object item){
                    if (count == memorySize)
                    {
                            doubleMemory();
                    }
                    this->operator[](count) = item;
                    count++;
            }
    private:
            int count;
            int memorySize;
            void * memory;
            void doubleMemory(){
                    memorySize *= 2;
                    memory = realloc(memory, (memorySize*sizeof(Object)));
            }

};
template <class Object>
ostream& operator<<(ostream& out, chain<Object>& c){
    for (int i = 0; i < c.length(); i++)
    {
            out << c[i] << " ";
    }
}
template <class Object>
istream& operator>>(istream& in, chain<Object>& c){
    char ch;
    int number = 0;
    int sign;
    while(ch != '\n')
    {
            ch = in.get();
            if (ch == '-')
            {
                    sign = 1;
            }
            else if (ch >= '0' && ch <= '9')
            {
                    number *= 10;
                    number += (ch-48);
            }
            else if (ch == ' ' || ch == '\n')
            {
                    number = sign == 1? 0 - number : number;
                    c.insert(number);
                    sign = 0;
                    number = 0;
            }
    }
}
#endif

这是我正在测试的代码：

#include "chain.h"

using namespace std;

int main(){

    chain<int> a, b, c;
    chain<int> d(10);
    chain<int> e(d);
    cin >> a;
    cout << endl;
    cout << endl;
    c = a+d;
    cout << c;
}

〜

Answer 1

您展示的代码不是问题。真正的问题可能是在复制构造函数或chain的析构函数中 - 也可能在insert方法中（或者，在C ++ 11中，在移动构造函数中）。

（它也可能在Object的复制构造函数中，但我认为这不太可能。）

编辑：哦，我的。不要在C ++中编写这样的代码。左，右和中心不安全。只要Object是POD你应该没问题，但如果不是这个代码会产生未定义的行为。特别是，它不会为您存储在链中的对象调用正确的构造函数和析构函数。

此外，您的复制构造函数应该采用类型为chain const&的参数，因为您没有修改传递的chain。这反过来要求您通过提供const的适当operator []重载来使您的类const更正。

最后也是最明显的是，您违反了三条规则，因为您没有为operator =实施chain。尝试将一个chain分配给另一个将导致双重释放。

通常避免使用calloc和free并使用标准容器，或者，如果不是一个选项，请使用new[]加上boost::shared_array之类的智能指针来管理内存（但不使用delete[]）。

另一件事，永远不要在头文件中使用using namespace，它会污染命名空间并导致在最奇怪的地方发生名称冲突。

Answer 2

好吧，我看到有关copy-constructor的以下问题。在我看来，你希望它作为一个复制构造函数：

chain(chain & original){
    memorySize = 8;
    memory = calloc(memorySize, sizeof(Object));
    count = 0;
    for (int i = 0; i < original.length(); i++)
    {
        insert(original[i]);
    }
}

但它不能，因为该方法的声明是错误的。您缺少复制参数中的const修饰符。如果不包含它，编译器会假定您只声明一个使用可变引用的普通构造函数，而这不是您需要在后面定义的复制构造函数。 Rule of Three

只需改变一下：

chain(chain & original){

到此：

chain(const chain & original){

这可能会解决错误的内存处理问题，希望您的程序中会得到不同的输出。

与对象一起返回时清除内存指针

2 个答案: