C++ 向量相关内存分配问题

我遇到以下错误

• 我有一门课

  Foo

  。此类实例存储在

  类B

  的std:：vector

  vec

  中
• 在类Foo中，我通过使用

  new

  分配内存并在

  ~Foo（）

  中删除该对象来创建类A的实例

代码可以编译，但是我在运行时崩溃了。如果我禁用

从类
Foo
的Destructor中删除我的a

。代码运行正常（但会出现内存泄漏）

有人能解释一下这里出了什么问题并提出解决方案吗

谢谢大家!

class A{
      public:
          A(int val);
          ~A(){};
          int val_a;

};

A::A(int val){
       val_a = val;
       };

class Foo {      
      public:
             Foo();
             ~Foo();
             void createA();
             A* my_a;
};

Foo::Foo(){
    createA();
};

void Foo::createA(){
    my_a = new A(20);
};

Foo::~Foo(){
    delete my_a;

};



class B {
      public:
             vector<Foo> vec;             
             void createFoo();            
             B(){};
             ~B(){};
};


void B::createFoo(){
    vec.push_back(Foo());
};


int main(){
    B b;

    int i  =0;
    for (i = 0; i < 5; i ++){
        std::cout<<"\n creating Foo";
        b.createFoo();   
        std::cout<<"\n Foo created";
        }
    std::cout<<"\nDone with Foo creation";

    std::cout << "\nPress RETURN to continue...";
    std::cin.get();

    return 0;
}

A类{
公众：
A（int-val）；
~A（）{}；
国际瓦卢阿；
};
A：：A（int-val）{
val_a=val；
};
类Foo{
公众：
Foo（）；
~Foo（）；
void createA（）；
我的天啊；
};
Foo：：Foo（）{
createA（）；
};
void Foo:：createA（）{
my_a=新的a（20）；
};
Foo:：~Foo（）{
删除我的_a；
};
B类{
公众：
向量向量机；
void createFoo（）；
B（）{}；
~B（）{}；
};
void B:：createFoo（）{
向量推回（Foo（））；
};
int main（）{
B B；
int i=0；
对于（i=0；i<5；i++）{
std:：cout您需要为Foo实现一个复制构造函数和一个赋值运算符。每当您发现需要析构函数时，您肯定也需要这两个。它们在许多地方都有使用，特别是用于将对象放入标准库容器中

复制构造函数应如下所示：

Foo :: Foo( const Foo & f ) : my_a( new A( * f.my_a ) ) {
}

Foo::Foo(const Foo& copy)
    : my_a(copy.my_a)
{}

Foo::Foo(const Foo& copy)
    : my_a(new A(*copy.my_a))
{}

和赋值运算符：

Foo & Foo :: operator=( const Foo & f ) {
    delete my_a;
    my_a = new A( * f.my_a );
    return * this;
}

或者更好的是，不要在Foo类中动态创建A实例：

class Foo {      
      public:
             Foo();
             ~Foo();
             void createA();
             A my_a;
};

Foo::Foo() : my_a( 20 ) {
};

复制Foo对象，并在销毁每个副本时，对同一指针值my_a调用delete。
为Foo实现复制和分配运算符或使用智能指针

 Foo( const Foo& s) : my_a( s.my_a ? new A(*s.my_a) : 0) {
 }

 Foo& operator= (const Foo& s) {
     Foo temp(s); 
     temp.swap (*this);
     return *this;
 }

 void swap (Foo &s) { 
     std::swap (my_a, s.my_a);  
 }; 

如果未指定副本构造函数，编译器将为您创建一个副本构造函数。编译器生成的副本构造函数如下所示：

Foo :: Foo( const Foo & f ) : my_a( new A( * f.my_a ) ) {
}

Foo::Foo(const Foo& copy)
    : my_a(copy.my_a)
{}

Foo::Foo(const Foo& copy)
    : my_a(new A(*copy.my_a))
{}

呜呜！你只是复制了指针，而不是指向内存的指针。你在
createFoo（）
中的临时
Foo（）
和复制到向量中的那一个都指向同一内存，因此内存被删除两次，这会在第二次删除时使程序崩溃

您应该创建一个如下所示的复制构造函数：

Foo :: Foo( const Foo & f ) : my_a( new A( * f.my_a ) ) {
}

Foo::Foo(const Foo& copy)
    : my_a(copy.my_a)
{}

Foo::Foo(const Foo& copy)
    : my_a(new A(*copy.my_a))
{}

请注意，如果
copy
有一个NULL
my_a
成员，并且它还调用了
a
上的复制构造函数（您也没有指定），那么这会崩溃。因此您需要做一些进一步的更改。您还需要一个
操作符=
重载。
谢谢Neil。那么我应该如何创建类a的实例？一个代码nippet将不胜感激。另外，复制构造函数和赋值运算符代码的效果如何。非常感谢您的输入错误…new a（f.my_a）；->new a（*f.my_a）；嗨，尼尔，非常感谢你的代码片段。实际上，我想在将Foo实例放入向量时传递
my_a
的
int-val
。我该怎么做？-->我想要这样的东西：（当然不起作用）
vec.push_back（Foo（）：my_a（40）
@memC您需要给Foo构造函数一个整数参数，然后将其传递给A构造函数。@尼尔：哦，我明白了。谢谢。
Foo:：Foo（int-val）：我的A（val）
完成了。谢谢