-1

我有以下类，当调用析构函数并尝试删除指向 a 和 b 的指针时出现错误。看起来它们不存在。这是触发问题的代码行：

unordered_map<string,Stock>* SDict = new unordered_map<string,S>();
SDict->insert(make_pair("38363",S("38363",i,w)));

标题

class O{
public:
    O();
    ~O();
    O(const O& tocopy);
    O& operator=(const O& toassign);


private:
    unordered_map<int,PQL>* b;
    unordered_map<int,PQL>* a;
};

资源

O::O(){
    a = new unordered_map<int,PQL>();
    b = new unordered_map<int,PQL>();
}

O::~O(){
    delete b; //I get the exception here- b doesn't exist before the delete.
    delete a;
}

O& O::operator=(const O& src){
    if(this != &src){
        delete b;
        delete a;

        b = new unordered_map<int,PQL>();
        b = src.b;
        a = new unordered_map<int,PQL>();
        a = src.a;
    }
    return *this;
}

O::O(const O& src){
    b = new unordered_map<int,PQL>();
    b = src.b;
    a = new unordered_map<int,PQL>();
    a = src.a;
}

PQL 是一个只有三个整数的类。是否有明显的原因导致此错误？

类 O 是以下类的数据成员：

标题

class S{
    public:
        S();
        S(string sid, vector<string>* indexids, vector<double>* sw);
        ~S();
        S(const S& tocopy);
        S& operator=(const S& toassign);

    private:
        string sid;
        O* o;
        vector<Strategy*> ts;
        unordered_map<string,double>* iw;
};

资源

    S::S(){}

    S::S(string sid, vector<string>* iis, vector<double>* sw){
        sid = sid;
        iw = new unordered_map<string,double>();
        o = new o();

        if(iis->size() == sw->size()){
            for(size_t i=0; i<iis->size(); i++){
                string key = iis->at(i);
                if(iw->count(key) == 0 ){
                    double weighting = sw->at(i);
                    iw->insert(make_pair(key,weighting));
                }
                else{
                    throw new exception();
                }
            }
        }
        else{
            throw new exception();
        }
    }

    S::S(const S& rhs){
        sid = rhs.sid;
        ts = rhs.ts;
        o = new O();
        o = rhs.o;
        iw = new unordered_map<string,double>();
        iw = rhs.iw;
    }

    S& S::operator=(const S& src){

        if(this != &src){
            delete o;
            delete iw;

            sid = src.sid;
            ts = src.ts;
            o = new o();
            o = src.o;
            iw = new unordered_map<string,double>();
            iw = src.iw;
        }

        return *this;
    }

    S::~S(){
        delete o;
        delete iw;
    }
4

4 回答 4

3

您的复制构造函数中有一个明显的问题：

O::O(const O& src){
    b = new unordered_map<int,PQL>();
    b = src.b;
    a = new unordered_map<int,PQL>();
    a = src.a;
}

分配确实分配了错误的实体：它分配了指针，即，分配b = src.b泄漏了刚刚分配的内存并复制了指针。你可能打算写：

O::O(O const& src)
    : b(new std::unordered_map<int, PQL>(*src.b)
    , a(new std::unordered_map<int, PQL>(*src.a)
{
}

请注意，您的赋值运算符不是异常安全的！一般的猜想是，如果您的代码需要检查自分配以在自分配的情况下工作，那么它不是异常安全的。

赋值的规范实现利用复制构造函数和析构函数并使用另一个常用函数swap(), 来交换资源：

O& O::operator= (O other) {
    this->swap(other);
    return *this;
}
void O::swap(O& other) {
    using std::swap;
    swap(this->b, other.b);
    swap(this->a, other.a);
}
于 2013-09-25T18:44:53.900 回答
1

以下代码：

   b = new unordered_map<int,PQL>();
   b = src.b;
   a = new unordered_map<int,PQL>();
   a = src.a;

应改为：

   b = new unordered_map<int,PQL>();
   *b = *src.b;
   a = new unordered_map<int,PQL>();
   *a = *src.a;

在复制 ctor 和赋值运算符中。所以它会复制地图内容而不是复制指针，这是错误的行为。但更好的方法是：

   b = new unordered_map<int,PQL>( *src.b );
   a = new unordered_map<int,PQL>( *src.a );
于 2013-09-25T18:45:22.247 回答
1

你的代码有几个问题

O& O::operator=(const O& src){
if(this != &src){
    delete b;
    delete a;
    //b will point to newly allocated memory
    b = new unordered_map<int,PQL>();
    //now you set b to point to the same unordered map as src (double deletion will occur)
    //you will leak the memory you just allocated
    b = src.b;

复制构造函数也有同样的问题......

于 2013-09-25T18:48:34.720 回答
0

您的复制构造函数是错误的。你需要做一个深拷贝，而不是仅仅使用类似的东西

b = src.b;

您需要将地图的每个成员从源复制到目标。

还有你的赋值运算符。

于 2013-09-25T18:43:36.853 回答