在面向对象的程序开发中，一般做法是将类的声明(其中包含成员函数的声明)放在指定的头文件中，用户如果想用该类，只要把有关的头文件包含进来即可，不必在程序中重复书写类的声明，以减少工作量，节省篇幅，提高编程的效率。
由于在头文件中包含了类的声明，因此在程序中就可以用该类来定义对象。由于在类体中包含了对成员函数的声明，在程序中就可以调用这些对象的公用成员函数。为了实现上一节所叙述的信息隐蔽，对类成员函数的定义一般不放在头文件中，而另外放在一个文件中。
例如，可以分别写两个文件：
//student.h (这是头文件，在此文件中进行类的声明)
class Student //类声明
public :
void display( );//公用成员函数原型声明
private :
int num;
char name[20];
char sex;
//student.cpp
//在此文件中进行函数的定义
#include <iostream>
#include ″student.h″//不要漏写此行，否则编译通不过
void Student∷display()//在类外定义display类函数
cout<<″num:″<<num<<endl;
cout<<″name:″<<name<<endl;
cout<<″sex:″<<sex<<endl;
为了组成一个完整的源程序，还应当有包括主函数的源文件：
//main.cpp 主函数模块
#include <iostream>
#include ″student.h″ //将类声明头文件包含进来
int main( )
Student stud;//定义对象
stud.display( );//执行stud对象的display函数
return 0;
这是一个包括3个文件的程序，组成两个文件模块：
一个是主模块main.cpp，
一个是student.cpp。
在主模块中又包含头文件student.h。在预编译时会将头文件student.h中的内容取代#include ″student.h″行。
请注意： 由于将头文件student.h放在用户当前目录中，因此在文件名两侧用双撇号包起来(″student.h″)而不用尖括号(<student.h>)，否则编译时会找不到此文件。
图8.6。
在运行程序时调用stud中的display函数，输出各数据成员的值。
如果一个类声明多次被不同的程序所选用，每次都要对包含成员函数定义的源文件(如上面的student.cpp)进行编译，这是否可以改进呢？的确，可以不必每次都对它重复进行编译，而只需编译一次即可。把第一次编译后所形成的目标文件保存起来，以后在需要时把它调出来直接与程序的目标文件相连接即可。这和使用函数库中的函数是类似的。这也是把成员函数的定义不放在头文件中的一个好处。
在实际工作中，并不是将一个类声明做成一个头文件，而是将若干个常用的功能相近的类声明集中在一起，形成类库。
类库有两种：
-
C++编译系统提供的标准类库；
-
用户根据自己的需要做成的用户类库，提供给自己和自己授权的人使用，这称为自定义类库。
在程序开发工作中，类库是很有用的，它可以减少用户自己对类和成员函数进行定义的工作量。
类库包括两个组成部分：
-
类声明头文件；
-
已经过编译的成员函数的定义，它是目标文件。
用户只需把类库装入到自己的计算机系统中(一般装到C++编译系统所在的子目录下)，并在程序中用#include命令行将有关的类声明的头文件包含到程序中，就可以使用这些类和其中的成员函数，顺利地运行程序。这和在程序中使用C++系统提供的标准函数的方法是一样的，例如用户在调用sin函数时只需将包含声明此函数的头文件包含到程序中，即可调用该库函数，而不必了解sin函数是怎么实现的(函数值是怎样计算出来的)。
当然，前提是系统已装了标准函数库。在用户源文件经过编译后，与系统库(是目标文件)相连接。
在用户程序中包含类声明头文件，类声明头文件就成为用户使用类的公用接口，在头文件的类体中还提供了成员函数的函数原型声明，用户只有通过头文件才能使用有关的类。用户看得见和接触到的是这个头文件，任何要使用这个类的用户只需包含这个头文件即可。包含成员函数定义的文件就是类的实现。
请特别注意：类声明和函数定义一般是分别放在两个文本中的。由于要求接口与实现分离，为软件开发商向用户提供类库创造了很好的条件。
开发商把用户所需的各种类的声明按类放在不同的头文件中，同时对包含成员函数定义的源文件进行编译，得到成员函数定义的目标代码。软件商向用户提供这些头文件和类的实现的目标代码(不提供函数定义的源代码)。用户在使用类库中的类时，只需将有关头文件包含到自己的程序中，并且在编译后连接成员函数定义的目标代码即可。
由于类库的出现，用户可以像使用零件一样方便地使用在实践中积累的通用的或专用的类，这就大大减少了程序设计的工作量，有效地提高了工作效率。
通过上述步骤，我们在file2.
cpp
中
使用了extern关键字来
调用
了file1.
cpp
中
的函数function1()。无论是使用头文件和函数声明还是使用extern关键字，都可以实现在
一个
cpp
文件
中
调用
另
一个
cpp
文件的函数。第二步：创建第二个
cpp
文件，命名为file2.
cpp
，使用extern关键字来
调用
第
一个
cpp
文件
中
的函数。第二步：创建第二个
cpp
文件，命名为file2.
cpp
，通过包含头文件来
调用
第
一个
cpp
文件
中
的函数。C++
中
在
一个
cpp
文件
中
调用
另
一个
cpp
文件的函数有两种方法。
引入了对象的
一个
同义词。定义
引用
的表示方法与定义指针相似，只是用&代替了*。
引用
（reference）是c++对c语言的重要扩充。
引用
就是某一变量（目标）的
一个
别名，对
引用
的操作与对变量直接操作完全一样。
引用
的声明方法：
类
型标识符 &
引用
名=目标变量名；
引用
说明：
（1）&在此不是求地址运算，而是起标识作用。
（2）
类
型标识符是指目标变量的
类
型。
（3）声明
引用
时，必须同时对其进行初始化。
（4）
引用
声明完毕后，相当于目标变量名有两个名称，即该目
最后我想在teaPage.
cpp
里面访问这个stuList，只需要在teaPage.
cpp
中
包含stuPage.h，然后在
调用
的时候加上前缀mainPage::即可。其他数据
类
型如指针、数组也是同样的方式。假设在stuPage.h
中
声明了
一个
放置Student
类
型元素的vector数组stuList，先将其声明为public的static
类
型；下图是在teaPage.
cpp
里面
调用
stuList的代码。
在面向对象的程序开发
中
，一般做法是将
类
的声明(其
中
包含成员函数的声明)放在指定的头文件
中
，用户如果想用该
类
，只要把有关的头文件包含进来即可，不必在程序
中
重复书写
类
的声明，以减少工作量，节省篇幅，提高编程的效率。
由于在头文件
中
包含了
类
的声明，因此在程序
中
就可以用该
类
来定义对象。由于在
类
体
中
包含了对成员函数的声明，在程序
中
就可以
调用
这些对象的公用成员函数。为了实现上一节所叙述的信息隐蔽，对
类
成
创建1个func2.
cpp
通过include 引入func1.
cpp
来使用func1里面的方法(如果有单独的头文件，比如func1.h 可以通过#include“func1.h”)C++
中
在
一个
cpp
文件
中
引用
另外
一个
cpp
文件 可以通过导入
cpp
文件或者.h文件来实现，
类
似python
中
的import 导入。
----C++头文件相互
引用
,
一个
#include,另
一个
class C
C++头文件相互#include时最好是:
(1)在"CA.h"
中
#include "CB.h".
(2)在"CB.h"
中
用
类
的前向声明: class CA;
(3)最好加上头文件卫士( #ifndef *** #define *** #endif)
示例如下:
(1)在"CA.h"
中
#include "CB.h".
(2)在"CB.h"
中
用
类
的前向声明: class CA;
(3)最好加上头文件卫士( #ifndef *** #define *** #endif)
2.示例代码
(1)"C
有时候写代码为了简便，会将一些函数方法单独在
一个
cpp
的源文件
中
定义，然后在另
一个
源文件
中
需要用到自定义的函数时直接
调用
就可以了！学过c++的人可能最熟悉的方法还是利用头文件来进行
调用
，其实还有一种c语言当
中
的方法一般情况下同样可以适用与c++
中
！
方法1：创建头文件
举个简单的例子：
首先创建
一个
method.h头文件，声明
一个
求最大值的函数max(int x,int y)，然后再创建
一个
同名的源文件method.
cpp
，在该文件
中
实现函数max(int x,int y)的功能。代码如下：
//metho
文件test1.
cpp
有
类
class A;文件test2.
cpp
有
类
class B.如在test2.
cpp
中
想用A：#include "test1.
cpp
"当然一般的做法是将
类
的声明放在.h文件里，定义放在.
cpp
文件，然后可以直接在B
类
中
保存
一个
A
类
的指针，那样即可实现使用A
类
了。
转载于:https://www.cnblogs.com/ryanzheng/p/8455031.html...
