C ++悬空指针/深层复制/浅层复制混乱

Question

我听说当我们将相同的地址分配给两个不同的指针时，就会出现悬空指针问题。 这是由于两个指针都指向相同的内存位置，并且如果使用一个指针中的地址释放了内存； 它仍然可以从第二个指针访问（甚至从第一个指针访问，如果未设置为null，则我不在讨论这种情况）。

在下面的代码中，我尝试了不同的场景，在这些场景中，应该将相同的内存位置分配给不同的指针，但是显然，在每种情况下，它都在分配新的内存。 为什么会这样呢？ 在每种情况下，都会创建深层副本。

#include<iostream>

using namespace std;

class Player
{
    public:
        char * name;
        char * countryName;
        char * gameName;
        int age;

        Player()
        {
        }

        Player(char * n, char * c, char * g,int a)
        {
            name=n;
            countryName=c;
            gameName=g;
            age=a;
        }
};


void printAddresses(Player p,Player p3)
{
    cout<<endl<<&p3<<endl<<&p<<endl;
    cout<<endl<<&p3.name<<endl<<&p.name<<endl;
    cout<<endl<<&p3.countryName<<endl<<&p.countryName<<endl;
    cout<<endl<<&p3.gameName<<endl<<&p.gameName<<endl;
    cout<<endl<<&p3.age<<endl<<&p.age<<endl;
}

int main()
{
    Player *p2=new Player;

    Player *p4=p2;

    // p2 is a pointer and p4 is also a pointer initialized from p2. But the following function prints the memory addresses, and it shows that both objects have different memory addresses. And data members also have different memory locations
    printAddresses(*p4,*p2);

    return 0;
}

我还尝试了很多方案来初始化指针。 但是在每种情况下，它们似乎都有单独的内存地址，并且相应的数据成员也都有不同的内存地址。

那么在哪种情况下这里会出现悬空指针问题？ 或者如何在此处进行浅表复制？ 这是c ++标准/版本（写在下面）的行为是这样的还是我缺少什么？

操作系统：Linux Mint 15

g ++ --version的输出：

g++ (Ubuntu/Linaro 4.7.3-1ubuntu1) 4.7.3
Copyright (C) 2012 Free Software Foundation, Inc.

Answer 1

您的问题是，您正在传递价值。

因此您的参数有自己的地址，该地址与指针的地址不同。 您想要通过指针或引用传递：

在这里查看示例：

// by pointer
void printAdressesPtr(int* p1, int* p2) {
  std::cout << "p1 - ptr: " << p1 << " - value: " << *p1 << std::endl;
  std::cout << "p2 - ptr: " << p2 << " - value: " << *p2 << std::endl;

  // while now the addresses of p1 and p2 are different
  std::cout << "p1 - ptr adr: " << &p1 << std::endl;
  std::cout << "p2 - ptr adr: " << &p2 << std::endl;
}

// by reference
void printAdressesRef(int& r1, int& r2) {
  std::cout << "r1 - ref: " << &r1 << " - value: " << r1 << std::endl;
  std::cout << "r2 - ref: " << &r2 << " - value: " << r2 << std::endl;
}

// by value. this will not work, since values are copied.
void printAdressesVal(int v1, int v2) {
  std::cout << "v1 - ref: " << &v1 << " - value: " << v1 << std::endl;
  std::cout << "v2 - ref: " << &v2 << " - value: " << v2 << std::endl;
}

int main() {
  int* ptr1 = new int(123);
  int* ptr2 = ptr1;

  printAdressesPtr(ptr1, ptr2);
  printAdressesRef(*ptr1, *ptr2);
  printAdressesVal(*ptr1, *ptr2);

  return 0;
}

如您所见，到给定指针/ refenreces（ptr1 && ptr2）的所有地址都相同，所有值也都相同，但是参数的地址不同。

编辑

这些都是浅表副本（年龄除外）。 因为您只复制指针（指针指向的地址），而不复制成员的值。 对于深拷贝，Player的每个实例都需要为每个值分配自己的内存。

您已将此问题标记为c ++，因此请改用c ++的东西。

class Player {
public:
  std::string name;
  std::string countryName;
  std::string gameName;
  int         age;

  Player() {}

  // this is not a copy constructor
  Player(std::string const& n, std::string const& c, std::string const& g, int a)
    : name(n), countryName(c), gameName(g), age(a) {} // this are deep copies

  // this is a copy constructor
  Player(Player const& cpy)
    : name(cpy.name)
    , countryName(cpy.countryName)
    , gameName(cpy.gameName)
    , age(cpy.age) {} // this are deep copies
};

否则，您必须自己处理分配和删除操作。 这看起来像：

class Player {
public:
  char* name;
  char* countryName;

  Player()
    : name(nullptr), countryName(nullptr) {}

  // this is not a copy constructor
  Player(char* n, char* c) {
    // this is a deep copy. name has his own memmory allocated and the value is copied
    // from n to name
    name = new char[strlen(n) + 1]; 
    strcpy(name, n);

    // this is a shallow copy. contryName and c have the same address of the value.
    // changing contryName of P2 is also changing contryName of P1. also there is no
    // guarantee that enough space is allocated!!!! use std::string!!!
    contryName = c;
  }


  // this is a copy constructor
  Player(Player const& cpy) {
    // this is a deep copy. name has his own memmory allocated and the value is copied
    // from n to name
    name = new char[strlen(cpy.name) + 1]; 
    strcpy(name, cpy.name);

    // this is a shallow copy. contryName and c have the same address of the value.
    // changing contryName of P2 is also changing contryName of P1. also there is no
    // guarantee that enough space is allocated!!!! use std::string!!!
    contryName = c;
  }

  ~Player() {
    if(name != nullptr)
      delete name;
    name = 0;

    // this will also delete contryName of P1. acces from P1 is undefined behavior...
    // use std::string!!!
    if(contryName != nullptr)
      delete[] contryName;
    contryName = 0;
  }
};

您还必须重载operator =，因为上面的示例仅适用于构造函数...

简而言之，请使用std :: string

EDIT2：

我忘了提到您没有复制构造函数。 Player p1=p2; // this is initialization Player p1=p2; // this is initialization需要一个副本构造函数，否则将使用编译器生成的副本构造函数，除非使用std :: string :)，否则它将以浅表副本结尾