相关概念

什么是面向过程的语言?

  • 面向过程就是自顶向下、逐层求解的一种程序设计方法。函数分解法。
  • 过程,就是实现从某个输入集合到某个输出集合的一个映射。 C 和 C++ 的函数都是过程。
  • 模块 = 函数 1+ 函数 2+…

面向过程的语言 :FORTRAN 、 COBOL 、 ALGOL 、 PASCAL 、 BASIC 、C 等等

什么是面向对象的语言?

  • 面向对象的程序中,类才是程序的组成模块。
  • 模块 = 类 1+ 类 2+… = 对象 1+ 对象 2+…
  • 类 = 变量 + 函数 =

面向对象的语言: C++ 、 java 、 python 等等

C++ 语言是面向过程的还是面向对象的?

C++ 语言是对 C 语言的扩展和改进,从这个意义上说,它是面向过程的。

C++ 语言引入了全新的面向对象的特性,这些是C 语言等面向过程的语言所没有的,所以它又是面向对象的。

综合上述, C++ 是一门混合型语言,它既可以面向过程,也可以面向对象,这取决于使用它的程序员是如何使用 C++ 来设计他的程序的。

对象和类

  • 对象:我们把问题空间中的事物和它们在解空间中的表示统称为对象。

    一个汽车是一个对象,组成汽车的发动机也是一个对象

    张三是一个对象,李四也是一个对象

  • 类是具有相同行为和属性的一组对象的集合体 , 对象是类的一个实例。

    你是一个对象,我也是一个对象,我们都有手有脚,会走路会说话。

    这个地球上的所有和你我一样的对象,就构成了“人”类。

  • 类可以看成是一种类型。更高级的,可以灵活扩展的类型。

    包含属性(类的成员变量)和方法(类的成员函数)。

类和类之间的关系

  • 没关系：鱼类和汽车类，无关。
  • is a sort of：人类、鸟类和动物类，人类 is a sort of 动物类。
  • has a：汽车类和发动机类，汽车类has a 发动机类。

面向对象的程序设计方法( OOP )

  • 万物皆对象。
  • 程序就是一组对象,对象之间通过发送消息互相通知做什么。
  • 每一个对象都有它自己的由其他对象构成的存储区。
  • 每一个对象都有一个类型。
  • 一个特定类型的所有对象都能接收相同的消息

C++相对C的增加之处

1. 类

#include using namespace std;//People是一个类（类 就是 类型）struct People{//成员变量，或者叫做属性char *name;int age;//成员函数，或者叫做方法void talk(){ cout << "talk something!" << endl;}void walk(){ cout << "he is walking!\n";}};int main(int argc, char *argv[]){People a, b;//a是一个People类型的对象，b也是一样a.walk();b.talk();cout << "sizeof(a) = " << sizeof(a) << endl;cout << "sizeof(People) = " << sizeof(People) << endl;cout << "sizeof(b)= " << sizeof(b) << endl;return 0;}

2. C++的命名空间

#include using namespace std;//A是一个命名空间namespace A{int a;void foo(){cout << "A::foo" << endl;}} //通常情况下，最后不加分号，加上不会报错。int main(int argc, char *argv[]){A::a = 10;A::foo();cout << "A::a = " << A::a << endl; 　 return 0;}

想像一下，如果每次调用变量a,都要在前面加上A::，岂不是很复杂，解决方法就是使用using namespace A导出命名空间A里的符号。用法如下所示：

#include using namespace std;namespace A{int a;void foo(){cout << "A::foo" << endl;}}using namespace A; //导出B名字空间的内容到当前名字空间。//using B::a;//只导出B名字空间里的a，引用foo();是需要在前面补充命名空间A::int main(int argc, char *argv[]){A::a = 10;cout << "A::a = " << A::a << endl;a = 200;cout << "A::a = " << a << endl;A::foo();foo();return 0;}

如果命名空间B中有变量跟全局变量重名，那会出现什么情况呢？

#include using namespace std;namespace A{int a;void foo(){cout << "A::foo" << endl;}}using namespace A; //导出B名字空间的内容到当前名字空间。//using B::a;//只导出B名字空间里的a，引用foo();是需要在前面补充命名空间A::int main(int argc, char *argv[]){A::a = 10;cout << "A::a = " << A::a << endl;a = 200;cout << "A::a = " << a << endl;A::foo();foo();return 0;}

此时编译的话，编译器会给出错误,如下所示：

b.cpp:In function ‘int main()’:b.cpp:33:error:reference to ‘a’ is ambiguousb.cpp:18:error:candidates are:int ab.cpp:5:error: int B::ab.cpp:33:error:reference to ‘a’ is ambiguousb.cpp:18:error:candidates are:int ab.cpp:5:error: int B::ab.cpp:36:error:call of overloaded ‘foo()’ is ambiguousb.cpp:19:note:candidates are:void foo()b.cpp:12:note: void B::foo()b.cpp:40:error:reference to ‘a’ is ambiguousb.cpp:18:error:candidates are:int ab.cpp:5:error: int B::ab.cpp:40:error:reference to ‘a’ is ambiguousb.cpp:18:error:candidates are:int ab.cpp:5:error: int B::a

大体意思就是说，该程序有歧义，对于变量a，已从命名空间B中导出到当前命名空间中，但是当前命名空间中，也存在一个变量a，这也就造成了模糊不清、有歧义的现状。如果想程序通过，将using namespace B;注释掉即可。

关于无名的命名空间，全局变量和普通的全局函数，都属于无名的命名空间，除了直接调用外，还可以使用::的方式调用，如下所示

#include using namespace std;namespace B{int a;void foo();}using namespace B;void B::foo(){cout << "B::foo" << endl;}//c和foo属于一个无名的名字空间int c;void foo(){cout << "::foo" << endl;}int main(int argc, char *argv[]){c = 1;cout << "c = " << c << endl;::c = 2;cout << "::c = " << ::c << endl;B::foo();::foo();return 0;}

c语言中，如果有同名的全局变量和局部变量，程序中访问时，遵循的是就近原则。根据上述调用无名的命名空间符号的方法，可以实现任意访问同名全局变量和局部变量其一的方法，如下所示

#include using namespace std;int c = 3;int main(int argc, char *argv[]){int c = 4;cout << "c = " << c << endl;cout << "::c = " << ::c << endl;c = 1;cout << "c = " << c << endl;::c = 2;cout << "::c = " << ::c << endl;return 0;}

对于一个已经定义好的命名空间，我们可以扩展它的符号。如下所示：

#include using namespace std;namespace B{int a;}namespace B{//扩展之前的B名字空间int f;}using namespace B;int main(int argc, char *argv[]){B::a = 50;B::f = 100;cout << "B::a = " << B::a << endl;cout << "B::f = " << B::f << endl;return 0;}

3. 布尔类型

c语言中，使用stdbool.h头文件来扩展使用bool类型。但是，stdbool.h提供的bool类型，其实还是还是用typedef定义的。并不是真正的bool类型。C++中提供了真正了bool类型。

如下所示：

#include using namespace std;typedef int BOOL;//C语言中的bool实现形式#define TRUE 1#define FALSE 0int main(int argc, char *argv[]){bool cond = true; //原生支持BOOL cond1 = TRUE;if(cond)cout << "true" << endl;if(cond1)cout << "TRUE" << endl;}

为了更好的看到这其中的区别，
我们使用gdb调试一下。

(gdb) display cond1:cond=true(gdb) display cond12:cond1=1

如果布尔变量用在算术表达式中，将被隐式的转换为int版，true就是1，false就是0。

4. 引用类型

引用类型是C++引入的一种新类型。引用类型的符号为&，关于引用类型的相关注意问题，见程序注释。

#**include**<iostream>**using****namespace**std;**int**main(){**int**n=10;**int**m=1000;**int***pn=&n; //指针pn指向变量n**int**&rn=n; //rn为变量n的引用，引用相当于变量的别名或者外号，因此该处的n和rn的地址是一样的。rn只是n的一个外号，引用类型不占用空间，本条语句没有新加变量。//1.引用被创建的同时必须初始化/*错误用法int &rn;rn = n;*///2.不能有NULL引用/*错误用法int &rn = NULL;*///3.不能创建常量的引用/*错误用法int &rn = 100;*///4.创建引用后 不能改变引用的对象。/*语法没错，这样做，只是把m的值赋给rn，这两句话等价于int n = m;int &rn = n;rn = m;cout << "rn = " << rn << endl;*/cout<<"&n = "<<hex<<&n<<endl;cout<<"&pn = "<<hex<<&pn<<endl;cout<<"&rn = "<<hex<<&rn<<endl;return 0;}

通过输出，我们可以发现，n的地址和rn的地址是相同的，因此rn是不占用空间的，它就是n的一个别名；

4.1 引用的主要功能

4.1.1 做函数参数

引用类型做函数参数，省去了值复制的过程，加快了程序的执行。

#include using namespace std;void swap(int &x, int &y){int tmp;tmp = x;x = y;y = tmp;}int main(int argc, char *argv[]){int i = 3, j = 4;swap(i, j);cout << "i = " << i << endl;cout << "j = " << j << endl;}

引用就是变量的别名，是从C++语法角度来理解的。从底层实现来看，引用就是用const指针实现的，只不过C++语法限定了它不能像指针一样使用它。因此swap函数通过引用类型直接访问了main函数的i和j变量。相对C语言里传递变量的指针来修改变量的值的方法，传递变量的引用，代码显的更简练。

4.1.2 做返回值

注意返回局部变量的引用问题。返回一个全局变量的引用时，函数调用可以做左值。

#include using namespace std;int data = 1;int &foo(){data = 2;return data;}int main(int argc, char *argv[]){cout << "data = " << data << endl;foo();cout << "data = "<< data << endl;foo() = 3;cout << "data = " << data << endl;return 0;}

5. 变量初始化

int data = 10;//定义+初始化int data(10);//定义变量data的同时，对data用10进行了初始化。等价于上面的一行代码

6. 分配空间（new、delete和malloc、free）

C语言中，动态分配内存，我们使用的是malloc/free函数，C++中的new/delete就相当于C中的malloc/free。new/delete写出的代码更加紧凑。同时，new操作会触发类的构造函数，delete会触发类的析构函数（后面类的部分，会介绍），因此C++中，就不要再使用malloc/free函数了。

malloc(100);//分配100个字节，单位为长度。返回值为void *，使用时要强转,如char *p = (char *)malloc(100);free(p);//释放malloc分配的空间new int[100];//分配100个int，即100 * 4 = 400字节，单位为个数。返回值为对应类型的指针，如int * p = new int[100];delete[] p;//释放new出来的空间

关于delete的使用规则，遵循如下两条即可。

  • new的时候没有带[],那么delete后面无需加[];
    int *p = new int;delete p;
  • new的时候带[],那么delete后面也要加[]
    int *p = new int[10];delete[] p;

再考虑一下这个问题，new int[10];跟new int(10);有什么区别？

  • new int[10]表示分配10个int的空间，即40字节；
  • new int(10)表示分配一个int的空间，即4字节，并用10初始化之。

7. 缺省参数

函数的声明：没有函数体
函数的定义：也是一种声明，需要分配存储空间
变量的声明：不分配空间，只说明程序中有这个符号
变量的定义：分配空间
比如：

int data; //data分配了空间，所以它是定义，但是其本身也是一种声明，表示该符号可引用。extern int data; //纯声明，其实现在其它源文件中。

变量的声明和定义与函数的声明和定义有一定区别，注意区分。

缺省参数只能出现在声明中，不能出现在定义中

void foo(int a = 0, int b = 0);void foo(int a, int b){//...}foo();//3种方式均可成功调用，没有写的参数用缺省值代替foo(1);foo(1, 2);

缺省参数只能从右向左连续缺省，不能跳过。因此foo(, 2);这种写法是错误的。再比如

void foo(int x, int y， int z){//...}//foo函数的缺省参数写法如下所示#if 1 //正确foo(int x = 0, int y = 1, int z = 2);foo(int x, int y, int z);foo(int x, int y, int z = 3);foo(int x, int y = 5, int z = 4); #else//错误foo(int x = 0, int y = 0, int z);foo(int x, int y = 0, int z);foo(int x = 0, int y, int z);foo(int x = 0, int y, int z = 0);#endif

下面是使用函数缺省参数的一个示例程序

#include using namespace std;void foo(int a = 1, int b = 2, int c = 2);void foo(int a, int b, int c){cout << "a = " << a << endl;cout << "b = " << b << endl;cout << "c = " << c << endl;}int main(int argc, char *argv[]){foo();foo(0);foo(0, 0);foo(0, 0, 0);}

8. 重载（overload）

8.1 函数重载

函数重载的表现是函数名相同，函数参数不同（包括参数类型和个数）。如下所示就是函数的重载：

/**add.c**/int add(int a, int b){return (a + b);}double add(double a, double b){return (a + b);}float add(float a, float b){return (a + b);}

使用Linux上的nm命令查看符号表，对比

$ g++add.c-c$ nm add.o0000000e T _Z3adddd00000034T _Z3addff00000000 T _Z3addii

也就是说，这3个名为add的c++函数相当于_Zadddd、_Zaddff、_Zaddii的3个新函数，这3个函数依次对应double、float、int3个名为add的C++函数（可以用linux上的c++filt命令出函数声明），到了链接阶段（g++ -c,只编译和汇编，不链接，下一步就是链接了），add函数就不重名了。在C语言中没有重载的概念，如果用gcc编译add.c，就会有错误提示：函数add重复定义。

函数重载（overload）可以使功能相同或者相似，并且具有统一接口和调用形式的一类函数，显得代码更紧凑。

8.2 运算符重载

上一节中，不同add函数里里都有a + b，这里的+号，就是重载的operator+运算符。再举个例子：cout<<"abc"<<100<<'d'<<endl;。这里的cout重载的是operator()运算符，具体有operator(int)、operator(char)、operator(float)、operator(char *)等等。

9. 在C++中调用C的库函数

c库函数提供的头文件应该统一写成如下形式，使用extern "C"包起来，目的时告知C++，在链接时把这里面的所有符号（变量、函数等）当成C语言版本的符号来处理。

#ifdef __cplusplusextern "C"{#endif//...extern int interval;extern int add(int a, int b);//...#ifdef __cplusplus}#endif

如C++中调用C库提供的add函数

/**add.c**/double add(double a, double b){return (a+b);}
/**add.h**/#ifdef __cplusplusextern "C"{#endifextern double add(double, double);#ifdef __cplusplus}#endif
/**main.cpp**/#include #include "add.h"using namespace std;int main(int argc, char *argv[]){cout << "add(1.2, 3.4) = " << add(1.2, 3.4) << endl;return 0;}

执行流程如下

$ gcc add.c-c$ ar rs libadd.a add.o$ g++main.cpp-o appcpp-L.-ladd$ ./appcpp #c++调用C库add(1.2,3.4)=4.6

上面讲到的都是C++中新增加的基础知识概念。除此之外，C++相比C还新增了很多高级语法（比如智能指针）、库函数（比如list库）等等，高级语言的丰富特性使得我们使用起来更加方便，更加高效，留待大家在后面的学习过程中持续去发现吧。