拷贝构造函数是一种特殊的构造函数，在创建对象时，它是使用同一类中之前创建过的对象来初始化新创建的对象。如果没有自定义拷贝构造函数，系统会提供一个缺省的拷贝构造函数，缺省的拷贝构造函数对于基本类型的成员变量，按字节复制，对于类类型成员变量，调用其相应类型的拷贝构造函数。
我们在编写程序的过程中，如果不主动编写拷贝构造函数和赋值函数，编译器将会调用默认的函数，如果类中含有指针变量，那么如果使用的默认的函数就会有错误，下面首先我们先进行简单的介绍，之后再用具体的例子来加以说明。
1.拷贝构造函数和赋值函数
拷贝构造函数，顾名思义，它是一个构造函数，所以它是在对象创建的时候被主动调用的函数，可以将
另外一个对象的变量拷贝给当前对象。赋值函数，是在对象已经存在的情况下才会进行调用。
12
#include <iostream>
#include <set>
using namespace std;
class Test {
public:
Test() { // 默认构造函数
cout << "Test()" << endl;
};
Test(int v) :value(v) { // 带参数的构造函数
cout << "Test(int v)" << endl;
}
Test(const Test& obj){ //拷贝构造函数
cout << "Test(const Test& obj)" << endl;
}
Test& operator=(const Test& obj)
{
cout << "Test& operator=(const Test& obj)" << endl;
return *this;
}
~Test() { // 析构函数
}
private:
int value;
};
int main() {
Test a(1);
Test c = a;
Test d;
d = a;
getchar();
return 0;
}
123456789101112131415161718192021222324252627282930313233343536
（1）拷贝构造函数和赋值函数
Test c = a;
d = a;1这里第一个"=“时对象c还没有存在，所以这里调用的是拷贝构造函数，第二个”="时对象d已经存在了，所以调用的是赋值函数
（2）拷贝构造函数 拷贝构造函数是其它构造函数的重载函数，它的参数是const对象的引用，const比较容易理解，我们将一个对象拷贝给另外一个对象，那该对象的值我们是不希望被改变了的，另外一个原因是，添加 const 限制后，就可以将 const 对象和非 const 对象传递给形参了，因为非 const 类型可以转换为 const 类型，如果没有 const 限制，就不能将 const 对象传递给形参，因为 const 类型不能转换为非 const 类型，这就意味着，不能使用 const 对象来初始化当前对象了；那么这里我们为什么选择传递对象的引用作为函数的参数呢？一个原因是引用传参的时候，形参是实参的一个别名，也就是说它们俩其实是相同的，但是如果我们不传递引用的话，在进入函数的时候，会另外分配一块存储空间给形参使用，形参将会初始化实参的值，在函数调用结束的时候，这块存储空间将会被释放掉，如果说对象比较大的话，在这个初始化的过程中将会比较的耗时；还有一个十分重要的原因是我们在调用拷贝构造函数的时候，如果传递的是对象的话，由于要将实参的值赋给形参，将会调用拷贝构造函数进行赋值，那么就会形成一个死循环，如果您将上述拷贝构造函数中的"&"删除掉，程序将会报错。
3）赋值函数 赋值函数用到的是运算符的重载，它的返回值是对象的引用，参数是const对象的引用。对于返回值而言，我们希望保留运算符原有的特性，考虑到a=b=c，这个赋值语句的顺序应该是a=(b=c)，所以赋值函数重载函数的返回值应该是类的对象，返回对象的引用是因为如果返回对象的话，将会把原先对象的值赋值给临时的对象，这样还会调用一次拷贝构造函数。赋值函数的参数是对象的引用，一个原因是节省时间，另外一个原因是使函数可以传递const的对象。
#include <iostream>
using namespace std;
class Test {
public:
Test() { // 默认构造函数
cout << "Test()" << endl;
};
Test(int v) :value(v) { // 带参数的构造函数
cout << "Test(int v)" << endl;
}
Test(const Test& obj){ //拷贝构造函数
cout << "Test(const Test& obj)" << endl;
}
Test operator=(const Test& obj)
{
cout << "Test& operator=(const Test& obj)" << endl;
return *this;
}
~Test() { // 析构函数
}
private:
int value;
};
int main() {
Test a(1);
Test c = a;
Test d;
d = c = a;
getchar();
return 0;
}
1234567891011121314151617181920212223242526272829303132333435
由于赋值函数的返回值是对象，这里在函数返回时就调用了拷贝构造函数。
2.何时调用拷贝构造函数
（1）定义一个对象时，以本类另一个对象作为初始值，发生拷贝构造。
（2）如果函数的形参是类的对象，调用函数时，将使用实参初始化形参，发生拷贝构造。
（3）如果函数的返回值是类的对象，函数执行完成返回主调函数时，将使用return语句中的对象初始化
一个临时的无名对象，传递给主调函数，发生拷贝构造。
1234
3.浅拷贝和深拷贝
浅拷贝：如果用默认的拷贝构造函数（赋值函数）去赋值有指针类型的成员变量的对象，将会使两个对象
的指针地址也是一样的，也就是说这两个对象的指针成员变量指向的是相同的地址。
深拷贝：每个对象拥有自己的资源，此时需要显示提供拷贝构造函数和赋值函数。
123
如果调用了默认的拷贝构造函数（赋值函数），在拷贝过程中是按字节复制的，对于指针型成员变量只复制指针本身，而不复制指针所指向的目标，这将会使同一指针指向相同的区域，同时也会导致同一块资源被释放多次，从而造成错误。
下面的例子是显示定义的赋值函数。
#include <iostream>
#include <string.h>
using namespace std;
class Test {
public:
Test():ptr(new char[1]) { // 带参数的构造函数
cout << "Test():ptr(new char[1])" << endl;
}
Test operator=(const Test& obj)
{
if (this == &obj) { // s=s
return *this;
}
delete[] ptr;
ptr = new char[strlen(obj.ptr) + 1];
strcpy(ptr, obj.ptr);
cout << "Test& operator=(const Test& obj)" << endl;
return *this;
}
Test& operator=(const char *s)
{
delete[] ptr;
ptr = new char[strlen(s) + 1];
strcpy(ptr, s);
cout << "Test& operator=(const Test& obj)" << endl;
return *this;
}
~Test() { // 析构函数
delete[] ptr;
}
private:
char* ptr;
};
int main() {
Test a;
a= "test";
Test b;
b= a;
Test d;
getchar();
return 0;
}
1234567891011121314151617181920212223242526272829303132333435363738394041424344
在对象拷贝过程中，如果没有自定义拷贝构造函数，系统会提供一个缺省的拷贝构造函数，缺省的拷贝构造函数对于基本类型的成员变量，按字节复制，对于类类型成员变量，调用其相应类型的拷贝构造函数。
阅读《高质量的c c++编程》，第9章有这样一段话，类似的话在《c++primer》《effective C++》都有所提及，那就是拷贝构造函数问题，这个是类编写者的一个基础问题。
位拷贝（浅拷贝）举例，a指向b，b的改变其实会影响a的改变，同时a原本指向的空间发生泄漏。
然后这种情况下有了深拷贝。
我对其绘制思维导图，方便阅读并用分点的方式进行总结；
何时调用？
以下情况都会调用拷贝构造函数： 一个对象以值传递的方式传入函数体 一个对象以值传递的方式从函数返回 一个对象需要通过另外一个对象进行初始化。
**浅拷贝：**位拷贝，拷贝构造函数，赋值重载
多个对象共用同一块资源，同一块资源释放多次，崩溃或者内存泄漏
**深拷贝：**每个对象共同拥有自己的资源，必须显式提供拷贝构造函数和赋值运算符。
缺省拷贝构造函数在拷贝过程中是按字节复制的，对于指针型成员变量只复制指针本身，而不复制指针所指向的目标--浅拷贝。
我们用自己编写的string举例
class String
{
public:
const char* c_str()
{
return _str;
}
String(const char* str = "")
:_str(new char[strlen(str) + 1])
{
strcpy(_str, str);
}
String(const String &s)
:_str(NULL)
{
String tmp(s._str);
swap(_str, tmp._str);
}
~String()
{
if (_str)
{
delete[]_str;
}
}
private:
char* _str;
};通过开辟空间的方式，进行深拷贝
String s1("字符串1");
String s2(s1);
cout << s2.c_str() << endl;
拷贝成功；
这种方式采取的 拷贝构造，注意这个
String(const String &s)
:_str(NULL)
{
String tmp(s._str);
swap(_str, tmp._str);
}代码解析：其中this指向拷贝的对象，s指向试图拷贝的原对象。(测试中的 this指向s2，s指向s1）
其中利用构造函数开辟空间，建立临时的tmp，然后进行交换完成拷贝。
当然，我们也可以使用赋值操作符重载完成这一功能（如例子s1=s2）
String& operator =(const String& s)
{
if (this != &s)
{
String tmp(s._str);
swap(tmp._str, _str);
return *this;
}
}//调用构造析构
//本代码是tmp调用的构造函数
String(const char* str = "")
:_str(new char[strlen(str) + 1])
{
strcpy(_str, str);
}
/*String tmp（s._str）
调用这个构造函数，开辟空间，建立一个和s1一样大小的空间，并拷贝值
*/代码解析：
s1（this），s2（s）
建立tmp，tmp有和s2一样大的空间，一样的数值（调用构造函数），然后交换使s1（this）指向2号空间，获得拷贝，tmp指向3号空间，tmp生命周期结束调用析构函数释放，功能完成。
当然 赋值重载函数可以写的更加简洁
String &operator=(String s)
{
swap(_str, s._str);
return *this;
}C++中类的拷贝有两种：深拷贝，浅拷贝：当出现类的等号赋值时，即会调用拷贝函数
一：两个的区别
1 在未定义显示拷贝构造函数的情况下，系统会调用默认的拷贝函数——即浅拷贝，它能够完成成员的一一复制。当数据成员中没有指针时，浅拷贝是可行的；但当数据成员中有指针时，如果采用简单的浅拷贝，则两类中的两个指针将指向同一个地址，当对象快结束时，会调用两次析构函数，而导致指针悬挂现象，所以，此时，必须采用深拷贝。
2 深拷贝与浅拷贝的区别就在于深拷贝会在堆内存中另外申请空间来储存数据，从而也就解决了指针悬挂的问题。简而言之，当数据成员中有指针时，必须要用深拷贝。
二 带实例的解释
c++默认的拷贝构造函数是浅拷贝
浅拷贝就是对象的数据成员之间的简单赋值，如你设计了一个没有类而没有提供它的复制构造函数，当用该类的一个对象去给令一个对象赋值时所执行的过程就是浅拷贝，如：
class A
{
public:
A(int _data) : data(_data){}
A(){}
private:
int data;
};
int main()
{
A a(5), b = a; // 仅仅是数据成员之间的赋值
}
这一句b = a;就是浅拷贝，执行完这句后b.data = 5;
如果对象中没有其他的资源（如：堆，文件，系统资源等），则深拷贝和浅拷贝没有什么区别，
但当对象中有这些资源时，例子：
class A
{
public:
A(int _size) : size(_size)
{
data = new int[size];
} // 假如其中有一段动态分配的内存
A(){};
~A()
{
delete [] data;
} // 析构时释放资源
private:
int* data;
int size;
}
int main()
{
A a(5), b = a; // 注意这一句
}
这里的b = a会造成未定义行为，因为类A中的复制构造函数是编译器生成的，所以b = a执行的是一个浅拷贝过程。我说过浅拷贝是对象数据之间的简单赋值，比如：
b.size = a.size;
b.data = a.data; // Oops!
这里b的指针data和a的指针指向了堆上的同一块内存，a和b析构时，b先把其data指向的动态分配的内存释放了一次，而后a析构时又将这块已经被释放过的内存再释放一次。对同一块动态内存执行2次以上释放的结果是未定义的，所以这将导致内存泄露或程序崩溃。
所以这里就需要深拷贝来解决这个问题，深拷贝指的就是当拷贝对象中有对其他资源（如堆、文件、系统等）的引用时（引用可以是指针或引用）时，对象的另开辟一块新的资源，而不再对拷贝对象中有对其他资源的引用的指针或引用进行单纯的赋值。如：
class A
{
public:
A(int _size) : size(_size)
{
data = new int[size];
} // 假如其中有一段动态分配的内存
A(){};
A(const A& _A) : size(_A.size)
{
data = new int[size];
} // 深拷贝
~A()
{
delete [] data;
} // 析构时释放资源
private:
int* data;
int size;
}
int main()
{
A a(5), b = a; // 这次就没问题了
}
总结：深拷贝和浅拷贝的区别是在对象状态中包含其它对象的引用的时候，当拷贝一个对象时，如果需要拷贝这个对象引用的对象，则是深拷贝，否则是浅拷贝。
一、C++ 编译模式
通常，在一个 C++ 程序中，只包含两类文件—— .cpp 文件和 .h 文件。其中，.cpp 文件被称作 C++ 源文件，里面放的都是 C++ 的源代码；而 .h 文件则被称作 C++ 头文件，里面放的也是 C++ 的源代码。
C++ 语言支持"分别编译"（separatecompilation）。也就是说，一个程序所有的内容，可以分成不同的部分分别放在不同的 .cpp 文件里。.cpp 文件里的东西都是相对独立的，在编译（compile）时不需要与其他文件互通，只需要在编译成目标文件后再与其他的目标文件做一次链接（link）就行了。比如，在文件 a.cpp 中定义了一个全局函数 "void a(){}"，而在文件 b.cpp 中需要调用这个函数。即使这样，文件 a.cpp 和文件 b.cpp 并不需要相互知道对方的存在，而是可以分别地对它们进行编译，编译成目标文件之后再链接，整个程序就可以运行了。
这是怎么实现的呢？从写程序的角度来讲，很简单。在文件 b.cpp 中，在调用 "void a()" 函数之前，先声明一下这个函数 "voida();"，就可以了。这是因为编译器在编译 b.cpp 的时候会生成一个符号表（symbol table），像 "void a()" 这样的看不到定义的符号，就会被存放在这个表中。再进行链接的时候，编译器就会在别的目标文件中去寻找这个符号的定义。一旦找到了，程序也就可以顺利地生成了。
注意这里提到了两个概念，一个是"定义"，一个是"声明"。简单地说，"定义"就是把一个符号完完整整地描述出来：它是变量还是函数，返回什么类型，需要什么参数等等。而"声明"则只是声明这个符号的存在，即告诉编译器，这个符号是在其他文件中定义的，我这里先用着，你链接的时候再到别的地方去找找看它到底是什么吧。定义的时候要按 C++ 语法完整地定义一个符号（变量或者函数），而声明的时候就只需要写出这个符号的原型了。需要注意的是，一个符号，在整个程序中可以被声明多次，但却要且仅要被定义一次。试想，如果一个符号出现了两种不同的定义，编译器该听谁的？
这种机制给 C++ 程序员们带来了很多好处，同时也引出了一种编写程序的方法。考虑一下，如果有一个很常用的函数 "void f() {}"，在整个程序中的许多 .cpp 文件中都会被调用，那么，我们就只需要在一个文件中定义这个函数，而在其他的文件中声明这个函数就可以了。一个函数还好对付，声明起来也就一句话。但是，如果函数多了，比如是一大堆的数学函数，有好几百个，那怎么办？能保证每个程序员都可以完完全全地把所有函数的形式都准确地记下来并写出来吗？
二、什么是头文件
很显然，答案是不可能。但是有一个很简单地办法，可以帮助程序员们省去记住那么多函数原型的麻烦：我们可以把那几百个函数的声明语句全都先写好，放在一个文件里，等到程序员需要它们的时候，就把这些东西全部 copy 进他的源代码中。
这个方法固然可行，但还是太麻烦，而且还显得很笨拙。于是，头文件便可以发挥它的作用了。所谓的头文件，其实它的内容跟 .cpp 文件中的内容是一样的，都是 C++ 的源代码。但头文件不用被编译。我们把所有的函数声明全部放进一个头文件中，当某一个 .cpp 源文件需要它们时，它们就可以通过一个宏命令 "#include" 包含进这个 .cpp 文件中，从而把它们的内容合并到 .cpp 文件中去。当 .cpp 文件被编译时，这些被包含进去的 .h 文件的作用便发挥了。
举一个例子吧，假设所有的数学函数只有两个：f1 和 f2，那么我们把它们的定义放在 math.cpp 里：
/* math.cpp / double f1() { //do something here.... return; } double f2(double a) { //do something here... return a * a; } / end of math.cpp */
并把"这些"函数的声明放在一个头文件 math.h 中：
/* math.h / double f1(); double f2(double); / end of math.h */
在另一个文件main.cpp中，我要调用这两个函数，那么就只需要把头文件包含进来：
/* main.cpp / #include "math.h" main() { int number1 = f1(); int number2 = f2(number1); } / end of main.cpp */
这样，便是一个完整的程序了。需要注意的是，.h 文件不用写在编译器的命令之后，但它必须要在编译器找得到的地方（比如跟 main.cpp 在一个目录下）main.cpp 和 math.cpp 都可以分别通过编译，生成 main.o 和 math.o，然后再把这两个目标文件进行链接，程序就可以运行了。
三、#include
#include 是一个来自 C 语言的宏命令，它在编译器进行编译之前，即在预编译的时候就会起作用。#include 的作用是把它后面所写的那个文件的内容，完完整整地、一字不改地包含到当前的文件中来。值得一提的是，它本身是没有其它任何作用与副功能的，它的作用就是把每一个它出现的地方，替换成它后面所写的那个文件的内容。简单的文本替换，别无其他。因此，main.cpp 文件中的第一句（#include"math.h"），在编译之前就会被替换成 math.h 文件的内容。即在编译过程将要开始的时候，main.cpp 的内容已经发生了改变：
/* ~main.cpp / double f1(); double f2(double); main() { int number1 = f1(); int number2 = f2(number1); } / end of ~main.cpp */
不多不少，刚刚好。同理可知，如果我们除了 main.cpp 以外，还有其他的很多 .cpp 文件也用到了 f1 和 f2 函数的话，那么它们也通通只需要在使用这两个函数前写上一句 #include "math.h" 就行了。
四、头文件中应该写什么
通过上面的讨论，我们可以了解到，头文件的作用就是被其他的 .cpp 包含进去的。它们本身并不参与编译，但实际上，它们的内容却在多个 .cpp 文件中得到了编译。通过"定义只能有一次"的规则，我们很容易可以得出，头文件中应该只放变量和函数的声明，而不能放它们的定义。因为一个头文件的内容实际上是会被引入到多个不同的 .cpp 文件中的，并且它们都会被编译。放声明当然没事，如果放了定义，那么也就相当于在多个文件中出现了对于一个符号（变量或函数）的定义，纵然这些定义都是相同的，但对于编译器来说，这样做不合法。
所以，应该记住的一点就是，.h头文件中，只能存在变量或者函数的声明，而不要放定义。即，只能在头文件中写形如：extern int a; 和 void f(); 的句子。这些才是声明。如果写上 inta;或者 void f() {} 这样的句子，那么一旦这个头文件被两个或两个以上的 .cpp 文件包含的话，编译器会立马报错。（关于 extern，前面有讨论过，这里不再讨论定义跟声明的区别了。）
但是，这个规则是有三个例外的:
- 一，头文件中可以写 const 对象的定义。因为全局的 const 对象默认是没有 extern 的声明的，所以它只在当前文件中有效。把这样的对象写进头文件中，即使它被包含到其他多个 .cpp 文件中，这个对象也都只在包含它的那个文件中有效，对其他文件来说是不可见的，所以便不会导致多重定义。同时，因为这些 .cpp 文件中的该对象都是从一个头文件中包含进去的，这样也就保证了这些 .cpp 文件中的这个 const 对象的值是相同的，可谓一举两得。同理，static 对象的定义也可以放进头文件。
- 二，头文件中可以写内联函数（inline）的定义。因为inline函数是需要编译器在遇到它的地方根据它的定义把它内联展开的，而并非是普通函数那样可以先声明再链接的（内联函数不会链接），所以编译器就需要在编译时看到内联函数的完整定义才行。如果内联函数像普通函数一样只能定义一次的话，这事儿就难办了。因为在一个文件中还好，我可以把内联函数的定义写在最开始，这样可以保证后面使用的时候都可以见到定义；但是，如果我在其他的文件中还使用到了这个函数那怎么办呢？这几乎没什么太好的解决办法，因此 C++ 规定，内联函数可以在程序中定义多次，只要内联函数在一个 .cpp 文件中只出现一次，并且在所有的 .cpp 文件中，这个内联函数的定义是一样的，就能通过编译。那么显然，把内联函数的定义放进一个头文件中是非常明智的做法。
- 三，头文件中可以写类（class）的定义。因为在程序中创建一个类的对象时，编译器只有在这个类的定义完全可见的情况下，才能知道这个类的对象应该如何布局，所以，关于类的定义的要求，跟内联函数是基本一样的。所以把类的定义放进头文件，在使用到这个类的 .cpp 文件中去包含这个头文件，是一个很好的做法。在这里，值得一提的是，类的定义中包含着数据成员和函数成员。数据成员是要等到具体的对象被创建时才会被定义（分配空间），但函数成员却是需要在一开始就被定义的，这也就是我们通常所说的类的实现。一般，我们的做法是，把类的定义放在头文件中，而把函数成员的实现代码放在一个 .cpp 文件中。这是可以的，也是很好的办法。不过，还有另一种办法。那就是直接把函数成员的实现代码也写进类定义里面。在 C++ 的类中，如果函数成员在类的定义体中被定义，那么编译器会视这个函数为内联的。因此，把函数成员的定义写进类定义体，一起放进头文件中，是合法的。注意一下，如果把函数成员的定义写在类定义的头文件中，而没有写进类定义中，这是不合法的，因为这个函数成员此时就不是内联的了。一旦头文件被两个或两个以上的 .cpp 文件包含，这个函数成员就被重定义了。
五、头文件中的保护措施
考虑一下，如果头文件中只包含声明语句的话，它被同一个 .cpp 文件包含再多次都没问题——因为声明语句的出现是不受限制的。然而，上面讨论到的头文件中的三个例外也是头文件很常用的一个用处。那么，一旦一个头文件中出现了上面三个例外中的任何一个，它再被一个 .cpp 包含多次的话，问题就大了。因为这三个例外中的语法元素虽然"可以定义在多个源文件中"，但是"在一个源文件中只能出现一次"。设想一下，如果 a.h 中含有类 A 的定义，b.h 中含有类 B 的定义，由于类B的定义依赖了类 A，所以 b.h 中也 #include了a.h。现在有一个源文件，它同时用到了类A和类B，于是程序员在这个源文件中既把 a.h 包含进来了，也把 b.h 包含进来了。这时，问题就来了：类A的定义在这个源文件中出现了两次！于是整个程序就不能通过编译了。你也许会认为这是程序员的失误——他应该知道 b.h 包含了 a.h ——但事实上他不应该知道。
使用 "#define" 配合条件编译可以很好地解决这个问题。在一个头文件中，通过 #define 定义一个名字，并且通过条件编译 #ifndef...#endif 使得编译器可以根据这个名字是否被定义，再决定要不要继续编译该头文中后续的内容。这个方法虽然简单，但是写头文件时一定记得写进去。
C++ 头文件和源文件的区别
一、源文件如何根据 #include 来关联头文件
- 1、系统自带的头文件用尖括号括起来，这样编译器会在系统文件目录下查找。
- 2、用户自定义的文件用双引号括起来，编译器首先会在用户目录下查找，然后在到 C++ 安装目录（比如 VC 中可以指定和修改库文件查找路径，Unix 和 Linux 中可以通过环境变量来设定）中查找，最后在系统文件中查找。
#include "xxx.h"（我一直以为 "" 和 <> 没什么区别，但是 tinyxml.h 是非系统下的都文件，所以要用 ""）
二、头文件如何来关联源文件
这个问题实际上是说，已知头文件 "a.h" 声明了一系列函数，"b.cpp" 中实现了这些函数，那么如果我想在 "c.cpp" 中使用 "a.h" 中声明的这些在 "b.cpp"中实现的函数，通常都是在 "c.cpp" 中使用 #include "a.h"，那么 c.cpp 是怎样找到 b.cpp 中的实现呢？
其实 .cpp 和 .h 文件名称没有任何直接关系，很多编译器都可以接受其他扩展名。比如偶现在看到偶们公司的源代码，.cpp 文件由 .cc 文件替代了。
在 Turbo C 中，采用命令行方式进行编译，命令行参数为文件的名称，默认的是 .cpp 和 .h，但是也可以自定义为 .xxx 等等。
谭浩强老师的《C 程序设计》一书中提到，编译器预处理时，要对 #include 命令进行"文件包含处理"：将 file2.c 的全部内容复制到 #include "file2.c" 处。这也正说明了，为什么很多编译器并不 care 到底这个文件的后缀名是什么----因为 #include 预处理就是完成了一个"复制并插入代码"的工作。
编译的时候，并不会去找 b.cpp 文件中的函数实现，只有在 link 的时候才进行这个工作。我们在 b.cpp 或 c.cpp 中用 #include "a.h" 实际上是引入相关声明，使得编译可以通过，程序并不关心实现是在哪里，是怎么实现的。源文件编译后成生了目标文件（.o 或 .obj 文件），目标文件中，这些函数和变量就视作一个个符号。在 link 的时候，需要在 makefile 里面说明需要连接哪个 .o 或 .obj 文件（在这里是 b.cpp 生成的 .o 或 .obj 文件），此时，连接器会去这个 .o 或 .obj 文件中找在 b.cpp 中实现的函数，再把他们 build 到 makefile 中指定的那个可以执行文件中。
在 Unix下，甚至可以不在源文件中包括头文件，只需要在 makefile 中指名即可（不过这样大大降低了程序可读性，是个不好的习惯哦^_^）。在 VC 中，一帮情况下不需要自己写 makefile，只需要将需要的文件都包括在 project中，VC 会自动帮你把 makefile 写好。
通常，C++ 编译器会在每个 .o 或 .obj 文件中都去找一下所需要的符号，而不是只在某个文件中找或者说找到一个就不找了。因此，如果在几个不同文件中实现了同一个函数，或者定义了同一个全局变量，链接的时候就会提示 "redefined"。
综上所诉
.h文件中能包含：
- 类成员数据的声明，但不能赋值
- 类静态数据成员的定义和赋值，但不建议，只是个声明就好。
- 类的成员函数的声明
- 非类成员函数的声明
- 常数的定义：如：constint a=5;
- 静态函数的定义
- 类的内联函数的定义
不能包含：
- 1． 所有非静态变量（不是类的数据成员）的声明
- 2。 默认命名空间声明不要放在头文件，using namespace std;等应放在.cpp中，在 .h 文件中使用 std::string
原文地址：https://blog.csdn.net/qq_35038153/article/details/71293265
note
.h 文件中能包含： static 普通变量和普通函数的定义，但是不能包含，static 成员函数和成员变量的定义。
原因在于 static 这个关键词其实有两个不同的含义：
- static 修饰普通的变量和函数时。
- static 关键字是为了限制可见性。
举例：
void funcA(){ int a =0; a++; printf(a) }，如果要连续记录调用了多少次，就得使用全局变量，但是全局变量暴露的太多了，其他文件中也能可见，所以，static a 用于仅本文件可见。
而 static 修饰类的成员变量时，该成员是属于类本身，所有类的实例对象共享。
class A{
public:
static int a;
}
其他文件 include 类定义的头文件 classA.h，本质上相当于复制。假设我们现在不 #include "classA.h" 而是直接写。
例如 a.cpp 写上上述头文件，然后再加上 int A::a = 3;, 在 b.cpp 中写上上述头文件，然后再加上 int A::a = 3;, 等于是定义了两次，此时发生重定义问题（根源在于 static 成员变量并不限制仅本文件可见），所以头文件中不能包含，static 成员函数和成员变量的定义，只能声明。