Question

我了解到复制构造函数使用的动机之一是避免程序中的跟随崩溃 -

#include <iostream>
using namespace std;

class Employee {
public:
    Employee(int ID,char const * name){...};
    ~Employee(){...};

    // Methods
    void Print();

private:
    // members
    int m_ID;
    char* m_name;
};

void MyFunc(Employee emp) {

    cout << "in MyFunc \n ";

}

int main() {
    Employee One(1,"Garen Torosian");

// calling copy constructor
    MyFunc(One);

    cout << "In the end of main \n";

// Here the program crashes!
    return 0;
}

你可以看到程序应该在return 0;之前崩溃，但是当我运行该程序时它工作正常并且终止正常，为什么？

编辑：在这种情况下，程序确实崩溃了 -

// Employee.h
#include <iostream>
using namespace std;

class Employee {
public:
   Employee(int ID, 
                   const char* name);
  ~Employee();

  // Methods
  void Print();

private:
  // members
  int   m_ID;
  char* m_name;
};

// Employee.cpp
#include "Employee.h“

Employee::Employee(int iID, const char *name){ // Ctor
  cout << "Constructor called" << endl;
  m_ID = iID;
  m_name = new char [strlen(name) +1];
  strcpy(m_name, name);
  Print();
}
void Employee::Print() { // Print
cout << "ID: " << m_ID << ",Name:” << m_name
<< " ,Address(pointer):0x" << hex << (int) m_name<< endl;
}
Employee::~Employee() { // Dtor
  cout << "Destructor called"<<endl;
  Print();
  delete [] m_name;
  m_name=NULL;
}

void MyFunc(Employee emp) {

  cout << "in MyFunc \n ";    

}

int main()
{
    Employee One(1,"Eli Rachamim");

// calling copy constructor
MyFunc(One);

cout<< "In the end of main \n“;

// Here the program crashes! 
return 0;
}

Answer 1

如果您d-tor就像

~Employee(){ delete[] name; }

并为你的char*指针分配内存，并且你没有copy c-tor，而不是编译器生成的copy c-tor memberwise-copy，当你复制时会调用double-free宾语。所以，会有memory dump，在大多数情况下会给你UB（在实际调用析构函数中已经被破坏的对象是delete[]并且在已删除对象上调用UB也是copy c-tor）。但如果你不使用内存 - d-tor，编译器生成的效果很好。

修改

因此，您的第二个示例演示了double-free对已经被破坏的对象以及{{1}}的调用。

Answer 2

为什么你认为它应该崩溃？

如果你没有提供一个自动生成的拷贝构造函数，那么C ++有一个不幸的特性，而你的MyFunc（）并没有真正做任何会被自动生成的副本搞砸的东西。

复制构造函数动机 - 为什么我的程序不会崩溃？

2 个答案: