C++ 数据类型
- 使用变量来存储各种信息，变量保留的是它所存储的值的内存位置。这意味着，当创建一个变量时，就会在内存中保留一些空间。这段内存空间可以用于存储各种数据类型（比如字符型、宽字符型、整型、浮点型、双浮点型、布尔型等）的信息，操作系统会根据变量的数据类型，来分配内存和决定在保留内存中存储什么。
-
typedef short int wchar_t;因此 wchar_t 实际上的空间是和 short int 一样。 -
一些基本类型可以使用一个或多个类型修饰符进行修饰：
- signed
- unsigned
- short
- long
typedef 声明
- 您可以使用 typedef 为一个已有的类型取一个新的名字。下面是使用 typedef 定义一个新类型的语法：
- typedef type newname；
- typedef int feed；给int给一个别名，feed
枚举类型
- 枚举类型(enumeration)是C++中的一种派生数据类型，它是由用户定义的若干枚举常量的集合。
- 如果一个变量只有几种可能的值，可以定义为枚举(enumeration)类型。所谓"枚举"是指将变量的值一一列举出来，变量的值只能在列举出来的值的范围内。创建枚举，需要使用关键字 enum。枚举类型的一般形式为：
enum 枚举名{ 标识符[=整型常数], 标识符[=整型常数],
... 标识符[=整型常数]
} 枚举变量;- 如果枚举没有初始化, 即省掉"=整型常数"时, 则从第一个标识符开始。例如，下面的代码定义了一个颜色枚举，变量 c 的类型为 color。最后，c 被赋值为 "blue"。
enum color { red, green, blue } c;
c = blue;- 默认情况下，第一个名称的值为 0，第二个名称的值为 1，第三个名称的值为 2，以此类推。但是，您也可以给名称赋予一个特殊的值，只需要添加一个初始值即可。例如，在下面的枚举中，green 的值为 5。
enum color { red, green=5, blue };
- 在这里，blue 的值为 6，因为默认情况下，每个名称都会比它前面一个名称大 1，但 red 的值依然为 0。
C++变量的类型
Extern
- 当使用多个文件且只在其中一个文件中定义变量时（定义变量的文件在程序连接时是可用的），变量声明就显得非常有用。可以使用 extern 关键字在任何地方声明一个变量。虽然可以在 C++ 程序中多次声明一个变量，但变量只能在某个文件、函数或代码块中被定义一次。
C++ 中的左值（Lvalues）和右值（Rvalues）
C++ 中有两种类型的表达式：
- 左值（lvalue）：指向内存位置的表达式被称为左值（lvalue）表达式。左值可以出现在赋值号的左边或右边。
- 右值（rvalue）：术语右值（rvalue）指的是存储在内存中某些地址的数值。右值是不能对其进行赋值的表达式，也就是说，右值可以出现在赋值号的右边，但不能出现在赋值号的左边。
变量是左值，因此可以出现在赋值号的左边。数值型的字面值是右值，因此不能被赋值，不能出现在赋值号的左边。下面是一个有效的语句：int g = 20;
C++ 变量作用域
作用域是程序的一个区域，一般来说有三个地方可以定义变量：
- 在函数或一个代码块内部声明的变量，称为局部变量。
- 在函数参数的定义中声明的变量，称为形式参数。
- 在所有函数外部声明的变量，称为全局变量。
初始化局部变量和全局变量
- 当局部变量被定义时，系统不会对其初始化，必须自行对其初始化。定义全局变量时，系统会自动初始化为下列值：
整数变量
- 整数常量也可以带一个后缀，后缀是 U 和 L 的组合，U 表示无符号整数（unsigned），L 表示长整数（long）。后缀可以是大写，也可以是小写，U 和 L 的顺序任意。
字符常量
- 字符常量是括在单引号中。如果常量以 L（仅当大写时）开头，则表示它是一个宽字符常量（例如 L'x'），此时它必须存储在 wchar_t 类型的变量中。否则，它就是一个窄字符常量（例如 'x'），此时它可以存储在 char 类型的简单变量中。
- 字符常量可以是一个普通的字符（例如 'x'）、一个转义序列（例如 '\t'），或一个通用的字符（例如 '\u02C0'）。
- 在 C++ 中，有一些特定的字符，当它们前面有反斜杠时，它们就具有特殊的含义，被用来表示如换行符（\n）或制表符（\t）等。下表列出了一些这样的转义序列码：
定义常量
在 C++ 中，有两种简单的定义常量的方式：
- 使用 #define 预处理器。
- 使用 const 关键字。
C++ 中的类型限定符
类型限定符提供了变量的额外信息。 
C++ 存储类
- auto
- register
- static
- extern
- mutable
- thread_local (C++11)
auto 存储类
- 自 C++ 11 以来，auto 关键字用于两种情况：声明变量时根据初始化表达式自动推断该变量的类型、声明函数时函数返回值的占位符。C++98标准中auto关键字用于自动变量的声明，但由于使用极少且多余，在C++11中已删除这一用法。
- 根据初始化表达式自动推断被声明的变量的类型，如：
auto f=3.14; //double
auto s("hello"); //const char*
auto z = new auto(9); // int*
auto x1 = 5, x2 = 5.0, x3='r';//错误，必须是初始化为同一类型register 存储类
- register 存储类用于定义存储在寄存器中而不是 RAM 中的局部变量。这意味着变量的最大尺寸等于寄存器的大小（通常是一个词），且不能对它应用一元的 '&' 运算符（因为它没有内存位置）。
{register int miles;
}- 寄存器只用于需要快速访问的变量，比如计数器。还应注意的是，定义 'register' 并不意味着变量将被存储在寄存器中，它意味着变量可能存储在寄存器中，这取决于硬件和实现的限制。
static 存储类
- static 存储类指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。
- static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。
- 在 C++ 中，当 static 用在类数据成员上时，会导致仅有一个该成员的副本被类的所有对象共享。
extern 存储类
- extern 存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。当您使用 'extern' 时，对于无法初始化的变量，会把变量名指向一个之前定义过的存储位置。
- 当您有多个文件且定义了一个可以在其他文件中使用的全局变量或函数时，可以在其他文件中使用 extern 来得到已定义的变量或函数的引用。可以这么理解，extern 是用来在另一个文件中声明一个全局变量或函数。
- extern 修饰符通常用于当有两个或多个文件共享相同的全局变量或函数的时候
mutable 存储类
- mutable 说明符仅适用于类的对象，这将在本教程的最后进行讲解。它允许对象的成员替代常量。也就是说，mutable 成员可以通过 const 成员函数修改。
thread_local 存储类
- 使用 thread_local 说明符声明的变量仅可在它在其上创建的线程上访问。 变量在创建线程时创建，并在销毁线程时销毁。 每个线程都有其自己的变量副本。
- thread_local 说明符可以与 static 或 extern 合并。
- 可以将 thread_local 仅应用于数据声明和定义，thread_local 不能用于函数声明或定义。
- 以下演示了可以被声明为 thread_local 的变量：
thread_local int x; // 命名空间下的全局变量
class X
{static thread_local std::string s; // 类的static成员变量
};
static thread_local std::string X::s; // X::s 是需要定义的void foo()
{thread_local std::vector<int> v; // 本地变量
}C++ 运算符
运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C++ 内置了丰富的运算符，并提供了以下类型的运算符：
- 算术运算符
- 关系运算符
- 逻辑运算符
- 位运算符
- 赋值运算符
- 杂项运算符
C++ 教程
C++ 教程C++ 简介C++ 环境设置C++ 基本语法C++ 注释C++ 数据类型C++ 变量类型C++ 变量作用域C++ 常量C++ 修饰符类型C++ 存储类C++ 运算符C++ 循环C++ 判断C++ 函数C++ 数字C++ 数组C++ 字符串C++ 指针C++ 引用C++ 日期 & 时间C++ 基本的输入输出C++ 数据结构
C++ 面向对象
C++ 类 & 对象C++ 继承C++ 重载运算符和重载函数C++ 多态C++ 数据抽象C++ 数据封装C++ 接口（抽象类）
C++ 高级教程
C++ 文件和流C++ 异常处理C++ 动态内存C++ 命名空间C++ 模板C++ 预处理器C++ 信号处理C++ 多线程C++ Web 编程
C++ 资源库
C++ STL 教程C++ 标准库C++ 有用的资源C++ 实例
C++ 存储类
C++ 循环
C++ 运算符
运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C++ 内置了丰富的运算符，并提供了以下类型的运算符：
- 算术运算符
- 关系运算符
- 逻辑运算符
- 位运算符
- 赋值运算符
- 杂项运算符
本章将逐一介绍算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符和其他运算符。
算术运算符
下表显示了 C++ 支持的算术运算符。
假设变量 A 的值为 10，变量 B 的值为 20，则：
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 把两个操作数相加 | A + B 将得到 30 |
| - | 从第一个操作数中减去第二个操作数 | A - B 将得到 -10 |
| * | 把两个操作数相乘 | A * B 将得到 200 |
| / | 分子除以分母 | B / A 将得到 2 |
| % | 取模运算符，整除后的余数 | B % A 将得到 0 |
| ++ | 自增运算符，整数值增加 1 | A++ 将得到 11 |
| -- | 自减运算符，整数值减少 1 | A-- 将得到 9 |
实例
请看下面的实例，了解 C++ 中可用的算术运算符。
复制并粘贴下面的 C++ 程序到 test.cpp 文件中，编译并运行程序。
实例
#include <iostream> using namespace std; int main() { int a = 21; int b = 10; int c; c = a + b; cout << "Line 1 - c 的值是 " << c << endl ; c = a - b; cout << "Line 2 - c 的值是 " << c << endl ; c = a * b; cout << "Line 3 - c 的值是 " << c << endl ; c = a / b; cout << "Line 4 - c 的值是 " << c << endl ; c = a % b; cout << "Line 5 - c 的值是 " << c << endl ; int d = 10; // 测试自增、自减 c = d++; cout << "Line 6 - c 的值是 " << c << endl ; d = 10; // 重新赋值 c = d--; cout << "Line 7 - c 的值是 " << c << endl ; return 0; }
当上面的代码被编译和执行时，它会产生以下结果：
Line 1 - c 的值是 31
Line 2 - c 的值是 11
Line 3 - c 的值是 210
Line 4 - c 的值是 2
Line 5 - c 的值是 1
Line 6 - c 的值是 10
Line 7 - c 的值是 10关系运算符
下表显示了 C++ 支持的关系运算符。
假设变量 A 的值为 10，变量 B 的值为 20，则：
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 检查两个操作数的值是否相等，如果相等则条件为真。 | (A == B) 不为真。 |
| != | 检查两个操作数的值是否相等，如果不相等则条件为真。 | (A != B) 为真。 |
| > | 检查左操作数的值是否大于右操作数的值，如果是则条件为真。 | (A > B) 不为真。 |
| < | 检查左操作数的值是否小于右操作数的值，如果是则条件为真。 | (A < B) 为真。 |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。 | (A >= B) 不为真。 |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。 | (A <= B) 为真。 |
实例
请看下面的实例，了解 C++ 中可用的关系运算符。
复制并黏贴下面的 C++ 程序到 test.cpp 文件中，编译并运行程序。
实例
#include <iostream> using namespace std; int main() { int a = 21; int b = 10; int c ; if( a == b ) { cout << "Line 1 - a 等于 b" << endl ; } else { cout << "Line 1 - a 不等于 b" << endl ; } if ( a < b ) { cout << "Line 2 - a 小于 b" << endl ; } else { cout << "Line 2 - a 不小于 b" << endl ; } if ( a > b ) { cout << "Line 3 - a 大于 b" << endl ; } else { cout << "Line 3 - a 不大于 b" << endl ; } /* 改变 a 和 b 的值 */ a = 5; b = 20; if ( a <= b ) { cout << "Line 4 - a 小于或等于 b" << endl ; } if ( b >= a ) { cout << "Line 5 - b 大于或等于 a" << endl ; } return 0; }
当上面的代码被编译和执行时，它会产生以下结果：
Line 1 - a 不等于 b
Line 2 - a 不小于 b
Line 3 - a 大于 b
Line 4 - a 小于或等于 b
Line 5 - b 大于或等于 a逻辑运算符
下表显示了 C++ 支持的关系逻辑运算符。
假设变量 A 的值为 1，变量 B 的值为 0，则：
| 运算符 | 描述 | 实例 |
|---|---|---|
| && | 称为逻辑与运算符。如果两个操作数都非零，则条件为真。 | (A && B) 为假。 |
| || | 称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。 | (A || B) 为真。 |
| ! | 称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 | !(A && B) 为真。 |
实例
请看下面的实例，了解 C++ 中可用的逻辑运算符。
复制并黏贴下面的 C++ 程序到 test.cpp 文件中，编译并运行程序。
实例
#include <iostream> using namespace std; int main() { int a = 5; int b = 20; int c ; if ( a && b ) { cout << "Line 1 - 条件为真"<< endl ; } if ( a || b ) { cout << "Line 2 - 条件为真"<< endl ; } /* 改变 a 和 b 的值 */ a = 0; b = 10; if ( a && b ) { cout << "Line 3 - 条件为真"<< endl ; } else { cout << "Line 4 - 条件不为真"<< endl ; } if ( !(a && b) ) { cout << "Line 5 - 条件为真"<< endl ; } return 0; }
当上面的代码被编译和执行时，它会产生以下结果：
Line 1 - 条件为真
Line 2 - 条件为真
Line 4 - 条件不为真
Line 5 - 条件为真位运算符
位运算符作用于位，并逐位执行操作。&、 | 和 ^ 的真值表如下所示：
| p | q | p & q | p | q | p ^ q |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
假设如果 A = 60，且 B = 13，现在以二进制格式表示，它们如下所示：
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011
下表显示了 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++ 程序到 test.cpp 文件中，编译并运行程序。
实例
#include <iostream> using namespace std; int main() { unsigned int a = 60; // 60 = 0011 1100 unsigned int b = 13; // 13 = 0000 1101 int c = 0; c = a & b; // 12 = 0000 1100 cout << "Line 1 - c 的值是 " << c << endl ; c = a | b; // 61 = 0011 1101 cout << "Line 2 - c 的值是 " << c << endl ; c = a ^ b; // 49 = 0011 0001 cout << "Line 3 - c 的值是 " << c << endl ; c = ~a; // -61 = 1100 0011 cout << "Line 4 - c 的值是 " << c << endl ; c = a << 2; // 240 = 1111 0000 cout << "Line 5 - c 的值是 " << c << endl ; c = a >> 2; // 15 = 0000 1111 cout << "Line 6 - c 的值是 " << c << endl ; return 0; }
当上面的代码被编译和执行时，它会产生以下结果：
Line 1 - c 的值是 12
Line 2 - c 的值是 61
Line 3 - c 的值是 49
Line 4 - c 的值是 -61
Line 5 - c 的值是 240
Line 6 - c 的值是 15赋值运算符
下表列出了 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++ 中可用的赋值运算符。
复制并黏贴下面的 C++ 程序到 test.cpp 文件中，编译并运行程序。
实例
#include <iostream> using namespace std; int main() { int a = 21; int c ; c = a; cout << "Line 1 - = 运算符实例，c 的值 = : " <<c<< endl ; c += a; cout << "Line 2 - += 运算符实例，c 的值 = : " <<c<< endl ; c -= a; cout << "Line 3 - -= 运算符实例，c 的值 = : " <<c<< endl ; c *= a; cout << "Line 4 - *= 运算符实例，c 的值 = : " <<c<< endl ; c /= a; cout << "Line 5 - /= 运算符实例，c 的值 = : " <<c<< endl ; c = 200; c %= a; cout << "Line 6 - %= 运算符实例，c 的值 = : " <<c<< endl ; c <<= 2; cout << "Line 7 - <<= 运算符实例，c 的值 = : " <<c<< endl ; c >>= 2; cout << "Line 8 - >>= 运算符实例，c 的值 = : " <<c<< endl ; c &= 2; cout << "Line 9 - &= 运算符实例，c 的值 = : " <<c<< endl ; c ^= 2; cout << "Line 10 - ^= 运算符实例，c 的值 = : " <<c<< endl ; c |= 2; cout << "Line 11 - |= 运算符实例，c 的值 = : " <<c<< endl ; return 0; }
当上面的代码被编译和执行时，它会产生以下结果：
Line 1 - = 运算符实例，c 的值 = 21
Line 2 - += 运算符实例，c 的值 = 42
Line 3 - -= 运算符实例，c 的值 = 21
Line 4 - *= 运算符实例，c 的值 = 441
Line 5 - /= 运算符实例，c 的值 = 21
Line 6 - %= 运算符实例，c 的值 = 11
Line 7 - <<= 运算符实例，c 的值 = 44
Line 8 - >>= 运算符实例，c 的值 = 11
Line 9 - &= 运算符实例，c 的值 = 2
Line 10 - ^= 运算符实例，c 的值 = 0
Line 11 - |= 运算符实例，c 的值 = 2杂项运算符
下表列出了 C++ 支持的其他一些重要的运算符。
| 运算符 | 描述 |
|---|---|
| sizeof | sizeof 运算符返回变量的大小。例如，sizeof(a) 将返回 4，其中 a 是整数。 |
| Condition ? X : Y | 条件运算符。如果 Condition 为真 ? 则值为 X : 否则值为 Y。 |
| , | 逗号运算符会顺序执行一系列运算。整个逗号表达式的值是以逗号分隔的列表中的最后一个表达式的值。 |
| .（点）和 ->（箭头） | 成员运算符用于引用类、结构和共用体的成员。 |
| Cast | 强制转换运算符把一种数据类型转换为另一种数据类型。例如，int(2.2000) 将返回 2。 |
| & | 指针运算符 & 返回变量的地址。例如 &a; 将给出变量的实际地址。 |
| * | 指针运算符 * 指向一个变量。例如，*var; 将指向变量 var。 |
- sizeof(data type);
- Exp1?Exp2:Exp3;
- 表达式1，表达式2 先求解表达式 1，再求解表达式 2。整个逗号表达式的值是表达式 2 的值。最右边的那个表达式的值将作为整个逗号表达式的值，其他表达式的值会被丢弃。
-
.（点）运算符和 ->（箭头）运算符用于引用类、结构和共用体的成员。点运算符应用于实际的对象。箭头运算符与一个指向对象的指针一起使用。
struct Employee {char first_name[16];int age;
} emp;（.）点运算符
下面的代码把值 "zara" 赋给对象 emp 的 first_name 成员：
strcpy(emp.first_name, "zara");（->）箭头运算符
如果 p_emp 是一个指针，指向类型为 Employee 的对象，则要把值 "zara" 赋给对象 emp 的 first_name 成员，需要编写如下代码：
strcpy(p_emp->first_name, "zara");-> 称为箭头运算符，它是由一个减号加上一个大于号组成。
简而言之，访问结构的成员时使用点运算符，而通过指针访问结构的成员时，则使用箭头运算符。
强制类型转换负号
-
const_cast<type> (expr): const_cast 运算符用于修改类型的 const / volatile 属性。除了 const 或 volatile 属性之外，目标类型必须与源类型相同。这种类型的转换主要是用来操作所传对象的 const 属性，可以加上 const 属性，也可以去掉 const 属性。
-
dynamic_cast<type> (expr): dynamic_cast 在运行时执行转换，验证转换的有效性。如果转换未执行，则转换失败，表达式 expr 被判定为 null。dynamic_cast 执行动态转换时，type 必须是类的指针、类的引用或者 void*，如果 type 是类指针类型，那么 expr 也必须是一个指针，如果 type 是一个引用，那个 expr 也必须是一个引用。
-
reinterpret_cast<type> (expr): reinterpret_cast 运算符把某种指针改为其他类型的指针。它可以把一个指针转换为一个整数，也可以把一个整数转换为一个指针。
-
static_cast<type> (expr): static_cast 运算符执行非动态转换，没有运行时类检查来保证转换的安全性。例如，它可以用来把一个基类指针转换为派生类指针。
取地址运算符号
- C++ 提供了两种指针运算符，一种是取地址运算符 &，一种是间接寻址运算符 *。
- 指针是一个包含了另一个变量地址的变量，可以把一个包含了另一个变量地址的变量说成是"指向"另一个变量。变量可以是任意的数据类型，包括对象、结构或者指针。
-
取地址运算符 &
& 是一元运算符，返回操作数的内存地址。例如，如果 var 是一个整型变量，则 &var 是它的地址。该运算符与其他一元运算符具有相同的优先级，在运算时它是从右向左顺序进行的。
您可以把 & 运算符读作"取地址运算符"，这意味着，&var 读作"var 的地址"。
间接寻址运算符 *
第二个运算符是间接寻址运算符 *，它是 & 运算符的补充。* 是一元运算符，返回操作数所指定地址的变量的值。
请看下面的实例，理解这两种运算符的用法。
-
#include <iostream>using namespace std;int main () {int var;int *ptr;int val;var = 3000;// 获取 var 的地址ptr = &var;// 获取 ptr 的值val = *ptr;cout << "Value of var :" << var << endl;cout << "Value of ptr :" << ptr << endl;cout << "Value of val :" << val << endl;return 0; } //Value of var :3000 //Value of ptr :0xbff64494 //Value of val :3000
C++ 中的运算符优先级
| 类别 | 运算符 | 结合性 |
|---|---|---|
| 后缀 | () [] -> . ++ - - | 从左到右 |
| 一元 | + - ! ~ ++ - - (type)* & sizeof | 从右到左 |
| 乘除 | * / % | 从左到右 |
| 加减 | + - | 从左到右 |
| 移位 | << >> | 从左到右 |
| 关系 | < <= > >= | 从左到右 |
| 相等 | == != | 从左到右 |
| 位与 AND | & | 从左到右 |
| 位异或 XOR | ^ | 从左到右 |
| 位或 OR | | | 从左到右 |
| 逻辑与 AND | && | 从左到右 |
| 逻辑或 OR | || | 从左到右 |
| 条件 | ?: | 从右到左 |
| 赋值 | = += -= *= /= %=>>= <<= &= ^= |= | 从右到左 |
| 逗号 | , | 从左到右 |
循环
| 循环类型 | 描述 |
|---|---|
| while 循环 | 当给定条件为真时，重复语句或语句组。它会在执行循环主体之前测试条件。 |
| for 循环 | 多次执行一个语句序列，简化管理循环变量的代码。 |
| do...while 循环 | 除了它是在循环主体结尾测试条件外，其他与 while 语句类似。 |
| 嵌套循环 | 您可以在 while、for 或 do..while 循环内使用一个或多个循环。 |
循环控制语句
| 控制语句 | 描述 |
|---|---|
| break 语句 | 终止 loop 或 switch 语句，程序流将继续执行紧接着 loop 或 switch 的下一条语句。 |
| continue 语句 | 引起循环跳过主体的剩余部分，立即重新开始测试条件。 |
| goto 语句 | 将控制转移到被标记的语句。但是不建议在程序中使用 goto 语句。 |
判断语句
| 语句 | 描述 |
|---|---|
| if 语句 | 一个 if 语句 由一个布尔表达式后跟一个或多个语句组成。 |
| if...else 语句 | 一个 if 语句 后可跟一个可选的 else 语句，else 语句在布尔表达式为假时执行。 |
| 嵌套 if 语句 | 您可以在一个 if 或 else if 语句内使用另一个 if 或 else if 语句。 |
| switch 语句 | 一个 switch 语句允许测试一个变量等于多个值时的情况。 |
| 嵌套 switch 语句 | 您可以在一个 switch 语句内使用另一个 switch 语句。 |
函数的参数
| 调用类型 | 描述 |
|---|---|
| 传值调用 | 该方法把参数的实际值赋值给函数的形式参数。在这种情况下，修改函数内的形式参数对实际参数没有影响。 |
| 指针调用 | 该方法把参数的地址赋值给形式参数。在函数内，该地址用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。 |
| 引用调用 | 该方法把参数的引用赋值给形式参数。在函数内，该引用用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。 |
Lambda 函数与表达式
- C++11 提供了对匿名函数的支持,称为 Lambda 函数(也叫 Lambda 表达式)。
- Lambda 表达式把函数看作对象。Lambda 表达式可以像对象一样使用，比如可以将它们赋给变量和作为参数传递，还可以像函数一样对其求值。
- Lambda 表达式本质上与函数声明非常类似。Lambda 表达式具体形式如下
[](int x, int y){ return x < y ; }
- 如果没有返回值，可以表示为：
[]{ ++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(); }();
C++ 随机数
- 在许多情况下，需要生成随机数。关于随机数生成器，有两个相关的函数。一个是 rand()，该函数只返回一个伪随机数。生成随机数之前必须先调用 srand() 函数。
- 下面是一个关于生成随机数的简单实例。实例中使用了 time() 函数来获取系统时间的秒数，通过调用 rand() 函数来生成随机数：
C++数组详解
| 概念 | 描述 |
|---|---|
| 多维数组 | C++ 支持多维数组。多维数组最简单的形式是二维数组。 |
| 指向数组的指针 | 您可以通过指定不带索引的数组名称来生成一个指向数组中第一个元素的指针。 |
| 传递数组给函数 | 您可以通过指定不带索引的数组名称来给函数传递一个指向数组的指针。 |
| 从函数返回数组 | C++ 允许从函数返回数组。 |
C++ 传递数组给函数
方式 1
形式参数是一个指针：
void myFunction(int *param)
{
.
.
.
}方式 2
形式参数是一个已定义大小的数组：
void myFunction(int param[10])
{
.
.
.
}方式 3
形式参数是一个未定义大小的数组：
void myFunction(int param[])
{
.
.
.
}C++ 从函数返回数组
- C++ 不允许返回一个完整的数组作为函数的参数。但是，可以通过指定不带索引的数组名来返回一个指向数组的指针。如果想要从函数返回一个一维数组，必须声明一个返回指针的函数，如下：
- int * myFunction() { . . . }
- 另外，C++ 不支持在函数外返回局部变量的地址，除非定义局部变量为 static 变量。
C++ 字符串
| 序号 | 函数 & 目的 |
|---|---|
| 1 | strcpy(s1, s2); 复制字符串 s2 到字符串 s1。 |
| 2 | strcat(s1, s2); 连接字符串 s2 到字符串 s1 的末尾。 |
| 3 | strlen(s1); 返回字符串 s1 的长度。 |
| 4 | strcmp(s1, s2); 如果 s1 和 s2 是相同的，则返回 0；如果 s1<s2 则返回值小于 0；如果 s1>s2 则返回值大于 0。 |
| 5 | strchr(s1, ch); 返回一个指针，指向字符串 s1 中字符 ch 的第一次出现的位置。 |
| 6 | strstr(s1, s2); 返回一个指针，指向字符串 s1 中字符串 s2 的第一次出现的位置。 |
C++中使用指针
| 概念 | 描述 |
|---|---|
| C++ Null 指针 | C++ 支持空指针。NULL 指针是一个定义在标准库中的值为零的常量。 |
| C++ 指针的算术运算 | 可以对指针进行四种算术运算：++、--、+、- |
| C++ 指针 vs 数组 | 指针和数组之间有着密切的关系。 |
| C++ 指针数组 | 可以定义用来存储指针的数组。 |
| C++ 指向指针的指针 | C++ 允许指向指针的指针。 |
| C++ 传递指针给函数 | 通过引用或地址传递参数，使传递的参数在调用函数中被改变。 |
| C++ 从函数返回指针 | C++ 允许函数返回指针到局部变量、静态变量和动态内存分配。 |
- C++ 不支持在函数外返回局部变量的地址，除非定义局部变量为 static 变量。
C++ 引用 vs 指针
引用很容易与指针混淆，它们之间有三个主要的不同：
- 不存在空引用。引用必须连接到一块合法的内存。
- 一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。
- 引用必须在创建时被初始化。指针可以在任何时间被初始化。
int i = 17;
int& r = i; //r 是一个初始化为 i 的整型引用
double& s = d; //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.7C++ 日期 & 时间
- C++ 标准库没有提供所谓的日期类型。C++ 继承了 C 语言用于日期和时间操作的结构和函数。为了使用日期和时间相关的函数和结构，需要在 C++ 程序中引用 <ctime> 头文件。
- 有四个与时间相关的类型：clock_t、time_t、size_t 和 tm。类型 clock_t、size_t 和 time_t 能够把系统时间和日期表示为某种整数。
- 结构类型 tm 把日期和时间以 C 结构的形式保存，tm 结构的定义如下：
struct tm {int tm_sec; // 秒，正常范围从 0 到 59，但允许至 61int tm_min; // 分，范围从 0 到 59int tm_hour; // 小时，范围从 0 到 23int tm_mday; // 一月中的第几天，范围从 1 到 31int tm_mon; // 月，范围从 0 到 11int tm_year; // 自 1900 年起的年数int tm_wday; // 一周中的第几天，范围从 0 到 6，从星期日算起int tm_yday; // 一年中的第几天，范围从 0 到 365，从 1 月 1 日算起int tm_isdst; // 夏令时
}| 序号 | 函数 & 描述 |
|---|---|
| 1 | time_t time(time_t *time); 该函数返回系统的当前日历时间，自 1970 年 1 月 1 日以来经过的秒数。如果系统没有时间，则返回 -1。 |
| 2 | char *ctime(const time_t *time); 该返回一个表示当地时间的字符串指针，字符串形式 day month year hours:minutes:seconds year\n\0。 |
| 3 | struct tm *localtime(const time_t *time); 该函数返回一个指向表示本地时间的 tm 结构的指针。 |
| 4 | clock_t clock(void); 该函数返回程序执行起（一般为程序的开头），处理器时钟所使用的时间。如果时间不可用，则返回 -1。 |
| 5 | char * asctime ( const struct tm * time ); 该函数返回一个指向字符串的指针，字符串包含了 time 所指向结构中存储的信息，返回形式为：day month date hours:minutes:seconds year\n\0。 |
| 6 | struct tm *gmtime(const time_t *time); 该函数返回一个指向 time 的指针，time 为 tm 结构，用协调世界时（UTC）也被称为格林尼治标准时间（GMT）表示。 |
| 7 | time_t mktime(struct tm *time); 该函数返回日历时间，相当于 time 所指向结构中存储的时间。 |
| 8 | double difftime ( time_t time2, time_t time1 ); 该函数返回 time1 和 time2 之间相差的秒数。 |
| 9 | size_t strftime(); 该函数可用于格式化日期和时间为指定的格式。 |
C++ 基本的输入输出
- C++ 的 I/O 发生在流中，流是字节序列。如果字节流是从设备（如键盘、磁盘驱动器、网络连接等）流向内存，这叫做输入操作。如果字节流是从内存流向设备（如显示屏、打印机、磁盘驱动器、网络连接等），这叫做输出操作。
| 头文件 | 函数和描述 |
|---|---|
| <iostream> | 该文件定义了 cin、cout、cerr 和 clog 对象，分别对应于标准输入流、标准输出流、非缓冲标准错误流和缓冲标准错误流。 |
| <iomanip> | 该文件通过所谓的参数化的流操纵器（比如 setw 和 setprecision），来声明对执行标准化 I/O 有用的服务。 |
| <fstream> | 该文件为用户控制的文件处理声明服务。我们将在文件和流的相关章节讨论它的细节。 |
标准输入流（cin）
标准错误流（cerr）
#include <iostream>using namespace std;int main( )
{char str[] = "Unable to read....";cerr << "Error message : " << str << endl;
}标准日志流（clog）
- 预定义的对象 clog 是 iostream 类的一个实例。clog 对象附属到标准错误设备，通常也是显示屏，但是 clog 对象是缓冲的。这意味着每个流插入到 clog 都会先存储在缓冲区，直到缓冲填满或者缓冲区刷新时才会输出。
- clog 也是与流插入运算符 << 结合使用的，如下所示：
#include <iostream>using namespace std;int main( )
{char str[] = "Unable to read....";clog << "Error message : " << str << endl;
}输入输出流中的函数（模板）
#include <iostream>
#include <iomanip>
using namespace std;
int main()
{cout<<setiosflags(ios::left|ios::showpoint); // 设左对齐，以一般实数方式显示cout.precision(5); // 设置除小数点外有五位有效数字 cout<<123.456789<<endl;cout.width(10); // 设置显示域宽10 cout.fill('*'); // 在显示区域空白处用*填充cout<<resetiosflags(ios::left); // 清除状态左对齐cout<<setiosflags(ios::right); // 设置右对齐cout<<123.456789<<endl;cout<<setiosflags(ios::left|ios::fixed); // 设左对齐，以固定小数位显示cout.precision(3); // 设置实数显示三位小数cout<<999.123456<<endl; cout<<resetiosflags(ios::left|ios::fixed); //清除状态左对齐和定点格式cout<<setiosflags(ios::left|ios::scientific); //设置左对齐，以科学技术法显示 cout.precision(3); //设置保留三位小数cout<<123.45678<<endl;return 0;
}setiosflags(ios::fixed) 固定的浮点显示
setiosflags(ios::scientific) 指数表示
setiosflags(ios::left) 左对齐
setiosflags(ios::right) 右对齐
setiosflags(ios::skipws 忽略前导空白
setiosflags(ios::uppercase) 16进制数大写输出
setiosflags(ios::lowercase) 16进制小写输出
setiosflags(ios::showpoint) 强制显示小数点
setiosflags(ios::showpos) 强制显示符号 | 标志 | 功能 |
|---|---|
| boolalpha | 可以使用单词”true”和”false”进行输入/输出的布尔值. |
| oct | 用八进制格式显示数值. |
| dec | 用十进制格式显示数值. |
| hex | 用十六进制格式显示数值. |
| left | 输出调整为左对齐. |
| right | 输出调整为右对齐. |
| scientific | 用科学记数法显示浮点数. |
| fixed | 用正常的记数方法显示浮点数(与科学计数法相对应). |
| showbase | 输出时显示所有数值的基数. |
| showpoint | 显示小数点和额外的零，即使不需要. |
| showpos | 在非负数值前面显示”＋（正号）”. |
| skipws | 当从一个流进行读取时，跳过空白字符(spaces, tabs, newlines). |
| unitbuf | 在每次插入以后，清空缓冲区. |
| internal | 将填充字符回到符号和数值之间. |
| uppercase | 以大写的形式显示科学记数法中的”e”和十六进制格式的”x”. |
| 操作符 | 描述 | 输入 | 输出 |
|---|---|---|---|
| boolalpha | 启用boolalpha标志 | √ | √ |
| dec | 启用dec标志 | √ | √ |
| endl | 输出换行标示，并清空缓冲区 | √ | |
| ends | 输出空字符 | √ | |
| fixed | 启用fixed标志 | √ | |
| flush | 清空流 | √ | |
| hex | 启用 hex 标志 | √ | √ |
| internal | 启用 internal 标志 | √ | |
| left | 启用 left 标志 | √ | |
| noboolalpha | 关闭boolalpha 标志 | √ | √ |
| noshowbase | 关闭showbase 标志 | √ | |
| noshowpoint | 关闭showpoint 标志 | √ | |
| noshowpos | 关闭showpos 标志 | √ | |
| noskipws | 关闭skipws 标志 | √ | |
| nounitbuf | 关闭unitbuf 标志 | √ | |
| nouppercase | 关闭uppercase 标志 | √ | |
| oct | 启用 oct 标志 | √ | √ |
| right | 启用 right 标志 | √ | |
| scientific | 启用 scientific 标志 | √ | |
| showbase | 启用 showbase 标志 | √ | |
| showpoint | 启用 showpoint 标志 | √ | |
| showpos | 启用 showpos 标志 | √ | |
| skipws | 启用 skipws 标志 | √ | |
| unitbuf | 启用 unitbuf 标志 | √ | |
| uppercase | 启用 uppercase 标志 | √ | |
| ws | 跳过所有前导空白字符 | √ |
| 操作符 | 描述 | 输入 | 输出 |
|---|---|---|---|
| resetiosflags(long f) | 关闭被指定为f的标志 | √ | √ |
| setbase(int base) | 设置数值的基本数为base | √ | |
| setfill(int ch) | 设置填充字符为ch | √ | |
| setiosflags(long f) | 启用指定为f的标志 | √ | √ |
| setprecision(int p) | 设置数值的精度(四舍五入) | √ | |
| setw(int w) | 设置域宽度为w | √ |
C++ 数据结构
- C/C++ 数组允许定义可存储相同类型数据项的变量，但是结构是 C++ 中另一种用户自定义的可用的数据类型，它允许您存储不同类型的数据项。
- 结构用于表示一条记录，假设您想要跟踪图书馆中书本的动态，您可能需要跟踪每本书的下列属性：
Title ：标题
Author ：作者
Subject ：类目
Book ID ：书的 IDstruct type_name {
member_type1 member_name1;
member_type2 member_name2;
member_type3 member_name3;
.
.
} object_names;type_name 是结构体类型的名称，member_type1 member_name1 是标准的变量定义，比如 int i; 或者 float f; 或者其他有效的变量定义。在结构定义的末尾，最后一个分号之前，您可以指定一个或多个结构变量，这是可选的。下面是声明一个结构体类型 Books，变量为 book：struct Books
{char title[50];char author[50];char subject[100];int book_id;
} book;访问结构成员
- 为了访问结构的成员，我们使用成员访问运算符（.）。成员访问运算符是结构变量名称和我们要访问的结构成员之间的一个句号。
- 下面的实例演示了结构的用法：
#include <iostream>
#include <cstring>using namespace std;// 声明一个结构体类型 Books
struct Books
{char title[50];char author[50];char subject[100];int book_id;
};int main( )
{Books Book1; // 定义结构体类型 Books 的变量 Book1Books Book2; // 定义结构体类型 Books 的变量 Book2// Book1 详述strcpy( Book1.title, "C++ 教程");strcpy( Book1.author, "Runoob"); strcpy( Book1.subject, "编程语言");Book1.book_id = 12345;// Book2 详述strcpy( Book2.title, "CSS 教程");strcpy( Book2.author, "Runoob");strcpy( Book2.subject, "前端技术");Book2.book_id = 12346;// 输出 Book1 信息cout << "第一本书标题 : " << Book1.title <<endl;cout << "第一本书作者 : " << Book1.author <<endl;cout << "第一本书类目 : " << Book1.subject <<endl;cout << "第一本书 ID : " << Book1.book_id <<endl;// 输出 Book2 信息cout << "第二本书标题 : " << Book2.title <<endl;cout << "第二本书作者 : " << Book2.author <<endl;cout << "第二本书类目 : " << Book2.subject <<endl;cout << "第二本书 ID : " << Book2.book_id <<endl;return 0;
}结构体作为函数的参数
#include <iostream>
#include <cstring>using namespace std;
void printBook( struct Books book );// 声明一个结构体类型 Books
struct Books
{char title[50];char author[50];char subject[100];int book_id;
};int main( )
{Books Book1; // 定义结构体类型 Books 的变量 Book1Books Book2; // 定义结构体类型 Books 的变量 Book2// Book1 详述strcpy( Book1.title, "C++ 教程");strcpy( Book1.author, "Runoob"); strcpy( Book1.subject, "编程语言");Book1.book_id = 12345;// Book2 详述strcpy( Book2.title, "CSS 教程");strcpy( Book2.author, "Runoob");strcpy( Book2.subject, "前端技术");Book2.book_id = 12346;// 输出 Book1 信息printBook( Book1 );// 输出 Book2 信息printBook( Book2 );return 0;
}
void printBook( struct Books book )
{cout << "书标题 : " << book.title <<endl;cout << "书作者 : " << book.author <<endl;cout << "书类目 : " << book.subject <<endl;cout << "书 ID : " << book.book_id <<endl;
}指向结构的指针
- 可以定义指向结构的指针，方式与定义指向其他类型变量的指针相似，如下所示：
struct Books *struct_pointer;- 现在，您可以在上述定义的指针变量中存储结构变量的地址。为了查找结构变量的地址，请把 & 运算符放在结构名称的前面，如下所示：
struct_pointer = &Book1;- 为了使用指向该结构的指针访问结构的成员，您必须使用 -> 运算符，如下所示：
struct_pointer->title;#include <iostream>
#include <cstring>using namespace std;
void printBook( struct Books *book );struct Books
{char title[50];char author[50];char subject[100];int book_id;
};int main( )
{Books Book1; // 定义结构体类型 Books 的变量 Book1Books Book2; // 定义结构体类型 Books 的变量 Book2// Book1 详述strcpy( Book1.title, "C++ 教程");strcpy( Book1.author, "Runoob"); strcpy( Book1.subject, "编程语言");Book1.book_id = 12345;// Book2 详述strcpy( Book2.title, "CSS 教程");strcpy( Book2.author, "Runoob");strcpy( Book2.subject, "前端技术");Book2.book_id = 12346;// 通过传 Book1 的地址来输出 Book1 信息printBook( &Book1 );// 通过传 Book2 的地址来输出 Book2 信息printBook( &Book2 );return 0;
}
// 该函数以结构指针作为参数
void printBook( struct Books *book )
{cout << "书标题 : " << book->title <<endl;cout << "书作者 : " << book->author <<endl;cout << "书类目 : " << book->subject <<endl;cout << "书 ID : " << book->book_id <<endl;
}typedef 关键字
下面是一种更简单的定义结构的方式，您可以为创建的类型取一个"别名"。例如：
typedef struct Books
{char title[50];char author[50];char subject[100];int book_id;
}Books;现在，您可以直接使用 Books 来定义 Books 类型的变量，而不需要使用 struct 关键字。下面是实例：Books Book1, Book2;
您可以使用 typedef 关键字来定义非结构类型，如下所示：typedef long int *pint32;pint32 x, y, z;
x, y 和 z 都是指向长整型 long int 的指针。
