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

Memory pointer cleared when returned with object

本文关键字:内存 指针 清除 对象 一起 返回      更新时间:2023-10-16

这已经毁了我一段时间了。我相信这是有原因的:

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

~

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

(它也可能在Object的复制构造函数中,但我认为这不太可能。)


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

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

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

通常避免使用callocfree,而是使用标准容器,或者,如果不是选项,则使用new[]加上智能指针(如boost::shared_array)来管理内存(但不要使用delete[])。

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

好吧,我看到了以下关于复制构造函数的问题。在我看来,你希望它充当一个复制构造函数:

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){

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