[C++知识库]C++学习笔记

C++简介

C++ 是一种静态类型的、编译式的、通用的、大小写敏感的、不规则的编程语言，支持过程化编程、面向对象编程和泛型编程。

C++是Bjarne Stroustrup于20世纪80年代在贝尔实验室开发出的。

C++是在C语言的基础上添加了对面向对象编程和泛型编程的支持的语言。

C语言编程原理

计算机语言的概念——数据和算法。数据是程序使用和处理的信息（好比做红烧肉的用料），算法是程序使用的方法（好比做做红烧肉的步骤）。C语言最初便是过程性（procedural）语言，即强调算法。自顶向下（top-down）的设计，将大型程序分解小型、便于管理的任务。（好比学习英语这件事分解为学音标、发音、背单词、学语法）

面向对象编程

OOP（Object Oriented Programming）强调数据。
在C++中，类是一种规范，即描述这种新型数据结构；对象是根据这种规范构造的特定数据结构。例如：类可以描述学生的基本特征（姓名、年龄、班级、外貌等），而对象则代表特定的学生。
OOP中从类到程序的处理过程叫做自下向上（bottom-up）的编程。OOP编程不仅是将数据和方法合并为类定义。还有创建可重用的代码、为运算符和函数创建多个定义的多态、使用旧类派生出新类的继承。
C++的优点之一：方便地重用和修改现有的、经过测试的代码。

泛型编程

泛型编程（generic programming）强调独立于特定数据类型，它使重用代码和抽象通用概念更加简单，提供了执行常见任务的工具。术语泛型（generic）是指创建独立于类型的代码。

C++基本语法

// #include编译指令，将iostream文件内容添加到程序中，这是一个预处理操作
#include <iostream> 
// using编译指令，名称空间编译指令
using namespace std;
int main()// 
{

	cout << "Hello World!"; // 使用cout输出Hello World！，<<在这里是插入运算符
	cout << endl; // 控制符（manipulator），重起一行
	cout << "I";
	return 0; // 返回语句（return statement）,结束函数
}

这是没有cout << endl;的显示效果

这是有cout << endl;的显示效果，也可使用换行符\n

C++ 标识符

C++ 标识符是用来标识变量、函数、类、模块，或任何其他用户自定义项目的名称。一个标识符以字母 A-Z 或 a-z 或下划线 _ 开始，后跟零个或多个字母、下划线和数字（0-9）。

C++ 标识符内不允许出现标点字符，比如 @、$ 和 %。C++ 是区分大小写的编程语言。因此，在 C++ 中，Manpower 和 manpower 是两个不同的标识符。

C++注释

• //一般用于单行注释。
• /* … */ 一般用于多行注释

C++ 修饰符类型

C++ 允许在 char、int 和 double 数据类型前放置修饰符。修饰符用于改变基本类型的含义，所以它更能满足各种情境的需求。

下面列出了数据类型修饰符：

• signed
• unsigned
• long
• short

修饰符 signed、unsigned、long 和 short 可应用于整型，signed 和 unsigned 可应用于字符型，long 可应用于双精度型。

修饰符 signed 和 unsigned 也可以作为 long 或 short 修饰符的前缀。例如：unsigned long int。

C++ 允许使用速记符号来声明无符号短整数或无符号长整数。您可以不写 int，只写单词 unsigned short 或 unsigned long，int 是隐含的。例如，下面的两个语句都声明了无符号整型变量。

unsigned x;
unsigned int y;

如：

#include <iostream>
using namespace std;
int main()
{
	short int a; // 有符号短整数
	short unsigned int b; // 无符号短整数
	a = 50000;
	b = a;
	cout << b << endl << a;
	return 0;
}

C++ 中的类型限定符

类型限定符提供了变量的额外信息。

C++ 运算符

• 算术运算符
• 关系运算符
• 逻辑运算符
• 位运算符
• 赋值运算符
• 杂项运算符

算术运算符

假设变量 A 的值为 10，变量 B 的值为 5，则：

关系运算符

假设变量 A 的值为 10，变量 B 的值为 20，则：

逻辑运算符

假设变量 A 的值为 1，变量 B 的值为 0，则：

位运算符

位运算符作用于位，并逐位执行操作。&、 | 和 ^ 的真值表如下所示：

赋值运算符

杂项运算符

C++ 数据类型

一些基本类型可以使用一个或多个类型修饰符进行修饰：

• signed
• unsigned
• short
• long

各种变量类型在内存中存储值时需要占用的内存，以及该类型的变量所能存储的最大值和最小值。
注意：不同系统会有所差异。

输出各种数据类型的大小

#include <iostream>
using namespace std;

int main()
{
	cout << "Size of char : " << sizeof(char) << endl;
	cout << "Size of int : " << sizeof(int) << endl;
	cout << "Size of short int : " << sizeof(short int) << endl;
	cout << "Size of long int : " << sizeof(long int) << endl;
	cout << "Size of float : " << sizeof(float) << endl;
	cout << "Size of double : " << sizeof(double) << endl;
	cout << "Size of wchar_t : " << sizeof(wchar_t) << endl;
	return 0;
}

typedef 声明

typedef 可以为一个已有的类型如int取一个新的名字

typedef type newname;

枚举类型

枚举类型声明一个可选的类型名称和一组标识符，用来作为该类型的值。其带有零个或多个标识符可以被用来作为该类型的值。每个枚举数是一个枚举类型的常数。

创建枚举，需要使用关键字 enum。枚举类型的一般形式为：

enum enum-name { list of names } var-list; 

enum-name 是枚举类型的名称，名称列表 { list of names } 中的内容用逗号分隔。

C++ 变量类型

C++变量

变量定义

变量定义就是告诉编译器在何处创建变量的存储，以及如何创建变量的存储。变量定义指定一个数据类型，并包含了该类型的一个或多个变量的列表，如下所示：

type variable_list;

#include <iostream>
using namespace std;

int main()
{
	int a = 1 , e = 2;
	char b = 'a', f = 'A';
	float c = 1.2 , g = 2.1;
	double d  = true, h = false;
	cout << a << endl << e << endl;
	cout << b << endl << f << endl;
	cout << c << endl << g << endl;
	cout << d << endl << h << endl;
	return 0;
}

C++连续赋值

	int a;
	int b;
	int c;
	a = b = c = 9;
	cout << a << b << c;

C++ 中的变量声明

变量声明向编译器保证变量以给定的类型和名称存在，这样编译器在不需要知道变量完整细节的情况下也能继续进一步的编译。变量声明只在编译时有它的意义，在程序连接时编译器需要实际的变量声明。

当您使用多个文件且只在其中一个文件中定义变量时（定义变量的文件在程序连接时是可用的），变量声明就显得非常有用。您可以使用 extern 关键字在任何地方声明一个变量。虽然您可以在 C++ 程序中多次声明一个变量，但变量只能在某个文件、函数或代码块中被定义一次。

#include <iostream>
using namespace std;
extern int a, b; // 变量声明
int main()
{
	int a, b; // 变量定义
	a = 10; // 初始化
	b = 20;
	cout << a << b;
	return 0;
}

C++ 中的左值（Lvalues）和右值（Rvalues）

左值（lvalue）：指向内存位置的表达式被称为左值（lvalue）表达式。左值可以出现在赋值号的左边或右边。
右值（rvalue）：术语右值（rvalue）指的是存储在内存中某些地址的数值。右值是不能对其进行赋值的表达式，也就是说，右值可以出现在赋值号的右边，但不能出现在赋值号的左边。
如：int a = 10；

C++ 变量作用域

• 局部变量，在函数或一个代码块内部声明的变量

#include <iostream>
	using namespace std;
	
	int main()
	{
		int a, b, c;
		a = 10;
		b = 20;
		c = a + b;
		cout << c;
		return 0;
	}

• 形式参数，在函数参数的定义中声明的变量
• 全局变量，在所有函数外部声明的变量

#include <iostream>
using namespace std;
int d;
int main()
{
	int a, b;
	a = 10;
	b = 20;
	d = a + b;
	cout << d;
	return 0;
}

以上局部变量和全局变量的运行结果都是30

初始化局部变量和全局变量

定义全局变量时，系统会自动初始化为下列值：

C++ 常量

常量是一个固定值，即在程执行期间不会改变，又叫做字面量。
常量可以是任何的基本数据类型，可分为整型数字、浮点数字、字符、字符串和布尔值。
常量的值在定义后不能进行修改。

整数常量

整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，不带前缀则默认表示十进制。

整数常量也可以带一个后缀，后缀是 U 和 L 的组合，U 表示无符号整数（unsigned），L 表示长整数（long）。后缀可以是大写，也可以是小写，U 和 L 的顺序任意。
如：

58         // 十进制
0245       // 八进制 
0x2b       // 十六进制 
20         // 整数 
20u        // 无符号整数 
45l        // 长整数 
60ul       // 无符号长整数

浮点常量

浮点常量由整数部分、小数点、小数部分和指数部分组成。您可以使用小数形式或者指数形式来表示浮点常量。

当使用小数形式表示时，必须包含小数点、指数，或同时包含两者。当使用指数形式表示时，必须包含整数部分、小数部分，或同时包含两者。带符号的指数是用 e 或 E 引入的。

3.14159       // 合法的 
314159E-5L    // 合法的 
520E          // 非法的：不完整的指数
1314f          // 非法的：没有小数或指数
.e55          // 非法的：缺少整数或分数

布尔常量

• true 值代表真。
• false 值代表假。

字符常量
字符常量是括在单引号中。如果常量以 L（仅当大写时）开头，则表示它是一个宽字符常量（例如 L’x’），此时它必须存储在 wchar_t 类型的变量中。否则，它就是一个窄字符常量（例如 ‘x’），此时它可以存储在 char 类型的简单变量中。

字符常量可以是一个普通的字符（例如 ‘x’）、一个转义序列（例如 ‘\t’），或一个通用的字符（例如 ‘\u02C0’）。

在 C++ 中，有一些特定的字符，当它们前面有反斜杠时，它们就具有特殊的含义，被用来表示如换行符（\n）或制表符（\t）等。下表列出了一些这样的转义序列码：

字符串常量

字符串字面值或常量是括在双引号 “” 中的。一个字符串包含类似于字符常量的字符：普通的字符、转义序列和通用的字符。

定义常量

• 使用 #define 预处理器。
• 使用 const 关键字。

#define 预处理器

使用 #define 预处理器定义常量的形式：

#define identifier value

如：

#include <iostream>
using namespace std;
#define PI 3.14
int main()
{
	int r = 5;
	float area;
	area = r * r * PI;
	cout << area;
	return 0;
}

const 关键字

使用 const 前缀声明指定类型的常量，如下所示：

const type variable = value;

如：

#include <iostream>
using namespace std;
int main()
{
	const float PI = 3.14;
	int r = 5;
	float area;
	area = r * r * PI;
	cout << area;
	return 0;
}

C++ 循环

循环语句允许我们多次执行一个语句或语句组

C++ while 循环

C++ 中 while 循环的语法：

while(condition)
{
   statement(s);
}

statement(s) 可以是一个单独的语句，也可以是几个语句组成的代码块。condition 可以是任意的表达式，当为任意非零值时都为真。当条件为真时执行循环。
如：

#include <iostream>
using namespace std;
int main()
{
	int a = 1;
	while (a < 10)
	{
		cout << a << endl;
		a++;
	}
	return 0;
}

C++ for 循环

for 循环允许编写一个执行特定次数的循环的重复控制结构
C++ 中 for 循环的语法：

for ( init; condition; increment )
{
   statement(s);
}

如：

#include <iostream>
using namespace std;
int main()
{
	for (int a = 1; a < 10; a = a + 1)
	{
		cout << a << endl;
	}
	return 0;
}

C++ do…while 循环

do…while 循环是在循环的尾部检查它的条件,即会确保至少执行一次循环。

C++ 中 do…while 循环的语法：

do
{
   statement(s);

}while( condition );

如：

#include <iostream>
using namespace std;
int main()
{
	int a = 1;
	do
	{
		cout << a << endl;
		a = a + 1;
	} while (a < 10);
	return 0;
}

C++ 嵌套循环

一个循环内可以嵌套另一个循环

C++ 中 嵌套 for 循环 语句的语法：

for ( init; condition; increment )
{
   for ( init; condition; increment )
   {
      statement(s);
   }
   statement(s); 
}

C++ 中 嵌套 while 循环 语句的语法：

while(condition)
{
   while(condition)
   {
      statement(s);
   }
   statement(s); /
}

C++ 中 嵌套 do…while 循环 语句的语法：

do
{
   statement(s); 
   do
   {
      statement(s);
   }while( condition );

}while( condition );

C++ break 语句

当 break 语句出现在一个循环内时，循环会立即终止，且程序流将继续执行紧接着循环的下一条语句。

break 语句可用于终止 switch 语句中的一个 case。

C++ 中 break 语句的语法：

break;

如：

#include <iostream>
using namespace std;
int main()
{
	int a = 1;
	do
	{
		cout << a << endl;
		a = a + 1;
		if (a == 5)
		{
			break;
		}
	} while (a < 10);
	return 0;
}

C++ continue 语句

continue 会跳过当前循环中的代码，强迫开始下一次循环。

C++ 中 continue 语句的语法：

continue;

#include <iostream>
using namespace std;
int main()
{
	int a = 1;
	do
	{
		cout << a << endl;
		a = a + 1;
		if (a == 5)
		{
			a = a + 1;
			continue;
		}
	} while (a < 10);
	return 0;
}

C++ goto 语句

goto 语句允许把控制无条件转移到同一函数内的被标记的语句。

C++ 中 goto 语句的语法：

goto label;
..
.
label: statement;

C++ 判断

判断结构要求指定一个或多条件为真时要执行的语句和条件为假时要执行的语句。

C++ if 语句

C++ 中 if 语句的语法：

if(boolean_expression)
{
   // 如果布尔表达式为真将执行的语句
}

C++ if…else 语句

一个 if 语句 后可跟一个可选的 else 语句，else 语句在布尔表达式为假时执行。

C++ 中 if…else 语句的语法：

if(boolean_expression)
{
   // 如果布尔表达式为真将执行的语句
}
else
{
   // 如果布尔表达式为假将执行的语句
}

if…else if…else 语句

一个 if 语句后可跟一个可选的 else if…else 语句，这可用于测试多种条件。

当使用 if…else if…else 语句时，以下几点需要注意：

• 一个 if 后可跟零个或一个 else，else 必须在所有 else if 之后。
• 一个 if 后可跟零个或多个 else if，else if 必须在 else 之前。
• 一旦某个 else if 匹配成功，其他的 else if 或 else 将不会被测试。

C++ 中的 if…else if…else 语句的语法：

if(boolean_expression 1)
{
   // 当布尔表达式 1 为真时执行
}
else if( boolean_expression 2)
{
   // 当布尔表达式 2 为真时执行
}
else if( boolean_expression 3)
{
   // 当布尔表达式 3 为真时执行
}
else 
{
   // 当上面条件都不为真时执行
}

C++ 嵌套 if 语句

C++ 中 嵌套 if 语句的语法：

if( boolean_expression 1)
{
   // 当布尔表达式 1 为真时执行
   if(boolean_expression 2)
   {
      // 当布尔表达式 2 为真时执行
   }
}

C++ switch 语句

一个 switch 语句允许测试一个变量等于多个值时的情况。每个值称为一个 case，且被测试的变量会对每个 switch case 进行检查。

C++ 中 switch 语句的语法：

switch(expression){
    case constant-expression  :
       statement(s);
       break; // 可选的
    case constant-expression  :
       statement(s);
       break; // 可选的
  
    // 您可以有任意数量的 case 语句
    default : // 可选的
       statement(s);
}

switch 语句必须遵循下面的规则：

• switch 语句中的 expression 必须是一个整型或枚举类型，或者是一个 class 类型，其中 class
  有一个单一的转换函数将其转换为整型或枚举类型。
• 在一个 switch 中可以有任意数量的 case 语句。每个 case 后跟一个要比较的值和一个冒号。
• case 的 constant-expression 必须与 switch 中的变量具有相同的数据类型，且必须是一个常量或字面量。
• 当被测试的变量等于 case 中的常量时，case 后跟的语句将被执行，直到遇到 break 语句为止。
• 当遇到 break 语句时，switch 终止，控制流将跳转到 switch 语句后的下一行。
• 不是每一个 case 都需要包含 break。如果 case 语句不包含 break，控制流将会 继续 后续的 case，直到遇到
  break 为止。
• 一个 switch 语句可以有一个可选的 default case，出现在 switch 的结尾。default case可用于在上面所有 case 都不为真时执行一个任务。default case 中的 break 语句不是必需的。

C++ 条件运算符 ? :

Exp1 ? Exp2 : Exp3;

如下所示的 if-else 语句：

if(condition){
   var = X;
}else{
   var = Y;
}

C++ 函数

函数是一组一起执行一个任务的语句。每个 C++ 程序都至少有一个函数，即主函数 main()。
函数声明告诉编译器函数的名称、返回类型和参数。函数定义提供了函数的实际主体。

定义函数

C++ 中的函数定义的一般形式如下：

return_type function_name( parameter list )
{
   body of the function
}

在 C++ 中，函数由一个函数头和一个函数主体组成。下面是一个函数的所有组成部分：

• 返回类型：一个函数可以返回一个值。return_type
  是函数返回的值的数据类型。有些函数执行所需的操作而不返回值，在这种情况下，return_type 是关键字 void。
• 函数名称：这是函数的实际名称。函数名和参数列表一起构成了函数签名。
• 参数：参数就像是占位符。当函数被调用时，您向参数传递一个值，这个值被称为实际参数。参数列表包括函数参数的类型、顺序、数量。参数是可选的，也就是说，函数可能不包含参数。
• 函数主体：函数主体包含一组定义函数执行任务的语句。

如：

int sum(int num1, int num2)
{
	int result;
	if (num1 > 0 || num2 > 0)
	{
		result = num1 + num2;
	}
	return result;
}

函数声明

函数声明会告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。

函数声明包括以下几个部分：

return_type function_name( parameter list );

如：

int sum(int num1, int num2);

调用函数

创建 C++ 函数时，会定义函数做什么，然后通过调用函数来完成已定义的任务。

当程序调用函数时，程序控制权会转移给被调用的函数。被调用的函数执行已定义的任务，当函数的返回语句被执行时，或到达函数的结束括号时，会把程序控制权交还给主程序。

调用函数时，传递所需参数，如果函数返回一个值，则可以存储返回值。例如：

#include <iostream>
using namespace std;
int sum(int num1, int num2);
int main()
{
	int a = 1;
	int b = 2;
	int c;
	c = sum(a, b);
	cout << c;
	return 0;
}
int sum(int num1, int num2)
{
	int result;
	if (num1 > 0 || num2 > 0)
	{
		result = num1 + num2;
	}
	return result;
}

函数参数

如果函数要使用参数，则必须声明接受参数值的变量。这些变量称为函数的形式参数。

形式参数就像函数内的其他局部变量，在进入函数时被创建，退出函数时被销毁。

当调用函数时，有两种向函数传递参数的方式：

C++ 传值调用
向函数传递参数的传值调用方法，把参数的实际值复制给函数的形式参数。在这种情况下，修改函数内的形式参数不会影响实际参数。
如：

#include <iostream>
using namespace std;
void swap(int x, int y)
{
	int temp;

	temp = x; // 保存 x 的值
	x = y;    // 把 y 赋值给 x 
	y = temp; // 把 x 赋值给 y 

	return;
}
void swap(int x, int y);
int main()
{
	int a = 100;
	int b = 200;

	cout << "交换前a 的值：" << a << endl;
	cout << "交换前b 的值：" << b << endl;

	// 调用函数来交换值
	swap(a, b);

	cout << "交换后a 的值：" << a << endl;
	cout << "交换后b 的值：" << b << endl;

	return 0;
}

C++ 指针调用

向函数传递参数的指针调用方法，把参数的地址复制给形式参数。在函数内，该地址用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。

按指针传递值，参数指针被传递给函数，就像传递其他值给函数一样。因此相应地，在下面的函数 swap() 中，您需要声明函数参数为指针类型，该函数用于交换参数所指向的两个整数变量的值。
如：

#include <iostream>
using namespace std;
void swap(int *x, int *y)
{
	int temp;

	temp = *x; // 保存 x 的值
	*x = *y;    // 把 y 赋值给 x 
	*y = temp; // 把 x 赋值给 y 

	return;
}
void swap(int *x, int *y);
int main()
{
	int a = 100;
	int b = 200;

	cout << "交换前a 的值：" << a << endl;
	cout << "交换前b 的值：" << b << endl;

	// &a 表示指向 a 的指针，即变量 a 的地址
	swap(&a, &b);

	cout << "交换后a 的值：" << a << endl;
	cout << "交换后b 的值：" << b << endl;

	return 0;
}

C++ 引用调用

向函数传递参数的引用调用方法，把参数的地址复制给形式参数。在函数内，该引用用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。

按引用传递值，参数引用被传递给函数，就像传递其他值给函数一样。因此相应地，在下面的函数 swap() 中，您需要声明函数参数为引用类型，该函数用于交换参数所指向的两个整数变量的值。

如：

#include <iostream>
using namespace std;
void swap(int &x, int &y)
{
	int temp;
	temp = x; // 保存 x 的值
	x = y;    // 把 y 赋值给 x 
	y = temp; // 把 x 赋值给 y 
	return;
}
void swap(int &x, int &y);
int main()
{
	int a = 100;
	int b = 200;

	cout << "交换前a 的值：" << a << endl;
	cout << "交换前b 的值：" << b << endl;


	swap(a, b);

	cout << "交换后a 的值：" << a << endl;
	cout << "交换后b 的值：" << b << endl;

	return 0;
}

C++ 数字

在 C++ 中，除了可以创建各种函数，还包含了各种有用的函数供您使用。这些函数写在标准 C 和 C++ 库中，叫做内置函数。

如：

#include <iostream>
#include <cmath> // 引用数学头文件<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;
	cout << "abs(i)  :" << abs(i) << endl;
	cout << "floor(d) :" << floor(d) << endl;
	cout << "sqrt(f) :" << sqrt(f) << endl;
	cout << "pow( d, 2) :" << pow(d, 2) << endl;
	return 0;
}

C++ 随机数

rand()，该函数只返回一个伪随机数。生成随机数之前必须先调用 srand() 函数。

#include <iostream>
using namespace std;
int main()
{
    int i,j;
    for (i = 0; i < 10; i++)
    {
        // 生成实际的随机数
        j = rand();
        cout << "随机数： " << j << endl;
    }

	return 0;
}

C++ 数组

数组是用来存储一系列数据，但它往往被认为是一系列相同类型的变量。
所有的数组都是由连续的内存位置组成。最低的地址对应第一个元素，最高的地址对应最后一个元素。

声明数组

在 C++ 中要声明一个数组，需要指定元素的类型和元素的数量，如下所示：

type arrayName [ arraySize ];

初始化数组

在 C++ 中，您可以逐个初始化数组，也可以使用一个初始化语句，如下所示：

int a[5] = { 1, 2, 3, 4, 5};

访问数组元素

#include <iostream>
using namespace std;
int main()
{
	int a[5] = { 1, 2, 3, 4, 5};
	cout << a[0];

	return 0;
}

C++ 多维数组

多维数组声明的一般形式如下：

type name[size1][size2]...[sizeN];

二维数组

多维数组最简单的形式是二维数组。一个二维数组，在本质上，是一个一维数组的列表。声明一个 x 行 y 列的二维整型数组，形式如下：

type arrayName [ x ][ y ];

初始化二维数组

多维数组可以通过在括号内为每行指定值来进行初始化。

int a[3][3] = {
	{1, 2, 3},
	{4, 5, 6},
	{7, 8, 9}
};

访问二维数组元素

二维数组中的元素是通过使用下标（即数组的行索引和列索引）来访问的。例如：

#include <iostream>
using namespace std;
int main()
{
	int a[3][3] = {
		{1, 2, 3},
		{4, 5, 6},
		{7, 8, 9}
	};
	cout << a[1][2];

	return 0;
}

C++ 指针

每一个变量都有一个内存位置，每一个内存位置都定义了可使用连字号（&）运算符访问的地址，它表示了在内存中的一个地址。请看下面的实例，它将输出定义的变量地址：

#include <iostream>
using namespace std;
int main()
{
	int  var1;
	char var2[10];

	cout << "var1 变量的地址： ";
	cout << &var1 << endl;

	cout << "var2 变量的地址： ";
	cout << &var2 << endl;

	return 0;
}

什么是指针？

指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。就像其他变量或常量一样，您必须在使用指针存储其他变量地址之前，对其进行声明。指针变量声明的一般形式为：

type *var-name;

type 是指针的基类型，它必须是一个有效的 C++ 数据类型，var-name 是指针变量的名称。用来声明指针的星号 * 与乘法中使用的星号是相同的。但是，在这个语句中，星号是用来指定一个变量是指针。以下是有效的指针声明：

int    *ip;    /* 一个整型的指针 */
double *dp;    /* 一个 double 型的指针 */
float  *fp;    /* 一个浮点型的指针 */
char   *ch     /* 一个字符型的指针 */

所有指针的值的实际数据类型，不管是整型、浮点型、字符型，还是其他的数据类型，都是一样的，都是一个代表内存地址的长的十六进制数。不同数据类型的指针之间唯一的不同是，指针所指向的变量或常量的数据类型不同。

C++ 中使用指针

#include <iostream>
using namespace std;
int main()
{
	int var = 20;
	int *ip; // 声明指针变量
	ip = &var; // 将var的地址赋值给指针变量
	cout << "var的地址中的值为：" << var << endl;
	cout << "存储在指针变量中的地址为：" << ip << endl;
	cout << "指针中地址的值为：" << *ip << endl;
	return 0;
}

指针相关的重要概念：

C++ Null 指针

赋为 NULL 值的指针被称为空指针。

NULL 指针是一个定义在标准库中的值为零的常量。
如：

#include <iostream>
using namespace std;
int main()
{
	int *ptr = NULL;
	cout << "ptr 的值是 " << ptr;

	return 0;
}

内存地址 0 有特别重要的意义，它表明该指针不指向一个可访问的内存位置。如果指针包含空值（零值），则假定它不指向任何东西。

如需检查一个空指针，您可以使用 if 语句，如下所示：

if(ptr)     // 如果 p 非空，则完成 
if(!ptr)    // 如果 p 为空，则完成 

如果所有未使用的指针都被赋予空值，同时避免使用空指针，就可以防止误用一个未初始化的指针。

C++ 指针的算术运算

指针是一个用数值表示的地址。因此，可以对指针进行四种算术运算：++、–、+、-。

递增一个指针

#include <iostream>
using namespace std;
const int MAX = 3;
int main()
{
	int var[MAX] = { 1, 13, 313 };
	int *ptr;
	ptr = var;
	for (int i = 0; i < MAX; i++)
	{
		cout << "var[" << i << "]=" << ptr << endl;
		cout << "var[" << i << "]=" << *ptr << endl;
		ptr++;
	}
	return 0;
}

递减一个指针

#include <iostream>
using namespace std;
const int MAX = 3;
int main()
{
	int var[MAX] = { 1, 13, 313 };
	int *ptr;
	ptr = &var[MAX-1];
	for (int i = MAX; i >0; i--)
	{
		cout << "var[" << i << "]=" << ptr << endl;
		cout << "var[" << i << "]=" << *ptr << endl;
		ptr--;
	}
	return 0;
}

C++ 指向指针的指针（多级间接寻址）

指向指针的指针是一种多级间接寻址的形式，或者说是一个指针链。通常，一个指针包含一个变量的地址。当我们定义一个指向指针的指针时，第一个指针包含了第二个指针的地址，第二个指针指向包含实际值的位置。
一个指向指针的指针变量必须如下声明，即在变量名前放置两个星号。例如，下面声明了一个指向 int 类型指针的指针：

int **var;

如：

#include <iostream>
using namespace std;
int main()
{
	int  var;
	int* ptr;
	int** pptr;
	var = 3000;
	ptr = &var; // 获取 var 的地址
	pptr = &ptr; // 使用运算符 & 获取 ptr 的地址
	cout << "Value of var :" << var << endl;
	cout << "Value available at *ptr :" << *ptr << endl;
	cout << "Value available at **pptr :" << **pptr << endl;
	return 0;
}

C++ 引用

引用变量是一个别名，也就是说，它是某个已存在变量的另一个名字。一旦把引用初始化为某个变量，就可以使用该引用名称或变量名称来指向变量。

C++ 引用 vs 指针

引用很容易与指针混淆，它们之间有三个主要的不同：

• 不存在空引用。引用必须连接到一块合法的内存。
• 一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。
• 引用必须在创建时被初始化。指针可以在任何时间被初始化。

C++ 中创建引用

如：

#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;
}

引用通常用于函数参数列表和函数返回值。

C++ 把引用作为返回值

当函数返回一个引用时，则返回一个指向返回值的隐式指针。这样，函数就可以放在赋值语句的左边。

如：

#include <iostream>
#include <ctime>
using namespace std;
int a[] = { 1, 2, 3, 4 };
int& seta(int i)
{
	return a[i];
}
int main()
{
    cout << "改变前的值" << endl;
    for (int i = 0; i < 4; i++)
    {
        cout << "a[" << i << "] = " << a[i] << endl;;
    }

    seta(1) = 20.23; // 改变第 2 个元素
    seta(3) = 70.8;  

    cout << "改变后的值" << endl;
    for (int i = 0; i < 4; i++)
    {
        cout << "a[" << i << "] = " << a[i] << endl;
    }
	return 0;
}

C++ 日期 & 时间

有四个与时间相关的类型：clock_t、time_t、size_t 和 tm。类型 clock_t、size_t 和 time_t 能够把系统时间和日期表示为某种整数。

结构类型 tm 把日期和时间以 C 结构的形式保存，tm 结构的定义如下：

struct tm {
  int tm_sec;   // 秒，正常范围从 0 到 59，但允许至 61
  int tm_min;   // 分，范围从 0 到 59
  int tm_hour;  // 小时，范围从 0 到 23
  int tm_mday;  // 一月中的第几天，范围从 1 到 31
  int tm_mon;   // 月，范围从 0 到 11
  int tm_year;  // 自 1900 年起的年数
  int tm_wday;  // 一周中的第几天，范围从 0 到 6，从星期日算起
  int tm_yday;  // 一年中的第几天，范围从 0 到 365，从 1 月 1 日算起
  int tm_isdst; // 夏令时
}

C++ 基本的输入输出

C++ 的 I/O 发生在流中，流是字节序列。如果字节流是从设备（如键盘、磁盘驱动器、网络连接等）流向内存，这叫做输入操作。如果字节流是从内存流向设备（如显示屏、打印机、磁盘驱动器、网络连接等），这叫做输出操作。

I/O 库头文件

标准输出流（cout）

预定义的对象 cout 是 ostream 类的一个实例。cout 对象"连接"到标准输出设备，通常是显示屏。cout 是与流插入运算符 << 结合使用的。

如：

#include <iostream>
using namespace std;

int main()
{
	char str[] = "Hello C++";
	cout << "Value of str is : " << str << endl;
}

标准输入流（cin）

预定义的对象 cin 是 istream 类的一个实例。cin 对象附属到标准输入设备，通常是键盘。cin 是与流提取运算符 >> 结合使用的。

如：

#include <iostream>
using namespace std;

int main()
{
    char name[50];
    cout << "请输入您的名称： ";
    cin >> name;
    cout << "您的名称是： " << name << endl;
}

标准错误流（cerr）

预定义的对象 cerr 是 ostream 类的一个实例。cerr 对象附属到标准错误设备，通常也是显示屏，但是 cerr 对象是非缓冲的，且每个流插入到 cerr 都会立即输出。

如：

#include <iostream>
using namespace std;
 
int main( )
{
   char str[] = "Unable to read....";
   cerr << "Error message : " << str << endl; 
} 

标准日志流（clog）

预定义的对象 clog 是 ostream 类的一个实例。clog 对象附属到标准错误设备，通常也是显示屏，但是 clog 对象是缓冲的。这意味着每个流插入到 clog 都会先存储在缓冲区中，直到缓冲填满或者缓冲区刷新时才会输出。

如：

#include <iostream>
using namespace std;
 
int main( )
{
   char str[] = "Unable to read....";
   clog << "Error message : " << str << endl;
} 

C++ 数据结构

C/C++ 数组允许定义可存储相同类型数据项的变量，但是结构是 C++ 中另一种用户自定义的可用的数据类型，它允许您存储不同类型的数据项。

定义结构
为了定义结构，您必须使用 struct 语句。struct 语句定义了一个包含多个成员的新的数据类型，struct 语句的格式如下：

struct [structure tag]
{
   member definition;
   member definition;
   ...
   member definition;
} [one or more structure variables];  

访问结构成员

为了访问结构的成员，我们使用成员访问运算符（.）。成员访问运算符是结构变量名称和我们要访问的结构成员之间的一个句号。您可以使用 struct 关键字来定义结构类型的变量。

结构作为函数参数

您可以把结构作为函数参数，传参方式与其他类型的变量或指针类似。

指向结构的指针

您可以定义指向结构的指针，方式与定义指向其他类型变量的指针相似，如下所示：

struct Books *struct_pointer;

typedef 关键字

下面是一种更简单的定义结构的方式，您可以为创建的类型取一个"别名"。