Question

在使用指向Foo类的指针返回Foo1对象后，我遇到了访问冲突错误。函数Foo2::something(int)的结果是Foo1对象。问题是：Foo** array Foo2::something(int)结果无法访问。

class Foo{
  int x;
public: 
  int getX() { return x; }
 Foo& operator=(const Foo &rhs){
  x = rhs.x; 
  return *this;
}
};
class Foo1{
  Foo** array;
  int size;
public:
  Foo1(int size){
   array = new Foo*[size]
   for(int i=0; i < size;i++)
       array[i] = new Foo[size];
  }  
 Foo1(const Foo1& foo): array(foo.array), size(foo.size){}
 ~Foo1(){
    for(int i=0; i < size);i++)
       delete[] array[i];
    delete[] array;
  }
 Foo getFoo(int x, int y){
    return array[x][y];
 }
 void setFoo(int x,int y,Foo foo){
    array[x][y] = foo;
 }
 Foo1& operator=(const Foo1& foo){
   array = foo.array;
   size = foo.size;
 }
};
class Foo2{
public:
  Foo1 something(int size){
    Foo1 obj(size);
    return obj;         
  }
};
int main(){
 Foo2 foo2;
 Foo1 obj = foo2.something(3);
 obj.getFoo(0,0).getX(); // <- access violation here 
}

Answer 1

Foo1 something(int size){
  Foo1 obj(size);
  return obj;         
}

您创建一个对象obj并将其返回。让我们检查你的拷贝构造函数是否负责复制数据：

Foo1(const Foo1& foo): array(foo.array), size(foo.size){}

这是一个浅层副本：数组的内容未被复制，而Foo1 obj中的临时对象和main都将拥有成员{{ 1}}指向相同的数据。但是，事后会发生什么？

array

此时Foo1 obj = foo2.something(3); // what happens here ^^^^^ ?中的obj将被销毁。因此，它的析构函数将被调用。而且析构函数会删除数组的内容。

进行深层复制（分配新内存并复制数组），使用引用计数（以确保不要过早删除数组）或使用something或类似的隐藏管道

进一步说明：启用编译器警告。您的大部分非虚空功能都不使用std::vector< std::vector<Foo> >。

访问冲突0xFEEEFEEE无法访问组件

1 个答案: