目录
C++简介
C++ 环境设置
本地环境设置
文本编辑器
C++ 编译器
Windows 上的安装
C++ 基本语法
C++ 程序结构
C++ 数据类型
基本的内置类型
typedef 声明
枚举类型
C++ 中的变量定义
C++ 中的变量声明
C++ 变量作用域
局部变量
全局变量
初始化局部变量和全局变量
C++ 常量
定义常量
#define 预处理器
const 关键字
宏定义 #define 和常量 const 的区别
const 关键字应用
C++ 存储类
auto 存储类（略）
register 存储类（略）
static 存储类
extern 存储类
mutable 存储类（略）
thread_local 存储类（略）
C++ 运算符
算术运算符
关系运算符
逻辑运算符
位运算符
赋值运算符
杂项运算符
C++ 中的运算符优先级
关于逻辑运算符 && ，|| 的巧用方式
C++ 函数
函数声明
调用函数
函数参数
Lambda 函数与表达式
C++ 数字
C++ 数学运算
C++ 随机数
C++ 数组
声明数组
初始化数组
C++ 中数组详解
Vector(向量)
C++ 字符串
C 风格字符串
C++ 中的 String 类
字符串与vector
sizeof 和 strlen 的区别
C++ 中常见的几种输入字符串的方法
C++ 指针
什么是指针？
C++ 中使用指针
C++ 指针详解
C++ Null 指针
C++ 指针的算术运算
C++ 指针 vs 数组
C++ 指针数组
C++ 指向指针的指针
C++ 传递指针给函数
C++ 从函数返回指针
C++ 引用
C++ 引用 vs 指针
C++ 中创建引用
C++ 把引用作为参数
C++ 把引用作为返回值
C++ 是一种静态类型的、编译式的、通用的、大小写敏感的、不规则的编程语言，支持过程化编程、面向对象编程和泛型编程。
C++ 被认为是一种中级语言，它综合了高级语言和低级语言的特点。
C++ 是 C 的一个超集，事实上，任何合法的 C 程序都是合法的 C++ 程序。
注意：使用静态类型的编程语言是在编译时执行类型检查，而不是在运行时执行类型检查。
C++ 完全支持面向对象的程序设计，包括面向对象开发的四大特性：
封装抽象继承多态如果您想要设置 C++ 语言环境，您需要确保电脑上有以下两款可用的软件，文本编辑器和 C++ 编译器。
这将用于输入您的程序。文本编辑器包括 Windows Notepad、OS Edit command、Brief、Epsilon、EMACS 和 vim/vi。
通过编辑器创建的文件通常称为源文件，源文件包含程序源代码。C++ 程序的源文件通常使用扩展名 .cpp、.cp 或 .c。
写在源文件中的源代码是人类可读的源。它需要"编译"，转为机器语言，这样 CPU 可以按给定指令执行程序。
C++ 编译器用于把源代码编译成最终的可执行程序。
大多数的 C++ 编译器并不在乎源文件的扩展名，但是如果未指定扩展名，则默认使用 .cpp。
最常用的免费可用的编译器是 GNU 的 C/C++ 编译器，这里同时提到 C/C++，主要是因为 GNU 的 gcc 编译器适合于 C 和 C++ 编程语言。
为了在 Windows 上安装 GCC，需要安装 MinGW。为了安装 MinGW，请访问 MinGW 的主页 www.mingw.org，进入 MinGW 下载页面，下载最新版本的 MinGW 安装程序，命名格式为 MinGW-<version>.exe。
当安装 MinGW 时，您至少要安装 gcc-core、gcc-g++、binutils 和 MinGW runtime，但是一般情况下都会安装更多其他的项。
添加您安装的 MinGW 的 bin 子目录到您的 PATH 环境变量中，这样您就可以在命令行中通过简单的名称来指定这些工具。
当完成安装时，您可以从 Windows 命令行上运行 gcc、g++、ar、ranlib、dlltool 和其他一些 GNU 工具。
C++ 程序可以定义为对象的集合，这些对象通过调用彼此的方法进行交互。现在让我们简要地看一下什么是类、对象，方法、即时变量。
对象 - 对象具有状态和行为。例如：一只狗的状态 - 颜色、名称、品种，行为 - 摇动、叫唤、吃。对象是类的实例。类 - 类可以定义为描述对象行为/状态的模板/蓝图。方法 - 从基本上说，一个方法表示一种行为。一个类可以包含多个方法。可以在方法中写入逻辑、操作数据以及执行所有的动作。即时变量 - 每个对象都有其独特的即时变量。对象的状态是由这些即时变量的值创建的。C/C++可以使用带有 $ 的标识符：如_2$、$8
在 C++ 中 main 函数前面为什么要加上数据类型，比如： int void ?
main 函数的返回值是返回给主调进程，使主调进程得知被调用程序的运行结果。
标准规范中规定 main 函数的返回值为 int，一般约定返回 0 值时代表程序运行无错误，其它值均为错误号，但该约定并非强制。
如果程序的运行结果不需要返回给主调进程，或程序开发人员确认该状态并不重要，比如所有出错信息均在程序中有明确提示的情况下，可以不写 main 函数的返回值。在一些检查不是很严格的编译器中，比如 VC, VS 等，void 类型的 main 是允许的。不过在一些检查严格的编译器下，比如 g++, 则要求 main 函数的返回值必须为 int 型。
所以在编程时，区分程序运行结果并以 int 型返回，是一个良好的编程习惯。
C 语言 int main() 和 int main(void) 的区别？
int main(void) 指的是此函数的参数为空，不能传入参数，如果你传入参数，就会出错。
int main() 表示可以传入参数。
// 这样是正确的 int main() { if (0) main(42); } // 这样会出错 int main(void) { if (0) main(42); }在 C++ 中 int main() 和 int main(void) 是等效的，但在 C 中让括号空着代表编译器对是否接受参数保持沉默。在 C 语言中 main() 省略返回类型也就相当说明返回类型为 int 型，不过这种用法在 C++ 中逐渐被淘汰。虽然 void main（）在很多系统都适用，但他毕竟不是标准的，所以应该避免这种用法, 应该使用这种 int main(void) 的写法比较妥当。
为什么要使用 using namespace std; ?
有些名字容易冲突，所以会使用命名空间的方式进行区分，具体来说就是加个前缀。比如 C++ 标准库里面定义了 vector 容器，你自己也写了个 vector 类，这样名字就冲突了。于是标准库里的名字都加上 std:: 的前缀，你必须用 std::vector 来引用。同理，你自己的类也可以加个自定义的前缀。
但是经常写全名会很繁琐，所以在没有冲突的情况下你可以偷懒，写一句 using namespace std;，接下去的代码就可以不用写前缀直接写 vector 了。比如说，std::cout与cout等价。
long int 与 int 都是 4 个字节，因为早期的 C 编译器定义了 long int 占用 4 个字节，int 占用 2 个字节，新版的C/C++ 标准兼容了早期的这一设定。
char/unsigned char/signed char都是1个字节int/unsigned int/signed int 都是4个字节short int/unsigned shor int/signed short int都是2个字节long int/unsigned long int/signed long int都是8个字节float是4个字节double是8个字节long double是16个字节wchar_t是2或4个字节变量的大小会根据编译器和所使用的电脑而有所不同。
可以使用 sizeof() 函数来获取各种数据类型的大小。
用numeric_limits<type>::max获取type类型的最大值
用numeric_limits<type>::min获取type类型的最小值
变量的类型间是可以互相转换的，转换又分为自动转换和强制转换。
自动转换规则：
1、若参与运算量的类型不同，则先转换成同一类型，然后进行运算。2、转换按数据长度增加的方向进行，以保证精度不降低。如int型和long型运算时，先把int量转成long型后再进行运算。 a、若两种类型的字节数不同，转换成字节数高的类型 b、若两种类型的字节数相同，且一种有符号，一种无符号，则转换成无符号类型 3、所有的浮点运算都是以双精度进行的，即使仅含float单精度量运算的表达式，也要先转换成double型，再作运算。 4、char型和short型参与运算时，必须先转换成int型。 5、在赋值运算中，赋值号两边量的数据类型不同时，赋值号右边量的类型将转换为左边量的类型。如果右边量的数据类型长度比左边长时，将丢失一部分数据，这样会降低精度 int a=1; double b=2.5; a=b; cout << a; //输出为 2，丢失小数部分 int a = 1; double b = 2.1; cout << "a + b = " << a + b << endl; //输出为a + b = 3.1强制转换规则：
强制类型转换是通过类型转换运算来实现的。其一般形式为：（类型说明符）（表达式）其功能是把表达式的运算结果强制转换成类型说明符所表示的类型
int a = 1; double b = 2.1; cout << "a + b = " << a + (int)b << endl; //输出为a + b = 3可以使用 typedef 为一个已有的类型取一个新的名字。
typedef type newname; //例如： typedef int feet; //那么用feet定义一个变量distance就相当于定义一个整型变量distance feet distance;typedef 可以声明各种类型名，但不能用来定义变量。用 typedef 可以声明数组类型、字符串类型，使用比较方便。
用typedef只是对已经存在的类型增加一个类型名，而没有创造新的类型。
typedef 与 #define 的区别
1. 执行时间不同
关键字 typedef 在编译阶段有效，由于是在编译阶段，因此 typedef 有类型检查的功能。
#define 则是宏定义，发生在预处理阶段，也就是编译之前，它只进行简单而机械的字符串替换，而不进行任何检查。
2、功能有差异
typedef 用来定义类型的别名，定义与平台无关的数据类型，与 struct 的结合使用等。
#define 不只是可以为类型取别名，还可以定义常量、变量、编译开关等。
3、作用域不同
#define 没有作用域的限制，只要是之前预定义过的宏，在以后的程序中都可以使用。
而 typedef 有自己的作用域。
4、对指针的操作
二者修饰指针类型时，作用不同。
枚举类型(enumeration)是C++中的一种派生数据类型，它是由用户定义的若干枚举常量的集合。
如果一个变量只有几种可能的值，可以定义为枚举(enumeration)类型。所谓"枚举"是指将变量的值一一列举出来，变量的值只能在列举出来的值的范围内。
创建枚举，需要使用关键字 enum。枚举类型的一般形式为：
enum 枚举名{ 标识符[=整型常数], 标识符[=整型常数], ... 标识符[=整型常数] } 枚举变量;如果枚举没有初始化, 即省掉"=整型常数"时, 则从第一个标识符开始。
例如，下面的代码定义了一个颜色枚举，变量 c 的类型为 color。最后，c 被赋值为 "blue"。
enum color { red, green, blue } c; c = blue;意思就是变量c的取值范围是red、green、blue。
默认情况下，第一个名称的值为 0，第二个名称的值为 1，第三个名称的值为 2，以此类推。但是，您也可以给名称赋予一个特殊的值，只需要添加一个初始值即可。例如，在下面的枚举中，green 的值为 5。
enum color { red, green=5, blue };在这里，blue 的值为 6，因为默认情况下，每个名称都会比它前面一个名称大 1，但 red 的值依然为 0。
变量定义就是告诉编译器在何处创建变量的存储，以及如何创建变量的存储。变量定义指定一个数据类型，并包含了该类型的一个或多个变量的列表
变量声明向编译器保证变量以给定的类型和名称存在，这样编译器在不需要知道变量完整细节的情况下也能继续进一步的编译。
当使用多个文件且只在其中一个文件中定义变量时（定义变量的文件在程序连接时是可用的），变量声明就显得非常有用。可以使用 extern 关键字在任何地方声明一个变量。虽然可以在 C++ 程序中多次声明一个变量，但变量只能在某个文件、函数或代码块中被定义一次。
尝试下面的实例，其中，变量在头部就已经被声明，但它们是在主函数内被定义和初始化的：
#include <iostream> using namespace std; // 变量声明 extern int a, b; extern int c; extern float f; int main () { // 变量定义 int a, b; int c; float f; // 实际初始化 a = 10; b = 20; c = a + b; cout << c << endl ; f = 70.0/3.0; cout << f << endl ; return 0; }同样的，在函数声明时，提供一个函数名，而函数的实际定义则可以在任何地方进行。例如：
// 函数声明 int func(); int main() { // 函数调用 int i = func(); } // 函数定义 int func() { return 0; }
定义包含了声明，但是声明不包含定义。
如：
int a = 0; //定义并声明了变量 a extern int a; //只是声明了有一个变量 a 存在，具体 a 在哪定义的，需要编译器编译的时候去找。函数也是类似，定义的时候同时声明。但如果只是声明，编译器只知道有这么个函数，具体函数怎么定义的要编译器去找。
void fun1(); //函数声明 void fun1(){ //函数定义 cout<<"fun1"<<endl; }C/C++ 编译 cpp 文件是从上往下编译，所以 main 函数里面调用其他函数时，如果其他函数在 main 函数的下面，则要在 main 函数上面先声明这个函数。
或者把 main 函数放在最下面，这个不仅限于 main 函数，其他函数的调用都是如此。被调用的函数要在调用的函数之前声明。
用 extern 声明外部变量是不能进行初始化的。
#include "head.h" #include <iostream> int main() { extern int a=20; std::cout<<a; //错误，不允许对外部变量的局部声明使用初始值设定项。 } //将extern int a=20;写在main函数之前就不再报错了 //若写在main函数之后，报错提示变量a未声明因为externa int a;只是声明而不是定义，声明是不会为变量开辟内存空间的，自然无法对其进行初始化的操作。
只有当声明也是定义时，声明才可以有初始化式，因为只有定义才分配存储空间。初始化必须要有存储空间来进行初始化。如果声明有初始化式，那么它可被当做是定义，即使声明标记为extern：
extern double pi=3.1416; //definition虽然使用了extern，但是这条语句还是定义了pi，分配并初始化了存储空间。只有当extern声明位于函数外部时，才可以含有初始化式。
任何在多个文件中使用的变量都需要有与定义分离的声明。在这种情况下，一个文件含变量的定义，使用该变量的其他文件则包含该变量的声明（而不是定义）。
extern 关键字声明在变量和函数之前的说明。
1、作用在变量之前
变量只允许定义一次，但可以在多个文件中声明。
//Test.cpp 中： int s32Val = 0; // 定义一个变量 s32Val，并赋初值为 0 //Test1.cpp 中： extern int s32Val; // 声明变量 s32Val，它在 Test.cpp 中被定义，此处不可赋值 //Test2.cpp 中： extern int s32Val; // 声明变量 s32Val,它在 Test.cpp 中被定义，此处不可赋值2、作用在函数之前
//Test.h： extern void Fun(); // 函数声明，extern 用于标识此函数为外部可调用函数 //Test.cpp： void Fun(); // 函数定义作用域是程序的一个区域，一般来说有三个地方可以定义变量：
在函数或一个代码块内部声明的变量，称为局部变量。
在函数参数的定义中声明的变量，称为形式参数（形参）。
在所有函数外部声明的变量，称为全局变量。
在函数或一个代码块内部声明的变量，称为局部变量。它们只能被函数内部或者代码块内部的语句使用。
在所有函数外部定义的变量（通常是在程序的头部），称为全局变量。全局变量的值在程序的整个生命周期内都是有效的。
全局变量可以被任何函数访问。也就是说，全局变量一旦声明，在整个程序中都是可用的。
注意：在程序中，局部变量和全局变量的名称可以相同，但是在函数内，局部变量的值会覆盖全局变量的值。
当局部变量被定义时，系统不会对其初始化，您必须自行对其初始化。定义全局变量时，系统会自动初始化为下列值：
数据类型初始化默认值int0char'\0'float0double0pointer（指针）NULL字符 '0' 和 '\0' 及整数 0 的区别
字符型变量用于存储一个单一字符，在 C 语言中用 char 表示，其中每个字符变量都会占用 1 个字节（8 位二进制数）。
整型 int 在内存中占用空间为四个字节（32位二进制数）。
字符 '0'：char c = '0'; 它的 ASCII 码实际上是 48，内存中存放表示：00110000。
字符 '\0'： ASCII 码为 0，表示一个字符串结束的标志。这是转义字符（整体视为一个字符）。由于内存中存储字符，依然是存储的是对应字符集的字符编码，所以内存中的表现形式为 00000000。
整数 0 ： 内存中表示为 00000000 00000000 00000000 00000000，虽然都是 0，但是跟上面字符 '\0' 存储占用长度是不一样的。
在一个函数体内可以存在重名的变量，前提是它们的作用域不同。
#include <iostream> using namespace std; // 全局变量声明 int g = 99; // 函数声明 int func(); int main() { // 局部变量声明 int g = 10; cout << g; //输出10 int kk = func(); cout << kk; //输出99 return 0; } // 函数定义 int func() { return g; } #include <iostream> using namespace std; int main() { int b = 2; { int b = 1; cout << "b = " << b << endl; //输出1 } cout << "b = " << b << endl; //输出2 } //当变量间出现重名的情况下，作用域小的屏蔽作用域大的，所以上面第一个 cout 输出 b 的值为 1 //但由于在块里面申请的变量作用域只限于当前块，所以离开这个块后变量会自动释放，所以第二个 cout 输出 b 的值为 2。全局变量的值可以在局部函数内重新赋值。
#include <iostream> using namespace std; // 全局变量声明 int g = 20; int fun1(int a,int b){ g=a+b; cout<<"被改变的全局变量为："<<g<<endl; //输出30 return 0; } int fun2(){ cout<<"此时的全局变量为："<<g<<endl; //输出20 return 0; } int main(){ fun2(); fun1(10,20); fun2(); //输出30 return 0; }全局变量从定义处开始至程序结束起作用，即全局变量存在有效作用域。
#include<iostream> using namespace std; int main() { cout<<"a= "<<a<<endl; //编译不通过，a是未知字符 return 0; } int a=10; //全局变量从此处定义若要想让 main 函数也使用全局变量 a，可以用 extern 对全局变量进行声明，就可以合法使用了。
#include<iostream> using namespace std; int main() { extern int a; cout<<"a= "<<a<<endl; //合法，输出10 return 0; } int a=10; //全局变量从此处定义全局变量和和局部变量同名时，可通过域名在函数中引用到全局变量，不加域名解析则引用局部变量。
#include<iostream> using namespace std; int a = 10; int main() { int a = 20; cout << ::a << endl; // 10 cout << a << endl; // 20 return 0; }C++ 全局变量、局部变量、静态全局变量、静态局部变量的区别
C++ 变量根据定义的位置的不同的生命周期，具有不同的作用域，作用域可分为 6 种：全局作用域，局部作用域，语句作用域，类作用域，命名空间作用域和文件作用域。
从作用域看：
全局变量具有全局作用域。全局变量只需在一个源文件中定义，就可以作用于所有的源文件。当然，其他不包含全局变量定义的源文件需要用 extern 关键字再次声明这个全局变量。
静态局部变量具有局部作用域，它只被初始化一次，自从第一次被初始化直到程序运行结束都一直存在，它和全局变量的区别在于全局变量对所有的函数都是可见的，而静态局部变量只对定义自己的函数体始终可见。
局部变量也只有局部作用域，它是自动对象（auto），它在程序运行期间不是一直存在，而是只在函数执行期间存在，函数的一次调用执行结束后，变量被撤销，其所占用的内存也被收回。
静态全局变量也具有全局作用域，它与全局变量的区别在于如果程序包含多个文件的话，它作用于定义它的文件里，不能作用到其它文件里，即被static关键字修饰过的变量具有文件作用域。这样即使两个不同的源文件都定义了相同名字的静态全局变量，它们也是不同的变量。
从分配内存空间看：
全局变量，静态局部变量，静态全局变量都在静态存储区分配空间，而局部变量在栈里分配空间。
全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作用域， 即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。
1)、静态变量会被放在程序的静态数据存储区（数据段）（全局可见）中，这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它与堆栈变量和堆变量的区别。 2)、变量用static告知编译器，自己仅仅在变量的作用范围内可见。这一点是它与全局变量的区别。从以上分析可以看出， 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域，限制了它的使用范围。因此 static 这个说明符在不同的地方所起的作用是不同的。应予以注意。
Tips:
A、若全局变量仅在单个C文件中访问，则可以将这个变量修改为静态全局变量，以降低模块间的耦合度；B、若全局变量仅由单个函数访问，则可以将这个变量改为该函数的静态局部变量，以降低模块间的耦合度；C、设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑重入问题，因为他们都放在静态数据存储区，全局可见；D、如果我们需要一个可重入的函数，那么，我们一定要避免函数中使用static变量（这样的函数被称为：带“内部存储器”功能的的函数）E、函数中必须要使用 static 变量情况：比如当某函数的返回值为指针类型时，则必须是 static 的局部变量的地址作为返回值，若为auto类型，则返回为错指针。【？？？？？？？？？？？？？？？？？？？？？？？？】static 全局变量：改变作用范围，不改变存储位置
static 局部变量：改变存储位置，不改变作用范围
静态函数：在函数的返回类型前加上 static 关键字,函数即被定义为静态函数。静态函数与普通函数不同，它只能在声明它的文件当中可见，不能被其它文件使用。
如果在一个源文件中定义的函数，只能被本文件中的函数调用，而不能被同一程序其它文件中的函数调用，这种函数也称为内部函数。定义一个内部函数，只需在函数类型前再加一个“static”关键字即可。
在 C++ 中，有两种简单的定义常量的方式：
使用 #define 预处理器。使用 const 关键字。下面是使用 #define 预处理器定义常量的形式：
#define identifier value #define PI 3.141592657您可以使用 const 前缀声明指定类型的常量，如下所示：
const type variable = value;定义成 const 后的常量，程序对其中只能读不能修改。
以下程序是错误的，因为开头就已经固定了常量，便不能再对其进行赋值：
#include <iostream> using namespace std; int main() { const double pi; //圆周率的值用pi表示 pi=3.14159265; cout<<"圆周率的近似值是"<<pi<<endl; return 0; }下面给出正确的赋值方法:
#include <iostream> using namespace std; int main() { const double pi=3.141592; //圆周率的值用pi表示 cout<<"圆周率的近似值是"<<pi<<endl; return 0; }类型和安全检查不同
宏定义是字符替换，没有数据类型的区别，同时这种替换没有类型安全检查，可能产生边际效应等错误；
const常量是常量的声明，有类型区别，需要在编译阶段进行类型检查
编译器处理不同
宏定义是一个"编译时"概念，在预处理阶段展开，不能对宏定义进行调试，生命周期结束与编译时期；
const常量是一个"运行时"概念，在程序运行使用，类似于一个只读行数据
存储方式不同
宏定义是直接替换，不会分配内存，存储与程序的代码段中；
const常量需要进行内存分配，存储与程序的数据段中
定义域不同
void f1 () { #define N 12 const int n 12; } void f2 () { cout<<N <<endl; //正确，N已经定义过，不受定义域限制 cout<<n <<endl; //错误，n定义域只在f1函数中 }定义后能否取消
宏定义可以通过#undef来使之前的宏定义失效
const常量定义后将在定义域内永久有效
void f1() { #define N 12 const int n = 12; #undef N //取消宏定义后，即使在f1函数中，N也无效了 #define N 21//取消后可以重新定义 }是否可以做函数参数
宏定义不能作为参数传递给函数
const常量可以在函数的参数列表中出现
存储类定义 C++ 程序中变量/函数的范围（可见性）和生命周期。这些说明符放置在它们所修饰的类型之前。下面列出 C++ 程序中可用的存储类：
autoregisterstaticexternmutablethread_local (C++11)从 C++ 17 开始，auto 关键字不再是 C++ 存储类说明符，且 register 关键字被弃用。
static 存储类指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。
static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。
在 C++ 中，当 static 用在类数据成员上时，会导致仅有一个该成员的副本被类的所有对象共享。
#include <iostream> // 函数声明 void func(void); static int count = 10; /* 全局变量 */ int main() { while(count--) { func(); } return 0; } // 函数定义 void func( void ) { static int i = 5; // 局部静态变量 i++; std::cout << "变量 i 为 " << i ; std::cout << " , 变量 count 为 " << count << std::endl; }当上面的代码被编译和执行时，它会产生下列结果：
变量 i 为 6 , 变量 count 为 9 变量 i 为 7 , 变量 count 为 8 变量 i 为 8 , 变量 count 为 7 变量 i 为 9 , 变量 count 为 6 变量 i 为 10 , 变量 count 为 5 变量 i 为 11 , 变量 count 为 4 变量 i 为 12 , 变量 count 为 3 变量 i 为 13 , 变量 count 为 2 变量 i 为 14 , 变量 count 为 1 变量 i 为 15 , 变量 count 为 0通常，在函数体内定义了一个变量，每当程序运行到该语句时都会给该局部变量分配栈内存。但随着程序退出函数体，系统就会收回栈内存，局部变量也相应失效。但有时候我们需要在两次调用之间对变量的值进行保存。
通常的想法是定义一个全局变量来实现。但这样一来，变量已经不再属于函数本身了，不再仅受函数的控制，给程序的维护带来不便。
静态局部变量正好可以解决这个问题。静态局部变量保存在全局数据区，而不是保存在栈中，每次的值保持到下一次调用，直到下次赋新值。
静态局部变量有以下特点
该变量在全局数据区分配内存；静态局部变量在程序执行到该对象的声明处时被首次初始化，即以后的函数调用不再进行初始化；静态局部变量一般在声明处初始化，如果没有显式初始化，会被程序自动初始化为0；它始终驻留在全局数据区，直到程序运行结束。但其作用域为局部作用域，当定义它的函数或语句块结束时，其作用域随之结束（生命周期还未结束，作用域已经结束了）static 修饰类的成员变量
静态成员变量是先于类的对象而存在这个类的所有对象共用一个静态成员如果静态成员是公有的，那么可以直接通过类名调用静态成员数据在声明时候类外初始化 #include <iostream> using namespace std; class Data { public: Data(){} ~Data(){} void show() { cout<<this->data<<" "<<number<<endl; } static void showData()//先于类的对象而存在 { //这方法调用的时候不包含this指针 cout<<" "<<number<<endl; } private: int data; public: static int number; //静态数据在声明时候类外初始化 }; int Data::number=0;//静态成员初始化 int main() { Data::showData();//通过类名直接调用 Data::number = 100;//通过类名直接使用 Data d; d.show(); d.showData();//通过对象调用 cout << "Hello World!" << endl; return 0; }static 修饰类的成员方法
静态成员函数是先于类的对象而存在可用类名直接调用（公有）在静态成员函数中没有this指针，所以不能使用非静态成员extern 存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。当您使用 'extern' 时，对于无法初始化的变量，会把变量名指向一个之前定义过的存储位置。
当您有多个文件且定义了一个可以在其他文件中使用的全局变量或函数时，可以在其他文件中使用 extern 来得到已定义的变量或函数的引用。可以这么理解，extern 是用来在另一个文件中声明一个全局变量或函数。
extern 修饰符通常用于当有两个或多个文件共享相同的全局变量或函数的时候，如下所示：
第一个文件：main.cpp
#include <iostream> int count ; extern void write_extern(); int main() { count = 5; write_extern(); }第二个文件：support.cpp
#include <iostream> extern int count; void write_extern(void) { std::cout << "Count is " << count << std::endl; }在这里，第二个文件中的 extern 关键字用于声明已经在第一个文件 main.cpp 中定义的 count。
现在 ，编译这两个文件，如下所示：
$ g++ main.cpp support.cpp -o write这会产生 write 可执行程序，尝试执行 write，它会产生下列结果：
$ ./write Count is 5下表显示了 C++ 支持的算术运算符。
假设变量 A 的值为 10，变量 B 的值为 20，则：
运算符描述实例+把两个操作数相加A + B 将得到 30-从第一个操作数中减去第二个操作数A - B 将得到 -10*把两个操作数相乘A * B 将得到 200/分子除以分母B / A 将得到 2%取模运算符，整除后的余数B % A 将得到 0++自增运算符，整数值增加 1A++ 将得到 11--自减运算符，整数值减少 1A-- 将得到 9下表显示了 C++ 支持的关系运算符。
假设变量 A 的值为 10，变量 B 的值为 20，则：
运算符描述实例==检查两个操作数的值是否相等，如果相等则条件为真。(A == B) 不为真。!=检查两个操作数的值是否相等，如果不相等则条件为真。(A != B) 为真。>检查左操作数的值是否大于右操作数的值，如果是则条件为真。(A > B) 不为真。<检查左操作数的值是否小于右操作数的值，如果是则条件为真。(A < B) 为真。>=检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。(A >= B) 不为真。<=检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。(A <= B) 为真。下表显示了 C++ 支持的关系逻辑运算符。
假设变量 A 的值为 1，变量 B 的值为 0，则：
运算符描述实例&&称为逻辑与运算符。如果两个操作数都非零，则条件为真。(A && B) 为假。||称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。(A || B) 为真。!称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。!(A && B) 为真。位运算符作用于位，并逐位执行操作。
下表显示了 C++ 支持的位运算符。假设变量 A 的值为 60，变量 B 的值为 13，则：
运算符描述实例&如果同时存在于两个操作数中，二进制 AND 运算符复制一位到结果中。(A & B) 将得到 12，即为 0000 1100|如果存在于任一操作数中，二进制 OR 运算符复制一位到结果中。(A | B) 将得到 61，即为 0011 1101^如果存在于其中一个操作数中但不同时存在于两个操作数中，二进制异或运算符复制一位到结果中。(A ^ B) 将得到 49，即为 0011 0001~二进制补码运算符是一元运算符，具有"翻转"位效果，即0变成1，1变成0。(~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。<<二进制左移运算符。左操作数的值向左移动右操作数指定的位数。A << 2 将得到 240，即为 1111 0000>>二进制右移运算符。左操作数的值向右移动右操作数指定的位数。A >> 2 将得到 15，即为 0000 1111下表列出了 C++ 支持的赋值运算符：
运算符描述实例=简单的赋值运算符，把右边操作数的值赋给左边操作数C = A + B 将把 A + B 的值赋给 C+=加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数C += A 相当于 C = C + A-=减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数C -= A 相当于 C = C - A*=乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数C *= A 相当于 C = C * A/=除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数C /= A 相当于 C = C / A%=求模且赋值运算符，求两个操作数的模赋值给左边操作数C %= A 相当于 C = C % A<<=左移且赋值运算符C <<= 2 等同于 C = C << 2>>=右移且赋值运算符C >>= 2 等同于 C = C >> 2&=按位与且赋值运算符C &= 2 等同于 C = C & 2^=按位异或且赋值运算符C ^= 2 等同于 C = C ^ 2|=按位或且赋值运算符C |= 2 等同于 C = C | 2下表列出了 C++ 支持的其他一些重要的运算符。
运算符描述sizeofsizeof 运算符返回变量的大小。例如，sizeof(a) 将返回 4，其中 a 是整数。Condition ? X : Y条件运算符。如果 Condition 为真 ? 则值为 X : 否则值为 Y。,逗号运算符会顺序执行一系列运算。整个逗号表达式的值是以逗号分隔的列表中的最后一个表达式的值。.（点）和 ->（箭头）成员运算符用于引用类、结构和共用体的成员。Cast强制转换运算符把一种数据类型转换为另一种数据类型。例如，int(2.2000) 将返回 2。&指针运算符 & 返回变量的地址。例如 &a; 将给出变量的实际地址。*指针运算符 * 指向一个变量。例如，*var; 将指向变量 var。运算符的优先级确定表达式中项的组合。这会影响到一个表达式如何计算。某些运算符比其他运算符有更高的优先级，例如，乘除运算符具有比加减运算符更高的优先级。
下表将按运算符优先级从高到低列出各个运算符，具有较高优先级的运算符出现在表格的上面，具有较低优先级的运算符出现在表格的下面。在表达式中，较高优先级的运算符会优先被计算。
类别 运算符 结合性 后缀 () [] -> . ++ - - 从左到右 一元 + - ! ~ ++ - - (type)* & sizeof 从右到左 乘除 * / % 从左到右 加减 + - 从左到右 移位 << >> 从左到右 关系 < <= > >= 从左到右 相等 == != 从左到右 位与 AND & 从左到右 位异或 XOR ^ 从左到右 位或 OR | 从左到右 逻辑与 AND && 从左到右 逻辑或 OR || 从左到右 条件 ?: 从右到左 赋值 = += -= *= /= %=>>= <<= &= ^= |= 从右到左 逗号 , 从左到右逻辑与 &&
&& 会先判断左边的值是否为真。
如果为假，那么整个表达式毫无疑问也为假。
如果为真，那就还需要判断右值，才能知道整个式子的值，所以需要执行右边的表达式。
这个时候判断右值的过程就起了一个if的作用，可以利用这个过程判断右边表达式是否为真。
/*不用任何循环语句，不用if，来实现1+2+3+...+10的值*/ #include <iostream> using namespace std; int add(int c) { int a=0; c&&(a=add(c-1));//递归循环，直到传入c的值为0则结束循环 cout<<c+a<<endl; return c+a; } int main() { add(10); return 0; }逻辑或 ||
其实与上面的逻辑与 && 大同小异。
都是先判断左边是否为真，再来考虑右边。
因为逻辑与 || 只需要左边为真，那么整个表达式就有值，就不会再去算右边的值了，也就不会执行右边的表达式。
所以我们加个 ! 让 c 值为假时，!c 才为真，这样的话逻辑与 || 还需要判断右边的表达式才能计算出整个表达式的值。
(!c)||(a=add(c-1));这样就达到了和用逻辑与&&时一样的目的。
/*不用任何循环语句，不用if，来实现1+2+3+...+10的值*/ #include <iostream> using namespace std; int add(int c) { int a=0; (!c)||(a=add(c-1));//递归循环，直到传入c的值为0，(!c)就为真，结束循环 cout<<c+a<<endl; return c+a; } int main() { add(10); return 0; }函数是一组一起执行一个任务的语句。每个 C++ 程序都至少有一个函数，即主函数 main() ，所有简单的程序都可以定义其他额外的函数。
函数声明告诉编译器函数的名称、返回类型和参数。函数定义提供了函数的实际主体。
函数声明会告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。
函数声明包括以下几个部分：
return_type function_name( parameter list );针对上面定义的函数 max()，以下是函数声明：
int max(int num1, int num2);在函数声明中，参数的名称并不重要，只有参数的类型是必需的，因此下面也是有效的声明：
int max(int, int);注意：当您在一个源文件中定义函数且在另一个文件中调用函数时，函数声明是必需的。在这种情况下，您应该在调用函数的文件顶部声明函数。
创建 C++ 函数时，会定义函数做什么，然后通过调用函数来完成已定义的任务。
当程序调用函数时，程序控制权会转移给被调用的函数。被调用的函数执行已定义的任务，当函数的返回语句被执行时，或到达函数的结束括号时，会把程序控制权交还给主程序。
调用函数时，传递所需参数，如果函数返回一个值，则可以存储返回值。
如果函数要使用参数，则必须声明接受参数值的变量。这些变量称为函数的形式参数。
形式参数就像函数内的其他局部变量，在进入函数时被创建，退出函数时被销毁。
当调用函数时，有三种向函数传递参数的方式：
调用类型描述传值调用该方法把参数的实际值赋值给函数的形式参数。在这种情况下，修改函数内的形式参数对实际参数没有影响。
指针调用该方法把参数的地址赋值给形式参数。在函数内，该地址用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。引用调用该方法把参数的引用赋值给形式参数。在函数内，该引用用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。
默认情况下，C++ 使用传值调用来传递参数。一般来说，这意味着函数内的代码不能改变用于调用函数的参数。之前提到的实例，调用 max() 函数时，使用了相同的方法。
C++11 提供了对匿名函数的支持,称为 Lambda 函数(也叫 Lambda 表达式)。
Lambda 表达式把函数看作对象。Lambda 表达式可以像对象一样使用，比如可以将它们赋给变量和作为参数传递，还可以像函数一样对其求值。
Lambda 表达式本质上与函数声明非常类似。Lambda 表达式具体形式如下:
[capture](parameters)->return-type{body}例如：
[](int x, int y){ return x < y ; }如果没有返回值可以表示为：
[capture](parameters){body}例如：
[]{ ++global_x; }在一个更为复杂的例子中，返回类型可以被明确的指定如下：
[](int x, int y) -> int { int z = x + y; return z + x; }本例中，一个临时的参数 z 被创建用来存储中间结果。如同一般的函数，z 的值不会保留到下一次该不具名函数再次被调用时。
如果 lambda 函数没有传回值（例如 void），其返回类型可被完全忽略。
在Lambda表达式内可以访问当前作用域的变量，这是Lambda表达式的闭包（Closure）行为。 与JavaScript闭包不同，C++变量传递有传值和传引用的区别。可以通过前面的[]来指定：
[] // 沒有定义任何变量。使用未定义变量会引发错误。 [x, &y] // x以传值方式传入（默认），y以引用方式传入。 [&] // 任何被使用到的外部变量都隐式地以引用方式加以引用。 [=] // 任何被使用到的外部变量都隐式地以传值方式加以引用。 [&, x] // x显式地以传值方式加以引用。其余变量以引用方式加以引用。 [=, &z] // z显式地以引用方式加以引用。其余变量以传值方式加以引用。另外有一点需要注意。对于[=]或[&]的形式，lambda 表达式可以直接使用 this 指针。但是，对于[]的形式，如果要使用 this 指针，必须显式传入：
[this]() { this->someFunc(); }();了解更多：https://blog.csdn.net/a379039233/article/details/83714770
在 C++ 中，除了可以创建各种函数，还包含了各种有用的函数供您使用。这些函数写在标准 C 和 C++ 库中，叫做内置函数。您可以在程序中引用这些函数。
C++ 内置了丰富的数学函数，可对各种数字进行运算。下表列出了 C++ 中一些有用的内置的数学函数。
为了利用这些函数，您需要引用数学头文件 <cmath>。
序号函数 & 描述1double cos(double); 该函数返回弧度角（double 型）的余弦。2double sin(double); 该函数返回弧度角（double 型）的正弦。3double tan(double); 该函数返回弧度角（double 型）的正切。4double log(double); 该函数返回参数的自然对数。5double pow(double, double); 假设第一个参数为 x，第二个参数为 y，则该函数返回 x 的 y 次方。6double hypot(double, double); 该函数返回两个参数的平方总和的平方根，也就是说，参数为一个直角三角形的两个直角边，函数会返回斜边的长度。7double sqrt(double); 该函数返回参数的平方根。8int abs(int); 该函数返回整数的绝对值。9double fabs(double); 该函数返回任意一个浮点数的绝对值。10double floor(double); 该函数返回一个小于或等于传入参数的最大整数。 #include <iostream> #include <cmath> using namespace std; int main () { // 数字定义 short s = 10; int i = -1000; long l = 100000; float f = 230.47; double d = 200.374; // 数学运算 cout << "sin(d) :" << sin(d) << endl; //-0.634939 cout << "abs(i) :" << abs(i) << endl; //1000 cout << "floor(d) :" << floor(d) << endl; //200 cout << "sqrt(f) :" << sqrt(f) << endl; //15.1812 cout << "pow( d, 2) :" << pow(d, 2) << endl; //40149.7 return 0; }在许多情况下，需要生成随机数。关于随机数生成器，有两个相关的函数。一个是 rand()，该函数只返回一个伪随机数。生成随机数之前必须先调用 srand() 函数。
下面是一个关于生成随机数的简单实例。实例中使用了 time() 函数来获取系统时间的秒数，通过调用 rand() 函数来生成随机数：
#include <iostream> #include <ctime> #include <cstdlib> using namespace std; int main () { int i,j; // 设置种子 srand((unsigned)time( NULL )); /* 生成 10 个随机数 */ for( i = 0; i < 10; i++ ) { // 生成实际的随机数 j= rand(); cout <<"随机数： " << j << endl; } return 0; }srand函数是随机数发生器的初始化函数。
原型： void srand(unsigned seed);
用法：它需要提供一个种子，这个种子会对应一个随机数，如果使用相同的种子后面的rand()函数会出现一样的随机数。如： srand(1); 直接使用 1 来初始化种子。不过为了防止随机数每次重复，常常使用系统时间来初始化，即使用 time 函数来获得系统时间，它的返回值为从 00:00:00 GMT, January 1, 1970 到现在所持续的秒数，然后将 time_t 型数据转化为(unsigned)型再传给 srand 函数，即： srand((unsigned) time(&t)); 还有一个经常用法，不需要定义 time_t 型 t 变量，即： srand((unsigned) time(NULL)); 直接传入一个空指针，因为你的程序中往往并不需要经过参数获得的 t 数据。
如要产生 [0,m-1] 范围内的随机数 num，可用：int num = rand() % m;
如要产生 [m,n] 范围内的随机数 num，可用：int num = rand() % (n-m+1) + m;（即 rand()%[区间内数的个数]+[区间起点值]）
C++ 支持数组数据结构，它可以存储一个固定大小的相同类型元素的顺序集合。数组是用来存储一系列数据，但它往往被认为是一系列相同类型的变量。
数组的声明并不是声明一个个单独的变量，而是声明一个数组变量，比如 numbers，然后使用 numbers[0]、numbers[1]、...、numbers[99] 来代表一个个单独的变量。数组中的特定元素可以通过索引访问。
所有的数组都是由连续的内存位置组成。最低的地址对应第一个元素，最高的地址对应最后一个元素。
在 C++ 中要声明一个数组，需要指定元素的类型和元素的数量，如下所示：
type arrayName [ arraySize ];这叫做一维数组。arraySize 必须是一个大于零的整数常量，type 可以是任意有效的 C++ 数据类型。例如，要声明一个类型为 double 的包含 10 个元素的数组 balance，声明语句如下：
double balance[10];现在 balance 是一个可用的数组，可以容纳 10 个类型为 double 的数字。
在 C++ 中，您可以逐个初始化数组，也可以使用一个初始化语句，如下所示：
double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};大括号 { } 之间的值的数目不能大于我们在数组声明时在方括号 [ ] 中指定的元素数目。
如果您省略掉了数组的大小，数组的大小则为初始化时元素的个数。因此，如果：
double balance[] = {1000.0, 2.0, 3.4, 7.0, 50.0}; //自动生成一个长度为5的double型数组您将创建一个数组，它与前一个实例中所创建的数组是完全相同的。下面是一个为数组中某个元素赋值的实例：
balance[4] = 50.0;在 C++ 中，数组是非常重要的，我们需要了解更多有关数组的细节。下面列出了 C++ 程序员必须清楚的一些与数组相关的重要概念：
概念描述多维数组C++ 支持多维数组。多维数组最简单的形式是二维数组。指向数组的指针您可以通过指定不带索引的数组名称来生成一个指向数组中第一个元素的指针。传递数组给函数您可以通过指定不带索引的数组名称来给函数传递一个指向数组的指针。从函数返回数组C++ 允许从函数返回数组。Array 直接初始化 char 数组是特殊的，这种初始化要记得字符是以一个 null 结尾的。
char a1[] = {'C', '+', '+'}; // 初始化，没有 null char a2[] = {'C', '+', '+', '\0'}; // 初始化，明确有 null char a3[] = "C++"; // null 终止符自动添加 const char a4[6] = "runoob"; // 报错，没有 null 的位置a4 是错误的，虽然 a4 包括 6 个直接字符，但是 array 大小是 7：6个字符 + 一个null。正确的是：
const char a4[7] = "runoob"; //'\0'藏在b后面，占一个字节Array 是固定大小的，不能额外增加元素。当我们想定义不固定大小的字符时，可以使用 vector(向量) 标准库。
#include <iostream> #include <vector> using namespace std; int main() { // 创建向量用于存储整型数据 vector<int> vec; int i; // 显示 vec 初始大小 cout << "vector size = " << vec.size() << endl; // 向向量 vec 追加 5 个整数值 for(i = 0; i < 5; i++){ vec.push_back(i); } // 显示追加后 vec 的大小 cout << "extended vector size = " << vec.size() << endl; return 0; } vector size = 0 extended vector size = 5数组初始化时可以用聚合方法，但是赋值的时候不可以用聚合方法。
合法：
int array[] = {5,10,20,40};不合法：
int array[]； int main() { array[] = {5,10,20,40}; return 0; }数组在使用时可以是一个含有变量的表达式，但是，在数组声明时必须用常量表达式。
// 合法 const int a=19; //如果是 int a=19; 会报错 long b[a]; // 合法 const int a=19; long b[a+5]; // 不合法 int a=19; long b[a+5];如果想声明一个任意长度的数组，可以用显式的类型转换，例如：
int a=19; //在VS2015下使用本地Windows调试器调试 int b[(const int)a]; //还是会报错，提示计算结果不是常数也可以定义一个常量来声明，例如：
int a=19; const int a1=a; //在VS2015下使用本地Windows调试器调试 int arr[a1]; //还是会报错，提示表达式的计算结果不是常数字符数组除了可以用花括号在定义时初始化外，还可以用字符串字面值初始化，但谨记字符串字面值包含一个额外的空字符
char c1[] = {'h','e','l','l','o'}; char c2[] = "hello"; cout<<sizeof(c1)/sizeof(char)<<endl; //长度是5 cout<<sizeof(c2)/sizeof(char)<<endl; //长度是6一个数组不能用另一个数组初始化，也不能将一个数组赋值给另一个数组
int a[3] = {1,2,3}; int b[3][3] = {{1,2,3},{1,2,3},{1,2,3}}; //right int c[3][3] = {a,a,a}; //error若指针保存0值，表明它不指向任何对象。但是把int型变量赋值给指针是非法的，尽管此int型变量的值可能为0
int a = 0; int *p1 = 0; //right int *p2 = a; //error typedef string *pstring; const pstring cstr;C++ 中的一种数据结构，确切的说是一个类。它相当于一个动态的数组，当程序员无法知道自己需要的数组的规模多大时，用其来解决问题可以达到最大节约空间的目的。
用法：
1.文件包含：
首先在程序开头处加上 #include<vector> 以包含所需要的类文件 vector。
还有一定要加上 using namespace std;
2.变量声明：
2.1 例：声明一个 int 向量以替代一维的数组: vector <int> a; (等于声明了一个 int 数组 a[]，大小没有指定，可以动态的向里面添加删除)。
2.2 例：用 vector 代替二维数组.其实只要声明一个一维数组向量即可，而一个数组的名字其实代表的是它的首地址,所以只要声明一个地址的向量即可，即: vector <int *> a 。同理想用向量代替三维数组也是一样，vector <int**>a; 再往上面依此类推。
3.具体的用法以及函数调用：
3.1 得到向量中的元素和数组一样，例如：
vector <int *> a int b = 5; a.push_back(b);//该函数下面有详解 cout<<a[0]; //输出结果为5使用数组给向量赋值：
vector<int> v( a, a+sizeof(a)/sizeof(a[0]) );或者：
int a[]={1,2,3,4,5,6,7,8,9}; typedef vector<int> vec_int; vec_int vecArray(a,a+9);了解更多：https://www.runoob.com/w3cnote/cpp-vector-container-analysis.html —— C++ vector 容器浅析
获取数组长度的小技巧：sizeof(ArrName)/sizeof(ArrElemType或ArrElem);
例如：sizeof(a)/sizeof(int)或sizeof(a[0]);
C 风格的字符串起源于 C 语言，并在 C++ 中继续得到支持。字符串实际上是使用 null 字符 '\0' 终止的一维字符数组。因此，一个以 null 结尾的字符串，包含了组成字符串的字符。
下面的声明和初始化创建了一个 "Hello" 字符串。由于在数组的末尾存储了空字符，所以字符数组的大小比单词 "Hello" 的字符数多一个。
char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};依据数组初始化规则，您可以把上面的语句写成以下语句：
char greeting[] = "Hello";以下是 C/C++ 中定义的字符串的内存表示：
其实，您不需要把 null 字符放在字符串常量的末尾。C++ 编译器会在初始化数组时，自动把 '\0' 放在字符串的末尾。
#include <iostream> using namespace std; int main () { char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'}; cout << "Greeting message: "; cout << greeting << endl; return 0; } //输出Greeting message: HelloC++ 中有大量的函数用来操作以 null 结尾的字符串
序号函数 & 目的1strcpy(s1, s2); 复制字符串 s2 到字符串 s1。2strcat(s1, s2); 连接字符串 s2 到字符串 s1 的末尾。3strlen(s1); 返回字符串 s1 的长度。4strcmp(s1, s2); 如果 s1 和 s2 是相同的，则返回 0；如果 s1<s2 则返回值小于 0；如果 s1>s2 则返回值大于 0。5strchr(s1, ch); 返回一个指针，指向字符串 s1 中字符 ch 的第一次出现的位置。6strstr(s1, s2); 返回一个指针，指向字符串 s1 中字符串 s2 的第一次出现的位置。C++ 标准库提供了 string 类类型，支持上述所有的操作，另外还增加了其他更多的功能。比如：
append() —— 在字符串的末尾添加字符 —— 用法：str.append(appendStr)find() —— 在字符串中查找字符串 —— 用法：str.find(targetStr)insert() —— 插入字符 —— 用法：str.insert(pos,insertStr) 详见：http://www.cplusplus.com/reference/string/string/insert/length() —— 返回字符串的长度 —— 用法：str.length()replace() —— 替换字符串 —— 用法：str.replace(begin,end,replaceStr)，索引从0开始substr() —— 返回某个子字符串 —— 用法：str.substr(begin,end)，索引从0开始find_first_of —— 从头开始找某个字符第一次出现的位置，索引从0开始find_last_of —— 从尾开始找某个字符第一次出现的位置，索引从0开始字符串字面值与标准库string不是同一种类型
string s("hello"); cout<<s.size()<<endl; //OK cout<<"hello".size()<<endl; //ERROR cout<<s+"world"<<endl; //OK cout<<"hello"+"world"<<endl; //ERRORstrlen、sizeof与size()求字符串长度的区别
cout<<strlen("123")<<endl; //返回 3 cout<<sizeof("123")<<endl; //返回 4，算上了结尾的空字符 string s = "123"; cout<<s.size()<<endl; //返回 3标准string库中的getline函数返回时会丢弃换行符const iterator与const_iterator的区别【不太理解】
vector<int>::const_iterator //不能改变指向的值，自身的值可以改变 const vector<int>::iterator //可以改变指向的值，自身的值不能改变 const vector<int>::const_iterator //自身的值和指向的值都是只读的任何改变vector长度的操作都会使已存在的迭代器失效。如：在调用push_back之后，就不能再信赖指向vector的迭代器了
vector<int> ivec; ivec.push_back(10); vector<int>::iterator it = ivec.begin(); cout<<*it<<endl; ivec.push_back(9); cout<<*it<<endl; //迭代器已经失效1、sizeof 操作符的结果类型是 size_t，它在头文件中 typedef 为 unsigned int 类型。该类型保证能容纳实现所建立的最大对象的字节大小。
2、sizeof 是运算符，strlen 是函数。
3、sizeof 可以用类型做参数，strlen 只能用 char* 做参数，且必须是以 \0 结尾的。
sizeof 还可以用函数做参数，比如：
short f(); printf("%d\n", sizeof(f())); //输出的结果是 sizeof(short)，即 2。4、数组做 sizeof 的参数不退化，传递给 strlen 就退化为指针了。
5、大部分编译程序在编译的时候就把 sizeof 计算过了，是类型或是变量的长度，这就是 sizeof(x) 可以用来定义数组维数的原因。
char str[20]="0123456789"; int a=strlen(str); // a=10; int b=sizeof(str); // 而 b=20;6、strlen 的结果要在运行的时候才能计算出来，是用来计算字符串的长度，不是类型占内存的大小。
7、sizeof 后如果是类型必须加括弧，如果是变量名可以不加括弧。这是因为 sizeof 是个操作符不是个函数。
8、当适用一个结构类型或变量时， sizeof 返回实际的大小；当适用一静态地空间数组， sizeof 归还全部数组的尺寸；sizeof 操作符不能返回动态地被分派了的数组或外部的数组的尺寸。
数组作为参数传给函数时传的是指针而不是数组，传递的是数组的首地址， 如：
fun(char [8]) fun(char []) //都等价于 fun(char *)在 C++ 里参数传递数组永远都是传递指向数组首元素的指针，编译器不知道数组的大小。
如果想在函数内知道数组的大小， 需要这样做：
进入函数后用内存拷贝函数memcpy()拷贝出来，长度由另一个形参传进去
fun(unsiged char *p1, int len) { unsigned char* buf = new unsigned char[len+1] memcpy(buf, p1, len); }看了上面的详细解释，发现两者的使用还是有区别的，从这个例子可以看得很清楚：
char str[20]="0123456789"; int a=strlen(str); // a=10; >>>> strlen 计算字符串的长度，以结束符 0x00 为字符串结束。 int b=sizeof(str); // 而 b=20; >>>> sizeof 计算的则是分配的数组 str[20] 所占的内存空间的大小，不受里面存储的内容改变。上面是对静态数组处理的结果，如果是对指针，结果就不一样了。
char* ss = "0123456789"; sizeof(ss) //结果 4 ，ss 是指向字符串常量的字符指针，sizeof 获得的是一个指针的之所占的空间,应该是长整型的，所以是 4。 sizeof(*ss) //结果 1 ， *ss 是第一个字符 其实就是获得了字符串的第一位 '0' 所占的内存空间，是 char 类型的，占了 1 位 strlen(ss)= 10 //如果要获得这个字符串的长度，则一定要使用 strlen。strlen 用来求字符串的长度； //而 sizeof 是用来求指定变量或者变量类型等所占内存大小。
为什么可以以数组名来用cout输出数组内容，而普通数组不行。
先上范例：
int a[10] = {1,2,3,6,7}; char b[6] = {'h','a','p','p','y','\0'}; char c[] = "happy"; cout<<a<<endl; cout<<b<<endl; cout<<c<<endl; //输出结果为 0x22fe6c happy happy从以上范例可以看出，普通数组中以数组名用cout来输出，只会得到一串地址；用字符数组则会输出数组中的内容。这是c++的机制。只有数组是char类型时，cout数组名才会输出内容，其他类型的都会输出地址。
如果字符数组b末尾没有加上'\0'，则会出现乱码，比如happy烫烫烫
cin、cin.get()、cin.getline()、getline()、gets()、getchar()
1. cin>>
用法一：最常用、最基本的用法，输入一个数字：
#include <iostream> using namespace std; int main () { int a,b; cin>>a>>b; cout<<a+b<<endl; } //输入：2[回车]3[回车] //输出：5 用法二：接受一个字符串，遇“空格”、“Tab”、“回车”都结束 #include <iostream> using namespace std; int main () { char a[20]; cin>>a; cout<<a<<endl; } //输入：jkljkljkl //输出：jkljkljkl //输入：jkljkl jkljkl //遇空格结束，所以不能输入多个单词 //输出：jkljkl2. cin.get()
用法一：cin.get(字符变量名)可以用来接收字符
#include <iostream> using namespace std; int main () { char ch; ch=cin.get(); //或者cin.get(ch);只能获取一个字符 cout<<ch<<endl; } //输入：jljkljkl //输出：j用法二：cin.get(字符数组名，接收字符数)用来接收一行字符串，可以接收空格
#include <iostream> using namespace std; int main () { char a[20]; cin.get(a,20); //有些类似getline。可以输入多个单词，中间空格隔开。 cout<<a<<endl; } //输入：jkl jkl jkl //输出：jkl jkl jkl //输入：abcdeabcdeabcdeabcdeabcde （输入25个字符） //输出：abcdeabcdeabcdeabcd （接收19个字符+1个'\0'） 用法三：cin.get(无参数)没有参数主要是用于舍弃输入流中的不需要的字符, 或者舍弃回车, 弥补cin.get(字符数组名,接收字符数目)的不足. #include <iostream> using namespace std; int main(void) { char arr[10]; cin.get(arr,10); cin.get();//用于吃掉回车，相当于getchar(); cout<<arr<<endl; cin.get(arr,5); cout<<arr<<endl; system("pause"); return 0; } //输入abcdefghi //输出abcdefghi //输入abcde //输出abcd //请按任意键继续 #include <iostream> using namespace std; int main(void) { char arr[10]; cin.get(arr,10); //cin.get();//用于吃掉回车，相当于getchar(); 现在把这行注释掉试试看 cout<<arr<<endl; cin.get(arr,5); cout<<arr<<endl; system("pause"); return 0; } //输入abcdefghi //输出abcdefghi //请按任意键继续3.cin.getline()
cin.getline()：接受一个字符串，可以接收空格并输出
#include <iostream> using namespace std; int main () { char m[20]; cin.getline(m,5); //与上面基本相同。 cout<<m<<endl; } //输入：jkljkljkl //输出：jklj接受5个字符到m中，其中最后一个为'\0'，所以只看到4个字符输出；
如果把5改成20：
输入：jkljkljkl 输出：jkljkljkl 输入：jklf fjlsjf fjsdklf 输出：jklf fjlsjf fjsdklf延伸：
cin.getline()实际上有三个参数，cin.getline(接受字符串到m,接受个数5,结束字符)
当第三个参数省略时，系统默认为'\0' 是‘/n’吧。
如果将例子中cin.getline()改为cin.getline(m,5,'a');当输入jlkjkljkl时输出jklj，输入jkaljkljkl时，输出jk
当用在多维数组中的时候，也可以用cin.getline(m[i],20)之类的用法：
#include<iostream> #include<string> using namespace std; int main () { char m[3][20]; for(int i=0;i<3;i++) { cout<<"\n请输入第"<<i+1<<"个字符串："<<endl; cin.getline(m[i],20); } cout<<endl; for(int j=0;j<3;j++) cout<<"输出m["<<j<<"]的值:"<<m[j]<<endl; }测试：
请输入第1个字符串： kskr1 请输入第2个字符串： kskr2 请输入第3个字符串： kskr3 输出m[0]的值:kskr1 输出m[1]的值:kskr2 输出m[2]的值:kskr34. getline()
getline() ：接受一个字符串，可以接收空格并输出，需包含 #include<string>。
#include<iostream> #include<string> using namespace std; int main () { string str; getline(cin,str); cout<<str<<endl; } 测试： 输入：jkljkljkl //VC6中有个bug,需要输入两次回车。 输出：jkljkljkl 输入：jkl jfksldfj jklsjfl 输出：jkl jfksldfj jklsjfl和cin.getline()类似，但是cin.getline()属于istream流，而getline()属于string流，是不一样的两个函数
5. gets()
gets()：接受一个字符串，可以接收空格并输出，需包含 #include<string>。
#include<iostream> #include<string> using namespace std; int main () { char m[20]; gets(m); //不能写成m=gets(); cout<<m<<endl; }测试：
输入：jkljkljkl 输出：jkljkljkl 输入：jkl jkl jkl 输出：jkl jkl jkl类似cin.getline()里面的一个例子，gets()同样可以用在多维数组里面：
#include<iostream> #include<string> using namespace std; int main () { char m[3][20]; for(int i=0;i<3;i++) { cout<<"\n请输入第"<<i+1<<"个字符串："<<endl; gets(m[i]); } cout<<endl; for(int j=0;j<3;j++) cout<<"输出m["<<j<<"]的值:"<<m[j]<<endl; }测试：
请输入第1个字符串： kskr1 请输入第2个字符串： kskr2 请输入第3个字符串： kskr3 输出m[0]的值:kskr1 输出m[1]的值:kskr2 输出m[2]的值:kskr3自我感觉gets()和cin.getline()的用法很类似，只不过cin.getline()多一个参数罢了；
这里顺带说明一下，对于本文中的这个kskr1,kskr2,kskr3的例子，对于cin>>也可以适用，原因是这里输入的没有空格，如果输入了空格，比如“ks kr jkl[回车]”那么cin就会已经接收到3个字符串，“ks,kr,jkl”；再如“kskr 1[回车]kskr 2[回车]”，那么则接收“kskr,1,kskr”；这不是我们所要的结果！而cin.getline()和gets()因为可以接收空格，所以不会产生这个错误；
6.getchar()
getchar()：接受一个字符，需包含 #include<string>。
#include<iostream> using namespace std; int main () { char ch; ch=getchar(); //不能写成getchar(ch); cout<<ch<<endl; } 测试： 输入：jkljkljkl 输出：jgetchar()是C语言的函数，C++也可以兼容，但是尽量不用或少用；
正如您所知道的，每一个变量都有一个内存位置，每一个内存位置都定义了可使用连字号（&）运算符访问的地址，它表示了在内存中的一个地址。
指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。就像其他变量或常量一样，您必须在使用指针存储其他变量地址之前，对其进行声明。指针变量声明的一般形式为：
type *var-name;在这里，type 是指针的基类型，它必须是一个有效的 C++ 数据类型，var-name 是指针变量的名称。用来声明指针的星号 * 与乘法中使用的星号是相同的。但是，在这个语句中，星号是用来指定一个变量是指针。
所有指针的值的实际数据类型，不管是整型、浮点型、字符型，还是其他的数据类型，都是一样的，都是一个代表内存地址的长的十六进制数。不同数据类型的指针之间唯一的不同是，指针所指向的变量或常量的数据类型不同。
使用指针时会频繁进行以下几个操作：定义一个指针变量、把变量地址赋值给指针、访问指针变量中可用地址的值。这些是通过使用一元运算符 * 来返回位于操作数所指定地址的变量的值。
#include <iostream> using namespace std; int main () { int var = 20; // 实际变量的声明 int *ip; // 指针变量的声明 ip = &var; // 在指针变量中存储 var 的地址 cout << "Value of var variable: "; cout << var << endl; // 输出在指针变量中存储的地址 cout << "Address stored in ip variable: "; cout << ip << endl; // 访问指针中地址的值 cout << "Value of *ip variable: "; cout << *ip << endl; return 0; } //输出结果： //Value of var variable: 20 //Address stored in ip variable: 0xbfc601ac //Value of *ip variable: 20在 C++ 中，有很多指针相关的概念，这些概念都很简单，但是都很重要。下面列出了 C++ 程序员必须清楚的一些与指针相关的重要概念：
概念描述C++ Null 指针C++ 支持空指针。NULL 指针是一个定义在标准库中的值为零的常量。C++ 指针的算术运算可以对指针进行四种算术运算：++、--、+、-C++ 指针 vs 数组指针和数组之间有着密切的关系。C++ 指针数组可以定义用来存储指针的数组。C++ 指向指针的指针C++ 允许指向指针的指针。C++ 传递指针给函数通过引用或地址传递参数，使传递的参数在调用函数中被改变。C++ 从函数返回指针C++ 允许函数返回指针到局部变量、静态变量和动态内存分配。C++ 中指针分配与释放一个空间
分配：
type *p; // type 是一种数据类型 p=new type; // 没有初始化 p=new type(100); // 初始化 p 所指向的那个空间的值为 100释放：
delete p; // 必须是用 new 声明的，才可以用 freeC++ 中指针分配与释放多个空间：
分配：
type *p; p=new type[10]; //给指针 p 分配 10 个空间释放：
delete []p;在变量声明的时候，如果没有确切的地址可以赋值，为指针变量赋一个 NULL 值是一个良好的编程习惯。赋为 NULL 值的指针被称为空指针。
NULL 指针是一个定义在标准库中的值为零的常量。
在大多数的操作系统上，程序不允许访问地址为 0 的内存，因为该内存是操作系统保留的。然而，内存地址 0 有特别重要的意义，它表明该指针不指向一个可访问的内存位置。但按照惯例，如果指针包含空值（零值），则假定它不指向任何东西。
因此，如果所有未使用的指针都被赋予空值，同时避免使用空指针，就可以防止误用一个未初始化的指针。很多时候，未初始化的变量存有一些垃圾值，导致程序难以调试。
NULL的定义就是
define NULL 0指针是一个用数值表示的地址。因此，您可以对指针执行算术运算。可以对指针进行四种算术运算：++、--、+、-。
指针做++、--、+、-运算时，都是以它所指向的变量类型的大小为基准，比如指向char型变量的指针，自增1时地址值增加1，而指向int型变量的指针，自增1时地址值增加4。
指针指向数组时，不可以加 &指针指向数组中某一元素时，要用 && 直接修饰数组名，取的是整个数组的地址，比如 int arr[10]; 指向包含 10 个元素的 int 型数组，若起始地址为1000，则&arr的地址范围为 1000~1036，&arr+1就会从1036开始+4（int型变量的大小）。& 修饰数组名[0]，取的是数组第一个元素的地址。直接输出数组名，得到的是数组第一个元素的地址。 int main() { short int height[10]; //int型的数组（short int 每个数据2字节） cout << "height " << height << endl; cout << "&height " << &height << endl; cout << "height+1 " << height + 1 << endl; cout << "&height[0] " << &height[0] << endl; cout << "&height[9] " << &height[9] << endl; cout << "&height+1 " << &height + 1 << endl; cout << "height+9 " << height + 9 << endl; cout << "height+10 " << height + 10 << endl; getchar(); } 输出结果： height 005FFE0C &height 005FFE0C height+1 005FFE0E &height[0] 005FFE0C &height[9] 005FFE1E &height+1 005FFE20 height+9 005FFE1E height+10 005FFE20 height 与 &height[0] 值相等。height+1 = height + 2 字节 = height + 1 个 short int 也即 一个数组元素。height+9 为 height[] 中最后一个元素的地址，height+10 为该数组结束后的第一个地址。&height +1=height+10，即执行 &height+1 的结果是地址跳到整个数组之后第一个地址。指针和数组是密切相关的。事实上，指针和数组在很多情况下是可以互换的。例如，一个指向数组开头的指针，可以通过使用指针的算术运算或数组索引来访问数组。
然而，指针和数组并不是完全互换的。
#include <iostream> using namespace std; const int MAX = 3; int main () { int var[MAX] = {10, 100, 200}; for (int i = 0; i < MAX; i++) { *var = i; // 这是正确的语法，var是数组var的第一个元素的地址，*var取出第一个元素的值 var++; // 这是不正确的，var是数组var的第一个元素的地址，是一个常量 } return 0; }把指针运算符 * 应用到 var 上是完全可以的，但修改 var 的值是非法的。这是因为 var 是一个指向数组开头的常量，不能作为左值。
由于一个数组名对应一个指针常量，也就是数组首元素的地址，它不是一个变量，只要不改变这个指针常量的值，仍然可以用指针形式的表达式。
//下面是一个有效的语句，把 var[2] 赋值为 500： *(var + 2) = 500; //上面的语句是有效的，且能成功编译，因为 var 未改变。type *names[MAX] 是指针数组, 它的本质是存储指针的数组, 既存储 type 类型的指针的数组, 数组内的每个元素都是一个指针指向一个存储type 类型的地址。
数组指针是指向一个数组的指针，指针数组是每一个数组元素都是指针的一个数组。简单来记就是数组指针是指针，指针数组是数组。
在理解字符型指针数组的时候，可以将它理解为一个二维数组，如 const char *names[4] = {"Zara Ali","Hina Ali","Nuha Ali","Sara Ali",} 可以理解为一个 4 行 8 列的数组，可以用 cout << *(names[i] + j)<< endl 取出数组中的每个元素。
#include <iostream> using namespace std; const int MAX = 4; int main () { const char *names[MAX] = { "Zara Ali", "Hina Ali", "Nuha Ali", "Sara Ali", }; for (int i = 0; i < MAX; i++) for (int j = 0; j < 8; j++) { cout << "Value of names[" << i << "] = "; cout << *(names[i] + j)<< endl; } return 0; }P.S：names[i]的输出结果就是names中的第i个字符串。
指向指针的指针是一种多级间接寻址的形式，或者说是一个指针链。通常，一个指针包含一个变量的地址。当我们定义一个指向指针的指针时，第一个指针包含了第二个指针的地址，第二个指针指向包含实际值的位置。
一个指向指针的指针变量必须如下声明，即在变量名前放置两个星号。例如，下面声明了一个指向 int 类型指针的指针：
int **var;当一个目标值被一个指针间接指向到另一个指针时，访问这个值需要使用两个星号运算符，如下面实例所示：
#include <iostream> using namespace std; int main () { int var; int *ptr; int **pptr; var = 3000; // 获取 var 的地址 ptr = &var; // 使用运算符 & 获取 ptr 的地址 pptr = &ptr; // 使用 pptr 获取值 cout << "var 值为 :" << var << endl; cout << "*ptr 值为:" << *ptr << endl; cout << "**pptr 值为:" << **pptr << endl; return 0; } //当上面的代码被编译和执行时，它会产生下列结果： //var 值为 :3000 //*ptr 值为:3000 //**pptr 值为:3000C++ 允许您传递指针给函数，只需要简单地声明函数参数为指针类型即可。
#include <iostream> #include <ctime> using namespace std; void getSeconds(unsigned long *par); int main () { unsigned long sec; getSeconds( &sec ); // 输出实际值 cout << "Number of seconds :" << sec << endl; return 0; } void getSeconds(unsigned long *par) { // 获取当前的秒数 *par = time( NULL ); return; } //当上面的代码被编译和执行时，它会产生下列结果： //Number of seconds :1294450468能接受指针作为参数的函数，也能接受数组作为参数
#include <iostream> using namespace std; // 函数声明 double getAverage(int *arr, int size); int main () { // 带有 5 个元素的整型数组 int balance[5] = {1000, 2, 3, 17, 50}; double avg; // 传递一个指向数组的指针作为参数 avg = getAverage( balance, 5 ) ; // 输出返回值 cout << "Average value is: " << avg << endl; return 0; } double getAverage(int *arr, int size) { int i, sum = 0; double avg; for (i = 0; i < size; ++i) { sum += arr[i]; } avg = double(sum) / size; return avg; } //当上面的代码被编译和执行时，它会产生下列结果： //Average value is: 214.4我们已经了解了 C++ 中如何从函数返回数组，类似地，C++ 允许您从函数返回指针。为了做到这点，您必须声明一个返回指针的函数。要点就是返回值应该是一个指针。
int * myFunction() { int arr[10]; int *p=arr; . . . return p; }C++ 不支持在函数外返回局部变量的地址，除非定义局部变量为 static 变量。
引用变量是一个别名，也就是说，它是某个已存在变量的另一个名字。一旦把引用初始化为某个变量，就可以使用该引用名称或变量名称来指向变量。
引用很容易与指针混淆，它们之间有三个主要的不同：
不存在空引用。引用必须连接到一块合法的内存。一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。引用必须在创建时被初始化。指针可以在任何时间被初始化。试想变量名称是变量附属在内存位置中的标签，您可以把引用当成是变量附属在内存位置中的第二个标签。因此，您可以通过原始变量名称或引用来访问变量的内容。
int i = 17;我们可以为 i 声明引用变量
int& r = i; double& s = d;在这些声明中，& 读作引用。因此，第一个声明可以读作 "r 是一个初始化为 i 的整型引用"，第二个声明可以读作 "s 是一个初始化为 d 的 double 型引用"。
#include <iostream> using namespace std; int main () { // 声明简单的变量 int i; double d; // 声明引用变量 int& r = i; double& s = d; i = 5; cout << "Value of i : " << i << endl; cout << "Value of i reference : " << r << endl; d = 11.7; cout << "Value of d : " << d << endl; cout << "Value of d reference : " << s << endl; return 0; } //当上面的代码被编译和执行时，它会产生下列结果： //Value of i : 5 //Value of i reference : 5 //Value of d : 11.7 //Value of d reference : 11.7引用通常用于函数参数列表和函数返回值。下面列出了 C++ 程序员必须清楚的两个与 C++ 引用相关的重要概念
概念描述把引用作为参数C++ 支持把引用作为参数传给函数，这比传一般的参数更安全。把引用作为返回值可以从 C++ 函数中返回引用，就像返回其他数据类型一样。注意：以引用作为参数的函数，可以把变量传入，但不能传入常量。
C++之所以增加引用类型，主要是把它作为函数参数，以扩充函数传递数据的功能。
指针能够毫无约束地操作内存中的任何东西，尽管指针功能强大，但是非常危险。
如果的确只需要借用一下某个对象的"别名"，那么就用"引用"，而不要用"指针"，以免发生意外。
引用更效率的原因是指针还要生成一个局部变量，即给指针分配栈，而引用却不会生成。
#include <iostream> using namespace std; void test1(int *a) { cout << a << endl; int **p = &a; cout << p << endl; } void test2(int &a) { cout << a << endl; cout << &a << endl; } int main() { int num = 2; test1(&num); test2(num); getchar(); return 0; } //程序运行结果 //00AFFD9C ———— 指向num的指针的值，也就是num的地址 //00AFFCC8 ———— 指向num的指针的地址，和num的地址不同 //2 ———— num的引用的值 //00AFFD9C ———— num的引用的地址，和num的地址一样P.S：以引用作为参数的函数，可以把变量传入，但不能传入常量。
通过使用引用来替代指针，会使 C++ 程序更容易阅读和维护。C++ 函数可以返回一个引用，方式与返回一个指针类似。
当函数返回一个引用时，则返回一个指向返回值的隐式指针。这样，函数就可以放在赋值语句的左边。
以引用返回函数值，定义函数时需要在函数名前加 &
用引用返回一个函数值的最大好处是，在内存中不产生被返回值的副本。
引用更接近const指针，必须在创建时进行初始化，一旦引用和某个变量关联起来，该引用就会一直指向该变量。
当返回一个引用时，要注意被引用的对象不能超出作用域。所以返回一个对局部变量的引用是不合法的。但是，可以返回一个对静态变量的引用。这一点和函数返回指针的规则是一样的。
int& func() { int q; //! return q; // 在编译时发生错误，因为q的作用域只在本函数内 static int x; return x; // 安全，x 在函数作用域外依然是有效的，因为它的作用域是全局 }引用作为返回值，必须遵守以下规则
不能返回局部变量的引用。主要原因是局部变量会在函数返回后被销毁，因此被返回的引用就成为了"无所指"的引用，程序会进入未知状态。不能返回函数内部new分配的内存的引用。虽然不存在局部变量的被动销毁问题，可对于这种情况（返回函数内部new分配内存的引用），又面临其它尴尬局面。例如，被函数返回的引用只是作为一个临时变量出现，而没有被赋予一个实际的变量，那么这个引用所指向的空间（由new分配）就无法释放，造成memory leak。可以返回类成员的引用，但最好是const。主要原因是当对象的属性是与某种业务规则（business rule）相关联的时候，其赋值常常与某些其它属性或者对象的状态有关，因此有必要将赋值操作封装在一个业务规则当中。如果其它对象可以获得该属性的非常 量引用（或指针），那么对该属性的单纯赋值就会破坏业务规则的完整性。
