Question

您好我使用模板delevop一个多容器，但是我从子类析构函数中得到了一个分段错误，这里是代码：

#include <algorithm>
#include <map>
#include <iostream>
class BaseType{
public:
    virtual ~BaseType(){}
    virtual BaseType * clone() const =0;
};

template<typename T>
class DataType : public BaseType
{
public:
    DataType(const T & aValueData = T()):mValue(aValueData) {
       // new DataType<T>(*this)
    }
    ~DataType(){

    }
    BaseType * clone() const
    {
        return new DataType<T>(*this);
    }

    T mValue;
};

    class MValueData
    {
    public:
        template<typename T>
        MValueData(T const  & aAnyValue = T()):mTypeData(0),isDelete(false)
        {
            std::cout<<"Object Address before create object: "<<mTypeData<<std::endl;
            mTypeData=new DataType<T>(aAnyValue);
            std::cout<<"Object Address after create object"<<mTypeData<<std::endl;
        }
        ~MValueData(){
            std::cout<<"Object Address "<<mTypeData<<std::endl;

            delete mTypeData;
            mTypeData=0;


        }
        MValueData()
        {
           mTypeData=0;
        }
        template<typename T>
        MValueData(const MValueData & aCopy)
        {

            mTypeData= new  DataType<T>();
           *mTypeData=aCopy.mTypeData;
        }
        template<typename T>
        const MValueData & operator=(const MValueData & aCopy)
        {
             mTypeData= new  DataType<T>();
             *mTypeData=aCopy.mTypeData;
            //MValueData(aCopia).swap(*this);
        }
         void swap(MValueData& other) {
             std::swap(this->mTypeData, other.mTypeData);
         }

         template <typename T>
         T& get()
         {
                return dynamic_cast<DataType<T>&>(*this->mTypeData).mValue;
         }

         bool operator <(const MValueData &rhs) const {
             return (mTypeData<rhs.mTypeData);
         }
         template<typename T>
         void setValue(T const & anyValue=T())
         {
             mTypeData= new DataType<T>(anyValue);
         }
         BaseType *mTypeData;
    private:

         bool isDelete;
    };

    int main()
    {
        MValueData aAnyType_1(0.22);
        aAnyType_1.get<double>();
        MValueData aAnyType_2(false);
        std::map<MValueData , MValueData&> mMapa;
        mMapa.insert(std::pair<MValueData  , MValueData&>(aAnyType_1,aAnyType_2));
//        mMapa.find(aAnyType_1);
        return 0;
    }

我正在使用GDB来确定错误，但我找不到正确的修复方法，当我对此行发表评论时，segmentacion会停止：

 ~MValueData(){
         //   if(mTypeData)    delete mTypeData;
        }

只有这样才能正常运行，但似乎我正在创建内存泄漏。更新：std :: map创建我插入的对象的copys，对象被销毁两次，一个在退出main函数时另一个当std :: map正在摧毁它时，任何提示？提前thx！

Answer 1

此分段错误可能似乎在析构函数中，但它是复制构造函数中的问题。让我们举一个简单的例子，我有一个存储指针的类。然后我像你正在做的那样复制这个指针值：我将有两个指向同一内存位置的指针。现在我删除其中一个对象，从而删除指针处的值。第二个对象将有一个指向无效内存的指针，当它试图删除内存时，会出现分段错误。

如何解决此问题：

实际上有几种方法。首先，您需要决定是否要深度复制指针。如果这样做，写一个指针所指向的deep copy内存。如果不是，我会使用shared_ptr进行重新调整，以避免出现这些问题。

Answer 2

您的复制构造函数已损坏。您不是克隆对象，而只是克隆指针。一旦复制了一个对象，这两个副本将尝试删除析构函数中内存中的同一个真实对象，这将导致崩溃。您需要确定谁应该拥有该对象，以及您是否希望在MValueData对象的不同实例之间克隆或共享该对象。然后采取相应措施来解决问题。

Answer 3

您的copy constructor不正确。

它只复制指针而不是对象。

使用复制构造函数复制的两个对象将尝试删除其析构函数中的同一对象。

析构函数子类中的c ++分段错误

3 个答案: