学步园

首先通过一段代码的测试情况来了解位拷贝

#include <fstream>
#include <string>
using namespace std;
ofstream out("HowMany.out");

class HowMany {
  static int objectCount;
public:
  HowMany() { objectCount++; }
  static void print(const string& msg = "") {
    if(msg.size() != 0) out << msg << ": ";
    out << "objectCount = "
         << objectCount << endl;
  }
  ~HowMany() {
    objectCount--;
    print("~HowMany()");
  }
};

int HowMany::objectCount = 0;

// Pass and return BY VALUE:
HowMany f(HowMany x) {
  x.print("x argument inside f()");
  return x;
}

测试一

int main() {
  HowMany h;
  HowMany::print("after construction of h");
  HowMany h2;
  out<<"test1........"<<endl;
  h2 = f(h);
  out<<"test2........"<<endl;
  HowMany::print("after call to f()");
} ///:~

这段代码的输出文件内容为：

after construction of h: objectCount = 1
test1........
x argument inside f(): objectCount = 2
~HowMany(): objectCount = 1
~HowMany(): objectCount = 0
test2........
after call to f(): objectCount = 0
~HowMany(): objectCount = -1
~HowMany(): objectCount = -2

测试二

int main() {
  HowMany h;
  HowMany::print("after construction of h");
  HowMany h2= f(h);
  out<<"test1........"<<endl;
  HowMany::print("after call to f()");
}

输出结果为：

after construction of h: objectCount = 1
x argument inside f(): objectCount = 1
~HowMany(): objectCount = 0
test1........
after call to f(): objectCount = 0
~HowMany(): objectCount = -1
~HowMany(): objectCount = -2

以上两种测试情况出现的结果都是由于位拷贝造成的。

f()函数通过按值传递方式传入参数，即在函数体内增加了一个对象，这个对象是原对象的一个位拷贝；所以在函数调用的最后，局部对象出了其范围，会调用析构函数，使objectcount减一。测试一与测试二的区别在于测试一中h2的创建调用了构造函数objectCount会加一，但f()函数返回一个对象的时候也会调用一个位拷贝，然后将这个拷贝的对象赋值给h2，函数调用的最后也会调用析构函数。而测试二中的h2的创建是直接通过位拷贝产生的。

以下内容是摘自http://www.51testing.com/html/81/n-831781.html

　　位拷贝拷贝的是地址（也叫浅拷贝），而值拷贝则拷贝的是内容（深拷贝）。深拷贝和浅拷贝可以简单理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。

　　位拷贝，及"bitwise assignment"是指将一个对象的内存映像按位原封不动的复制给另一个对象，所谓值拷贝就是指，将原对象的值复制一份给新对象。 在用"bitwise assignment"时会直接将对象的内存映像复制给另一个对象，这样两个对象会指向同一个内存区域，当一个对象被释放后，另一个对象的指针会成为空指针。这时，就应该编写operator=和copy constructor来实现值拷贝 。

　　默认的拷贝构造函数”和“缺省的赋值函数”均采用“位拷贝”而非“值拷贝”的方式来实现，倘若类中含有指针变量，这两个函数注定将出错。

　　当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用。也就是说，当类的对象需要拷贝时，拷贝构造函数将会被调用。以下情况都会调用拷贝构造函数：

　　1、一个对象以值传递的方式传入函数体

　　2、一个对象以值传递的方式从函数返回

　　3、一个对象需要通过另外一个对象进行初始化。

　　如果在类中没有显式地声明一个拷贝构造函数，那么，编译器将会自动生成一个默认的拷贝构造函数，该构造函数完成对象之间的位拷贝。位拷贝又称浅拷贝。自定义拷贝构造函数是一种良好的编程风格，它可以阻止编译器形成默认的拷贝构造函数，提高源码效率。

如果没有自定义复制构造函数，则系统会创建默认的复制构造函数，但系统创建的默认复制构造函数只会执行“位拷贝”，即将被拷贝对象的数据成员的值一一赋值给新创建的对象，若该类的数据成员中有指针成员，则会使得新的对象的指针所指向的地址与被拷贝对象的指针所指向的地址相同，delete该指针时则会导致两次重复delete而出错。下面拿这个经典示例：

　　如果以String为例定义strA和strB

　　如果不主动编写拷贝构造函数和赋值函数，编译器将以“位拷贝”的方式自动生成缺省的函数。倘若类中含有指针变量，那么这两个缺省的函数就隐含了错误。以类String的两个对象strA,strB为例，假设strA.m_data的内容为“hello”，strB.m_data的内容为“world”。 现将strA赋给strB，缺省赋值函数的“位拷贝”意味着执行strB.m_data =strA.m_data。这将造成三个错误：

　　● strB.m_data 原有的内存没被释放，造成内存泄露；

　　● strB.m_data和strA.m_data指向同一块内存，strA或strB任何一方变动都会影响另一方；

　　● 在对象被析构时，m_data被释放了两次。

　　对于编译器，如果不主动编写拷贝函数和赋值函数，它会以位拷贝的方式自动生成缺省的函数。