1

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

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;
}

~

4

2 回答 2

3

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

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

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

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

最后也是最明显的，你违反了三原则，因为你没有operator =为你的chain. 因此，试图将一个分配chain给另一个将导致双重释放。

通常避免callocandfree并使用标准容器，或者，如果这不是一个选项，请使用new[]plus 智能指针，如boost::shared_array来管理内存（但不要使用delete[]）。

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

于 2012-09-11T09:03:34.590 回答
0

好吧，我看到以下关于复制构造函数的问题。在我看来，您希望它充当复制构造函数：

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

但它不能，因为方法的声明是错误的。您在 copy 参数中缺少 const 修饰符。如果不包含它，编译器会假定您只声明了一个与可变引用一起使用的普通构造函数，而这不是您需要遵循 三规则定义的复制构造函数。

只需更改此：

chain(chain & original){

对此：

chain(const chain & original){

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

于 2012-09-11T09:50:11.600 回答