^函数重载的匹配：

          当函数名被重载后，函数的匹配过程：首先寻找能精确匹配的函数，如果未能精确匹配，则尝试找一个可以模糊匹配的函数。

1）精确匹配：参数个数相同，类型相同。

2）模糊匹配：参数个数相同，类型不同，但支持隐式转换。

^参数默认值

1）具有默认值的参数必须要放在后面。

2）当函数声明与定义分开时，应把默认写在声明里，不能写在定义里。          

    void show(int x,int y,int z=1);  //默认值加在函数声明里              

    int main()             

 {            

          ...          

    }      

void show(int x,int y,int z)      //函数定义之处不能加默认值   

   {        

...     

 }

 ^内联函数：

在函数前加一个inline关键字，该函数称为内联函数。

^函数的递归调用：

1）将高阶问题转化为低阶相同问题。

2）必须设置终止条件，避免无限制递归。

3）可以替换为非递归算法，改善循环语法。

4）控制递归深度。

***指针^内存地址的表示：  a在内存中对应4个字节；            

  unsigned int a=0xA0A0A0A0;    //a内存中的值：A0 A0 A0 A0            

  a = 0xB1B1B1B1;              //a内存中的值：B1 B1 B1 B1  变量地址是一个整数，可以用操作符&来取得。

例如：      inta = 0;  

                double b = 0;      

                printf("%08X\n"&a);          //把地址按十六进制来打印    

                printf("%08X\n"&b);          /*把址按照十六进制来打印^指针的概念：    XXX* 表示XXX型变量的地址。可以为char，int，double等,这种带*的类型叫做指针类型。*/

  指针(Pointer)意思是Point to an address.例如：         

   int a = 1；  

  int *p = &a；                //定义了一个int*型变量p，其值为a的地址。

1）指针变量也是变量。

2）不同类型的指针，不能互相赋值。

3）指针是一个整数类型。    在用printf打印时，通常使用的格式符为%p，p代表pointer。

4）*位置比较随意。

5）同类型指针可以混合定义。

^星号操作  “*”可以用来修改内存值，用在指针变量上可以直接读写内存的值。星号操作是一种按地址访问的技术，只要知道了这块内存的地址，就可以直接修改这块内存的值。

1）只有指针类型才支持星号操作。              int addrress = 0x12345678;        *addr = 0                      //编译错误！只有指针才支持星号操作

2）其他指针类型的用法是一样的。

3）区分星号的上下文^指针与数组    数组在内存中就相当于一串紧密排列的变量，数组名代表的就是这一块内存的首地址。

^指针加减法^指针与数组的转换

1）p指向arr的任意一个值；              p = arr+3;                      //指向arr[3]      p = &arr[3];                    //指向arr[3]

2）给数组元素赋值；              arr[3] = 10;      或：      *(arr+3) = 10;      或：      int* p=arr+3;      *p = 10;

3）把p当成数组使用              int* p = &arr[1];              //p指向arr[1]      p[0] = 0xAA;                    //p[0]:自p开始的第0号元素      p[1] = 0xBB；                  //p[1]:即arr[2]

4）长度为1的数组；    普通变量int a可以视为长度为1的数组来操作。            int a = 10;    int* p = &a;    p[1] = 11;              //长度为1的数组5）

数组的遍历；

方法一：            int arr[4] = {1,2,3,4};    for(int i = 0;i<4;i++)    {        printf("%d\n",arr[i]);    }

方法二：用指针遍历，注意终止条件为P来访问对象的成员，例如：            p->id = 20141011;                //使用->访问对象成员    strcpy(p->phone,"15928682083");  //使用->访问对象成员    也可以使用(*p).id,但是不常用。

3）做为函数参数    和基本类型一样，结构体也可以作为函数参数

4）做为函数返回值

5）作为结构体成员^结构体的特殊写法    结构体定义允许放在函数内部，这么定义的类型只能在函数内可见。由于struct语法的初衷是要定义一个呗多处使用的自定义类型，正常情况下应该定义在函数体之外。

^结构体的命名    结构体命名：“数字、字母、下划线的组合，不能以字母开头”。其次，命名要有意义，一个好的名字应该直接反映其意义。下面有两种常见的格式：

1）纯小写，以下划线分开每个单词，例如good_job,large_buffer.

2）每个单词以大写开头，在C++中推荐使用这种风格，结构体内成员变量，通常是小写，并以下划线分割每个单词。

^传值与传地址    在传输参数时，如果传入的是一个对象的值，叫“传值”方式，如果传入的是一个对象的地址，叫做“传地址”方式。

1）传值方式

2）传地址方式：

***联合体

1）概念：

***动态内存分配

1）动态内存分配malloc申请内存    应用程序调用malloc函数可以申请一块指定大小的内存，函数原型为：            #includevoid* malloc(int size);    参数：size：内存空间的大小，以字节为单位。    返回值：申请出来的这块内存首地址。    用法示例：            char* p = (char*) malloc(84);  //申请一块84字节的空间    内存管理空间并不关心这一块内存的用途，所以malloc的返回值是void* ，仅表示内存的地址。应用程序可以用来存储任何类型的数据。例如申请一块100个int型数据，示例如下            int* p = (int*)malloc(100*4);  //申请100*4内存    for(int i = 0;i<100;i++)    {        p[i] = i * i;              //使用这块内存    }  

  free释放内存          

  #includevoid free(void* ptr);    在使用完毕后，应用程序应当调用free函数来释放内存，当内存交给内存管理器，传入的参数就是先前用malloc得到的指针.

2）内存管理器与堆    内存管理器（MM）的职责就是提供内存服务，它管理的区域称为堆，malloc得到的内存的位置是在堆区。原则：尽可能少的申请内存，尽可能快的释放。    

堆内部管理：MM对借出的内存块进行标识：            (p0,n0)(p1,n1)(p2,n2)...    它内部已经保证任意两块不会交叠，不会把一块内存同时借给两个应用程序使用。    内存泄漏

3）对象的生命期    对象的分类：全局对象，局部对象，动态对象。    ①当定义一个变量时：Object a;,则变量a对应了一个对象，类型为Object,地址为&a，如果这个变量是全局变量，则a称为全局对象，如果这个变量是局部变量，则a称为局部对象。    当用malloc动态申请内存时：Object* p = (Object*)malloc(sizeof(Object));此时p指向了一个对象。该对象内存使动态分配的，称为动态对象。    一个对象总是对应了一块内存，对象的值就是内存里的数据。    对象生命期：全局对象生命期是永恒的，只有程序退出时才失效;局部对象生命期是临时的在超出作用域后对象立即消失;动态对象生命期是动态的，在malloc时生命生效，在free时失效。

4）常见问题  用malloc申请的内存，用完以后要用free释放。  不适用malloc得到的内存不能用free释放。  及时归还，再借不难。  不能只free一部分。  程序退出时，malloc内存都会自动释放归还给MM。***链表^概念    把若干对象用指针串联起来，形成一个链状数据结构，称为“链表”。            struct Student    {        int id; char name[16]; Student* naxt;    }    其中添加一个成员变量next，用于指向下一个对象。

^链表的构造

1）先准备好四个对象            Student ss[4]=    {        {201501,"John",0}, {201502,"Jennifer",0}, {201503,"Anxi",0}, {201504,"Unnamed",0}    };

2）把这个对象“串“起来            ss[0].next = &ss[0];    ss[1].next = &ss[1];    ss[2].next = &ss[2];    ss[3].next = 0;    一个链表构造完毕。

3）头节点与末节点    当若干个对象被串起来以后，只要知道第一个对象，就可以访问链表中的每一个对象。把链表中每个对象，称为“节点”。第一个节点也叫“头节点”

4）链表头的作用：可以用于代表整个链表：Student* stu_list = &ss[0];

^有头链表

1）概念:用一个固定的头节点来指代整个链表，所有的对象挂在这个头节点下面，而头节点本身并不包含有效数据。2）定义一个有头链表    只需要定义一个对象作为其节点，将成员next初始化为NULL。            Student m_head = {0,"head",NULL};    或者写：            Student m_head = {0};    当有对象加入时，直接加在后面就可以，当他的next为NULL时表示该节点没有数据节点（链表长度为0）。

3）添加一个节点            void add(Student* obj)    {          obj->next = m_head.next;  m_head.next = obj->next;    }    创建一个对象，然后调用add函数插入列表中。            Student* obj = (Student*)malloc(sizeof(Student));    obj->id = 12;    strcpy(obj->name,"X");    add(obj);                            上面的add函数直接把新的节点插在最前面，也可以把节点插到末尾，代码如下：            void add(Student* obj)    {          Student* p = &m_head;  while(p->next)        p = p->next;          p->next = obj;  obj->next = NULL;    }

4）有头链表的遍历    在遍历时，有头链表的头节点由于不含有数据，是不参与遍历的实际遍历时，只访问链表中的数据节点。            void show_all()    {                Student* p = m_head.next;  while(p)  {        printf("ID: %d,name: %s\n",p->id,p->name);p = p->next;  }    }

5）按顺序插入节点    先遍历链表，并比较ID的值，找到目标位置，并记录前一个节点为pre，找到位置后，把新的节点直接挂在pre后面。            obj->next = next->next;    pre->next = obj;6)查找和删除节点***引用^定义    在类型之后加上一个&符号，该变量即为引用类型。    引用只相当于对象的一个别名。

^与指针的区别    引用在定义时必须初始化关联到一个对象，例如：Object* p = NULL;      //允许在定义的时候不指向任何一个对象，如果在定义一个引用时不初始化，则编译器就会报错，例如：Object a;  Object& r;  //语法错，定义引用时必须初始化！    引用与某个对象绑定，中途无法解绑，而指针的使用较为灵活，一个指针可以先指向对象a，再指向对象b，引用可以视为功能受限的指针。

^简单的例子^作为函数参数   

 引用类型可以作为函数的参数，可以达到与指针相同的效果。

^做为函数返回值   

 引用也可以作为函数返回值，指针作为返回值是把某个对象的地址返回，^const引用    const引用限定被引用的对象为只读的，不能修改的对象，常用作函数的参数。***字符串^字符串的三种形式

1）字符数组    当以char型数组来存放字符串时，数组名时字符串的首地址。

2）动态字符串    可以动态分配一块内存，然后在这块内存里存放一串字符。也就是说，这个字符串对象在堆上。

3）字符串常量    在代码中用双引号包括，包含0..N个字符，称为字符串常量。^字符串常量多行表示    当一个字符串常量要表达的内容特别长时，在单独一行代码中可能书写不下，可以用两种方法分成多行。   

 第一种：使用双引号将多段文本连接起来，两个字符串之间可以被空格分开，不影响最终效果。例如              const char* str = "hello" "world";相当于：const char* str = "helloworld";   

 第二种：在末尾添加一个反斜线，例如：              const char* poem = "江山定\n\      风雨遮前路，冰火伴我行.\n\      一度波澜惊，而今江山定.\n\;

^字符串与与普通数据    

字符串是以char*表示的，它指向了字符串的首地址。实际上仅当这块内存用于存储字符串的时候，才把它称作字符串，如果只是把它用于存储一些普通数据则不能把它称作字符串。

^字符串的遍历    

遍历字符串指的是从前往后访问每一个字符，有两种方法：索引遍历和指针遍历。都需要检测结束符'\0'来判断是否结束。

^字符串长度    

是指从第一个字符开始，一直到末尾的结束符，中间的有效字符的个数，长度不包含末尾的'\0'在内。^字符串复制    字符串的复制，是指将源字符串的每一个字符挨个复制到目标缓存区，最终保证目标缓冲区的字符串末尾有一个'\0'字符。    

注意事项:目标缓冲区要足够大；目标缓冲区保证以0结束。可以使用里的strcpy函数。   

 区分深拷贝和浅拷贝：例如              char* p1 = "hello,world";      char* p2 = p1;    这种简单的这振赋值，就叫做浅拷贝，一句话表示：两个指针指向了同一个字符串对象。              char* p2 = (char*)malloc(strlen(p1)+1);      strcpy(2,p1);    这段代码新申请一块相同大小的内存，然后把字符串内容复制到这块内存，那么这两个字符串对象（两块内存），他们的内容相同，这种拷贝叫做深拷贝，一句话表示：两个指针（p1，p2），分别指向两个字符串对象。

^字符串比较    

字符串也可以比较是否相等，以及大小关系，只有当所有字符全部相同时才认为两者相等。两个字符则是按它们的ASCII码值大小进行比较。   

 一般直接使用里的strcmp函数来比较两个字符串。strcmp（a,b）,当相等时返回值为0，当ab时返回值为1.

^字符串插入与删除

1）删除字符

函数Erase用于字符串中某个字符的删除。

2）插入字符

函数Insert用于在源字符中插入一个字符。

^字符串分割

一个字符串由若干信息组成，每一段信息中间用分隔符分开，解析这个字符串，得到一段内容称之为字符串的分割。

^用数组还是指针

数组方式：

指针方式：

**标准C函数库

1）stdio.h

标准输入/输出函数

2）math.h

3）time.h

4）stdib.h

5）string.h

***文件操作

^认识文件

文件的作用是持久化存储数据。所谓持久化是指当关闭计算机电源后数据依然存在，再次打开计算机时，还可以重新加载显示这些数据。

^保存数据

使用ANSI C中的stdio.h里的相关数据来进行文件读写操作。步骤如下;

1）fopen：打开文件。

fopen函数用于打开文件，得到一个FILE*指针，该指针指代该文件，后续的fwrite/fclose等函数都需要传入这个文件指针。其原型为：

FILE fopen(const char *filename,const char *mode);

其中，filename:表示要打开的文件路径；mode：固定使用"wb"(w表示write,b表示binary);

用法示例：FILE* fp = fopen("c:/aaa.txt","wb");

if(fp == NULL)

{

printf("文件打开失败\n");

}

2）fwrite：写入数据。

当数据写入完毕，该文件不再被指针使用时，要及时调用fclose函数来关闭文件，其原型为：

int fclose(FILE* stream);

参数：stream就是前面fopen的返回值。用法示例：

fclose(p);

3）fclose：关闭文件。

fwrite用于向文件中写入数据，其原型为：

size_t fwrite(const void * buf,size_t size,size__t nelem,FILE * stream);

参数：stream就是前面fopen的返回值;buf:要写入的数据首地址;size：总是传1;nelem：数据长度。用法示例：

char buf[] = "hello";

fwrite(buf,1,5,fp);

^读取数据：就是把曾经写入的文件读取出来。

读取数据分为三步。

1）fopen打开文件

2）fread读取文件

fread函数原型为：

size_t fread(void * buf,size_t size,size_t nelem,FILE * stream);

参数：stream：前面fopen函数的返回值;buf：内存缓冲区，用于存储数据的内存位置;size：恒为1;nelem：最多读取多少字节;返回值：实际读取字节，如果

返回-1，则读取失败。用法示例：

char buf[128];

int n = fread(buf,1,128,fp);

如果文件中的数据不超过128字节，则返回值n就是实际的字节数。如果文件中的数据超过128字节，那这次操作只能读取128个字节。

3）fclose关闭文件

^数据的存储格式

第一种方式：

int x = 100;

int y = 100;

fwrite(&x,1,2,fp);

fwrite(&y,1,4,fp);

当以这种方式写入时，一共8个字节。可以用相应的代码，从文件中读取数据，并恢复x，y坐标。

int x,y;

fread(&x,1,4,fp);

fread(&y,1,4,fp);

第二种方式：

int x = 100;

int y = 200;

char buf[128];

sprintf*(buf,"x = %d,y = %d",x,y);

fwrite(buf,1,strlen(buf),fp);

这种方式把一个字符串“x = 100，y = 200”写入文件。

第三种方式：

int x = 123;

int y = 456;

char buf[128];

sprintf(buf,"%d%d",x,y);

fwrite(buf,1,strlen(buf),fp);

^存储格式：按字节存储

1）存储char类型

char ch = 12;

fwrite(&ch,1,1,fp);    //存

fread(&ch,1,1,fp);    //取

2）存储int类型

int n = 12;

fwrite(&n,1,sizeof(int),fp);    //存

fread(&n,1,sizeof(int),fp);      //取

3）存储double类型

double val = 123.456;

fwrite(&val,1,sizeof(val),fp);

fread(&val,1,sizeof(val),fp)

4）存储结构体类型

Object obj = {123};

fwrite(&obj,1,sizeof(obj),fp);

fread(&obj,1,sizeof(obj),fp);

5）存储字符串

char name[32] = "shaofa";

fwrite(name,1,32,fp);

fread(name,1,32,fp);

^存储格式：文本化存储

当数据量比较少时，可以把数据格式化为文本的形式来存储。

1)fprintf按行格式化写入

2)fgets按行读取

^文件的随机访问

在描述一个文件的可访问属性时，有两个术语。

顺序访问：不能跳跃。

随机访问：随意跳到一个位置访问。

1）fseek

2）文件位置指示器

3）随机访问实例

4）fseek的物理限制

5）文件被重复打开的情况

^文件打开模式

rb:读模式。当读一个文件使用。如果该文件不存在，则fopen返回NULL.

wb:写模式。再写一个文件时使用。

ab:附加模式。表示打开文件但不清空里面的内容。

***多文件项目及编译过程

^extern

1）extern声明全局函数

想要在main.cpp中调用其他.cpp中定义的函数，那么就必须在main.cpp里用extern声明这个函数，写法如下：

extern double get_area(double r);

以关键字extern修饰，在后面加上函数的原型，关键字extern不仅可以声明一个外部函数，还可以声明一个外部的全局变量。在声明全局时，关键字extern是

可以声明不写的。

2）extern声明全局变量

也可以在A.cpp里访问B.cpp里的全局变量，需要在A.cpp里用extern声明这个全局变量。

注意：在声明变量时不能加初始值;必须要在前面加上extern。

3）深入理解全局变量

extern的作用是通知编译器在本cpp中要用到某个符号，这个符号可能不在本cpp中定义，它表示在某个cpp文件中存在这么一个全局变量/函数，这个符号可以

再别的cpp中定义，亦可以在本cpp中定义

^多文件项目的生成

1）第一阶段：编译

编译，这一阶段是处理每个cpp文件，把cpp文件中的代码转换为中间文件(*.obj)，可以再debug文件夹中找到这个中间文件,A.cpp->A.object,C.cpp->B.obj。

在变异过程中各个cpp文件都不区分顺序，谁先谁后都一样，只要声明了一个函数为extern，编译器就不检测是否真的存在这个符号。

2）第二阶段：链接

如果迁移阶段编译成功，则进行连接过程。此过程作用是将各个obj文件综合在一起，生成可执行程序。A.obj,B.obj,..->test.exe。

在连接阶段编译器会检测所有extern的福海是否真的存在。

3）用伪代码表示整个过程

可以用一段伪代码来表示编译器和连接过程，并非真正的c++代码，仅用于解释说明。

4）全量编译与增量编译

全量编译是将所有的cpp文件重新编译一下，“重新生成解决方案”就是全量编译。

增量编译是指对有改动的文件进行执行，当执行生成解决方案时执行的是增量编译，这也是大多数编译器的默认动作。

^头文件#include指令

头文件的后缀名一般为.h,相应的把.cpp文件叫做头文件。

1）为什么需要头文件

同一结构的定义要在不同的cpp里重复好几遍。如果不写，就是语法错误。由于每个cpp时独立编译的，在other.cpp中定义的结构类型对main.cpp没有任何

影响

2）使用头文件

吓死项目中新增一个头文件Objeect.h,然后把Object的类型定义写在里面，然后在需要它的cpp里加上#include"Object.h",这样就解决了前面所说的问题，需

要扩展Object结构时，只需要修改Object.h即可。头文件写法：后缀一般为.h；内容一般为几种：类型定义，extern函数声明，extern变量声明。

3）#include指令的原理

#include"Object"

其中，#include称为一条“预处理指令”。"Object.h"表示要包含的头文件的路径，以双引号包围。预处理过程是：编译器过程的作用是，编译器在处理每个cpp

之前，首先将文件里的所有预处理指令进行处理，形成一个中间文件，然后对这个中间文件进行编译。

4）头文件的重复包含问题

5）头文件里的内容

头文件里，一般放以下内容：

公用类型定义：如果一个类型要在多个cpp中使用，可以放在头文件里。

extern函数声明：extern变量声明。

嵌入包含其他文件。

^宏定义#define指令

所有已#开头的行，称为预处理指令。#define指令通常称为宏定义。两个用法：

1）#define的一个数值

使用#define可以起到定义一个“常量”的效果。

2）#define的一个算式

使用#define可以定义一个类似“函数”的东西，它不是函数。学这些东西只是为了能够看懂一些老旧的代码。

3）几个常见宏定义

NULL空指针：#define NULL 0

RAND_MAX的宏定义:见16章。

^条件编译指令

1）#if...#endif

2）#ifdef...#endif

#ifdef表示如果对应的宏有定义，则相应的代码被编译。可以使用#undef指令去定义。

#ifndef表示的意思和#ifdef恰好相反：当相应的宏不存在时，才编译相应的代码。

3）结局头文件重复包含的问题

通常要对头文件用条件编译指令对其进行保护，之后便可以对其重复包含了。

^main函数的参数和返回值

1）main函数的参数

2）main函数的返回值

^static的用法

1）static修饰变量

2）static修饰函数

***面向对象编程

^面向对象设计的过程

^实例演示

^封装

***类

^类和成员变量

^类和成员函数

^变量名字和覆盖

^命名规范

^类的封装

^类的分离式写法

^const对象与const函数

***构造与析构

^构造函数

^析构函数

^自动生成构造/析构函数

^默认构造函数

^混合使用两种初始化方式

^构造与析构的顺序

^分离式写法

^无名对象

^构造函数与类型转换

***动态创建对象

^回顾malloc/free

^用new和delete创建/销毁对象

^new/delete与malloc/free的区别

^为new指定初始化对象

^默认构造函数的必要性

^注意事项

***继承

^继承的概念

^访问修饰符protected

^成员函数重写

^虚拟继承

^虚函数virtual

^继承关系下的构造与析构

^多重继承

^继承函数与纯虚类

^以protected/private方式继承

***拷贝构造函数

^定义

^拷贝构造函数的调用

^默认拷贝构造函数

^定义拷贝构造函数

^深度拷贝

***静态成员

^static定义全局变量

^static定义全局函数

^与普通成员函数的区别

^static语法的特点

^实例

***朋友成员

^类的朋友

^friend的语法

^实例

***重载操作符

^算术操作符

^赋值操作符=

^自增操作符++与自减操作符--

^关系操作符

^逻辑操作符

^类型转换操作符()

^元素操作符

^输入/输出操作符>>与<<

^操作符new与delete

***内部类和名字空间

^内部类

^名字空间

**模板

^函数模板

^类模板

^模板参数

^实例

***标准函数库

^一般使用方法

^向量vector

^list

^string

^map

^stack

^queue

***异常

^