C++6万字详解_scanf输出指针

语言基础简介
    C++ 基础
        Hello, World!
        C++ 语法基础
        变量
        运算
        流程控制语句
        函数

C++ 进阶

    类
    命名空间
    值类别
    重载运算符
    引用
    常值
    编译优化

C++ 与其他常用语言的区别

 Pascal 转 C++ 急救

语言基础简介

本章将会介绍编程相关的知识，包括 C++ 从入门到进阶教程和一些其它语言的简介。

程序是算法与数据结构的载体，是解决 OI 问题的工具。

在 OI 中，最常用的编程语言是 C++。

学习编程是学习 OI 最基础的部分。

目录

语言基础简介

Hello, World!

环境配置

集成开发环境

编译器

Windows

macOS

Linux

在命令行中编译代码

第一份代码

C++ 语法基础

代码框架

注释

输入与输出

cin 与 cout

scanf 与 printf

一些扩展内容

C++ 中的空白字符

#define 命令

变量

数据类型

布尔类型

整数类型

字符类型

浮点类型

无类型

空指针类型

定宽整数类型

类型转换

数值提升

整数提升

浮点提升

数值转换

整数转换

浮点转换

浮点整数转换

布尔转换

定义变量

变量作用域

常量

运算

算术运算符

算术运算中的类型转换

位运算符

自增/自减 运算符

复合赋值运算符

条件运算符

比较运算符

逻辑运算符

逗号运算符

成员访问运算符

C++ 运算符优先级总表

分支

if 语句

基本 if 语句

if...else 语句

else if 语句

switch 语句

循环

for 语句

while 语句

do...while 语句

三种语句的联系

break 与 continue 语句

函数

函数的声明

实现函数：编写函数的定义

函数的调用

main 函数

类

定义类

访问说明符

访问与修改成员元素的值

成员函数

重载运算符

在实例化变量时设定初始值

销毁

为类变量赋值

参考资料

命名空间

概述

声明

using 指令

应用

值类别

从 CPL 语言的定义说起

C 和 C++11 以前

C++11 开始

C++17 带来的新变化

重载运算符

限制

实现

函数调用运算符

自增自减运算符

比较运算符

引用

左值引用

右值引用 (C++ 11)

一些例子

++i 和 i++

移动语义和 std::move(C++11)

函数返回引用

参考内容

常值

常类型

常量

常引用、常指针

常参数

常成员

常表达式 constexpr（C++11）

参考资料

编译优化

编译器优化简介

什么是优化 (Optimization)

常见的编译器优化

常量折叠 (Constant Folding)

死代码消除 (Deadcode Elimination)

循环旋转 (Loop Rotate)

循环不变量外提 (Loop Invariant Code Motion)

循环展开 (Loop Unroll)

循环判断外提 (Loop Unswitching)

代码布局优化 (Code Layout Optimizations)

基本块放置 (Basic Block Placement)

冷热代码分离 (Hot Cold Splitting)

函数内联 (Function Inlining)

always_inline,__force_inline

尾调用优化 (Tail Call Optimization)

用跳转指令代替函数调用

自动尾递归改写

尾递归消除 -Rpass=tailcallelim

强度削减 (Strength Reduction)

标量运算符变换

位运算代替乘法

乘法代替除法

索引变量强度削减 (IndVars)

自动向量化 (Auto-Vectorization)

__restrict type specifier (GNU, MSVC)

和编译优化相关的常见语言误用

inline - 内联

register - 虚假的寄存器建议

Sanitizer

Address Sanitizer -fsanitize=address

Undefined Behavior Sanitizer -fsanitize=undefined

杂项

Compiler Explorer

参考资料与注释

C++ 与其他常用语言的区别

C 与 C++ 的区别

宏与模板

指针与引用

bool

struct

const

内存分配

变量声明

可变长数组

结构体初始化

注释语法

Python 与 C++ 的区别

Java 与 C++ 的区别

Pascal 转 C++ 急救

C++ 快速安装与环境配置

方式一：使用 IDE

方式二：使用 代码编辑器 + 编译器 + 调试器

C++ 语法快速提要 Start Here

Hello World：第一个 C++ 程序

简要解释

简单练习

A+B Problem：第二个 C++ 程序

简要解释

简单练习

结束语与下一步

对应语法 Syntax

变量 Variable

基本数据类型 Fundamental types

常量声明 Constant

运算符 Operator

条件

if 语句

case 与 switch

循环 Loop

while 循环

for 循环

repeat until 与 do while 循环

循环控制 Loop Control

数组与字符串 Array and String

不定长数组：标准库类型 Vector

字符串：标准库类型 String

C 风格数组 Array

重要不同之处 Differences

变量作用域 Scope：全局变量与局部变量

C++ 可以自动转换类型

C++ 很多语句有返回值：以如何实现读取数量不定数据为例

函数 Function：C++ 只有函数没有过程但有 void ，没有函数值变量但有 return 。

在函数中传递参数 Passing Parameters to Functions

C++ 标准库与参考资料 Reference

C++ 标准库

错误排查与技巧

C++ 语言资料

后记

本文 Pascal 语言的参考文献

附 A：Pascal 与 C++ 运算符与数学函数语法对比表 Pascal vs C++ Operator Syntax Table

基本算术

逻辑

比较

赋值

自增/自减

数学函数

Hello, World!

环境配置

工欲善其事，必先利其器。

集成开发环境

IDE 操作较为简单，一般入门玩家会选用 IDE 来编写代码。在竞赛中最常见的是 Dev-C++（如果考试环境是 Windows 系统，一般也会提供这一 IDE）。

编译器

Windows

推荐使用 GNU 编译器。需要去 MinGW Distro 下载 MinGW 并安装。此外 Windows 下也可以选择 Microsoft Visual C++ 编译器，需要去 Visual Studio 页面 下载安装。

macOS

在终端中执行：

xcode-select --install

Linux

使用 g++ -v 来检查是否安装过 g++。

使用如下命令可以安装：

sudo apt update && sudo apt install g++

在命令行中编译代码

熟练之后也有玩家会使用更灵活的命令行来编译代码，这样就不依赖 IDE 了，而是使用自己熟悉的文本编辑器编写代码。

g++ test.cpp -o test -lm

g++ 是 C++ 语言的编译器（C 语言的编译器为 gcc），-o 用于指定可执行文件的文件名，编译选项 -lm 用于链接数学库 libm，从而使得使用 math.h 的代码可以正常编译运行。

注：C++ 程序不需要 -lm 即可正常编译运行。历年 NOI/NOIP 试题的 C++ 编译选项中都带着 -lm，故这里也一并加上。

第一份代码

通过这样一个示例程序来展开 C++ 入门之旅吧～

注：请在编写前注意开启英文输入法。

C++ 语言

#include <iostream>  // 引用头文件
 
using namespace std;
 
// 引入命名空间（相关阅读 https://oi-wiki.org/lang/namespace/#using ）
 
int main() {                // 定义 main 函数
  cout << "Hello, world!";  // 输出 Hello, world!
  return 0;                 // 返回 0，结束 main 函数
}

C 语言

#include <stdio.h>  // 引用头文件
 
int main() {                // 定义 main 函数
  printf("Hello, world!");  // 输出 Hello, world!
  return 0;                 // 返回 0，结束 main 函数
}

C++ 语法基础

代码框架

如果你不想深究背后的原理，初学时可以直接将这个「框架」背下来：

#include <cstdio>
#include <iostream>
 
int main() {
  // do something...
  return 0;
}

什么是 include？

什么是 main()？

注释

在 C++ 代码中，注释有两种写法：

1. 行内注释

   以 // 开头，行内位于其后的内容全部为注释。

2. 注释块

   以 /* 开头，*/ 结尾，中间的内容全部为注释，可以跨行。

注释对程序运行没有影响，可以用来解释程序的意思，还可以在让某段代码不执行（但是依然保留在源文件里）。

在工程开发中，注释可以便于日后维护、他人阅读。

在 OI 中，很少有人写许多注释，但注释可以便于在写代码的时候理清思路，或者便于日后复习。而且，如果要写题解、教程的话，适量的注释可以便于读者阅读，理解代码的意图。希望各位同学能养成写注释的好习惯。

输入与输出

cin 与 cout

#include <iostream>
 
int main() {
  int x, y;                          // 声明变量
  std::cin >> x >> y;                // 读入 x 和 y
  std::cout << y << std::endl << x;  // 输出 y，换行，再输出 x
  return 0;                          // 结束主函数
}

什么是变量？

可以参考 变量 页面。

什么是 std？

std 是 C++ 标准库所使用的 命名空间。使用命名空间是为了避免重名。

关于命名空间的详细知识，可以参考 命名空间 页面。

scanf 与 printf

scanf 与 printf 其实是 C 语言提供的函数。大多数情况下，它们的速度比 cin 和 cout 更快，并且能够方便地控制输入输出格式。

读入输出优化

cin/cout 和 scanf/prinf 的具体差别和读入输出优化，请参考 读入、输出优化 页面。

#include <cstdio>
 
int main() {
  int x, y;
  scanf("%d%d", &x, &y);   // 读入 x 和 y
  printf("%d\n%d", y, x);  // 输出 y，换行，再输出 x
  return 0;
}

其中，%d 表示读入/输出的变量是一个有符号整型（int 型）的变量。

类似地：

1. %s 表示字符串。
2. %c 表示字符。
3. %lf 表示双精度浮点数 (double)。
4. %lld 表示长整型 (long long)。根据系统不同，也可能是 %I64d。
5. %u 表示无符号整型 (unsigned int)。
6. %llu 表示无符号长整型 (unsigned long long)，也可能是 %I64u。

除了类型标识符以外，还有一些控制格式的方式。许多都不常用，选取两个常用的列举如下：

1. %1d 表示长度为 1 的整型。在读入时，即使没有空格也可以逐位读入数字。在输出时，若指定的长度大于数字的位数，就会在数字前用空格填充。若指定的长度小于数字的位数，就没有效果。
2. %.6lf，用于输出，保留六位小数。

这两种运算符的相应地方都可以填入其他数字，例如 %.3lf 表示保留三位小数。

「双精度浮点数」，「长整型」是什么

为什么 scanf 中有 & 运算符？

什么是 \n？

一些扩展内容

C++ 中的空白字符

在 C++ 中，所有空白字符（空格、制表符、换行），多个或是单个，都被视作是一样的。（当然，引号中视作字符串的一部分的不算。）

因此，你可以自由地使用任何代码风格（除了行内注释、字符串字面量与预处理命令必须在单行内），例如：

/* clang-format off */
 
#include <iostream>
 
 int 
 
    main(){
int/**/x, y;  std::cin
>> x >>y;
                std::cout <<
          y  <<std::endl   
     << x
 
          ;
 
    return       0;     }

当然，这么做是不被推荐的。

一种也被广泛使用但与 OI Wiki 要求的码风不同的代码风格：

/* clang-format off */
 
#include <iostream>
 
int main()
{
    int x, y;
 
    std::cin >> x >> y;
    std::cout << y << std::endl << x;
 
    return 0;
}

#define 命令

#define 是一种预处理命令，用于定义宏，本质上是文本替换。例如：

#include <iostream>
#define n 233
 
// n 不是变量，而是编译器会将代码中所有 n 文本替换为 233，但是作为标识符一部分的
// n 的就不会被替换，如 fn 不会被替换成 f233，同样，字符串内的也不会被替换
 
int main() {
  std::cout << n;  // 输出 233
  return 0;
}

什么是标识符？

什么是预处理命令？

宏可以带参数，带参数的宏可以像函数一样使用：

#include <iostream>
#define sum(x, y) ((x) + (y))
#define square(x) ((x) * (x))
 
int main() {
  std::cout << sum(1, 2) << ' ' << 2 * sum(3, 5) << std::endl;  // 输出 3 16
}

但是带参数的宏和函数有区别。因为宏是文本替换，所以会引发许多问题。如：

#include <iostream>
#define sum(x, y) x + y
// 这里应当为 #define sum(x, y) ((x) + (y))
#define square(x) ((x) * (x))
 
int main() {
  std::cout << sum(1, 2) << ' ' << 2 * sum(3, 5) << std::endl;
  // 输出为 3 11，因为 #define 是文本替换，后面的语句被替换为了 2 * 3 + 5
  int i = 1;
  std::cout << square(++i) << ' ' << i;
  // 输出未定义，因为 ++i 被执行了两遍
  // 而同一个语句中多次修改同一个变量是未定义行为（有例外）
}

使用 #define 是有风险的（由于 #define 作用域是整个程序，因此可能导致文本被意外地替换，需要使用 #undef 及时取消定义），因此应谨慎使用。较为推荐的做法是：使用 const 限定符声明常量，使用函数代替宏。

但是，在 OI 中，#define 依然有用武之处（以下两种是不被推荐的用法，会降低代码的规范性）：

1. #define int long long+signed main()。通常用于避免忘记开 long long 导致的错误，或是调试时排除忘开 long long 导致错误的可能性。（也可能导致增大常数甚至 TLE，或者因为爆空间而 MLE）
2. #define For(i, l, r) for (int i = (l); i <= (r); ++i)、#define pb push_back、#define mid ((l + r) / 2)，用于减短代码长度。

不过，#define 也有优点，比如结合 #ifdef 等预处理指令有奇效，比如：

#ifdef LINUX
// code for linux
#else
// code for other OS
#endif

变量

数据类型

C++ 的类型系统由如下几部分组成：

1. 基础类型（括号内为代表关键词/代表类型）
   1. 无类型/void 型 (void)
   2. （C++11 起）空指针类型 (std::nullptr_t)
   3. 算术类型
      1. 整数类型 (int)
      2. 布尔类型/bool 型 (bool)
      3. 字符类型 (char)
      4. 浮点类型 (float,double)
2. 复合类型2

布尔类型

一个 bool 类型的变量取值只可能为两种：true 和 false。

一般情况下，一个 bool 类型变量占有 字节（一般情况下， 字节 = 位）的空间。

C 语言的布尔类型

C 语言最初是没有布尔类型的，直到 C99 时才引入 _Bool 关键词作为布尔类型，其被视作无符号整数类型。

Note

C 语言的 bool 类型从 C23 起不再使用整型的零与非零值定义，而是定义为足够储存 true 和 false 两个常量的类型。

为方便使用，stdbool.h 中提供了 bool,true,false 三个宏，定义如下：

#define bool _Bool
#define true 1
#define false 0

这些宏于 C23 中移除，并且 C23 起引入 true,false 和 bool 作为关键字，同时保留 _Bool 作为替代拼写形式1。

整数类型

用于存储整数。最基础的整数类型是 int.

注意

由于历史原因，C++ 中布尔类型和字符类型会被视作特殊的整型。

在几乎所有的情况下都 不应该 将除 signed char 和 unsigned char 之外的字符类型作为整型使用。

整数类型一般按位宽有 5 个梯度：char,short,int,long,long long.

C++ 标准保证 1 == sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long) <= sizeof(long long)

由于历史原因，整数类型的位宽有多种流行模型，为解决这一问题，C99/C++11 引入了 定宽整数类型。

int 类型的大小

在 C++ 标准中，规定 int 的位数 至少 为 位。

事实上在现在的绝大多数平台，int 的位数均为 位。

对于 int 关键字，可以使用如下修饰关键字进行修饰：

符号性：

• signed：表示带符号整数（默认）；
• unsigned：表示无符号整数。

大小：

• short：表示 至少 位整数；
• long：表示 至少 位整数；
• （C++11 起）long long：表示 至少 位整数。

下表给出在 一般情况下，各整数类型的位宽和表示范围大小（少数平台上一些类型的表示范围可能与下表不同）：

类型名	等价类型	位宽（C++ 标准）	位宽（常见）	位宽（较罕见）
signed char	signed char		-	-
unsigned char	unsigned char		-	-
short,short int,signed short,signed short int	short int			-
unsigned short,unsigned short int	unsigned short int			-
int,signed,signed int	int			（常见于 Win16 API）
unsigned,unsigned int	unsigned int			（常见于 Win16 API）
long,long int,signed long,signed long int	long int			（常见于 64 位 Linux、macOS）
unsigned long,unsigned long int	unsigned long int			（常见于 64 位 Linux、macOS）
long long,long long int,signed long long,signed long long int	long long int			-
unsigned long long,unsigned long long int	unsigned long long int			-

当位宽为 时，有符号类型的表示范围为 , 无符号类型的表示范围为 . 具体而言，有下表：

位宽	表示范围
	有符号：, 无符号：
	有符号：, 无符号：
	有符号：, 无符号：
	有符号：, 无符号：

等价的类型表述

在不引发歧义的情况下，允许省略部分修饰关键字，或调整修饰关键字的顺序。这意味着同一类型会存在多种等价表述。

例如 int，signed，int signed，signed int 表示同一类型，而 unsigned long 和 unsigned long int 表示同一类型。

另外，一些编译器实现了扩展整数类型，如 GCC 实现了 128 位整数：有符号版的 __int128_t 和无符号版的 __uint128_t，如果您在比赛时想使用这些类型，请仔细阅读比赛规则 以确定是否允许或支持使用扩展整数类型。

字符类型

分为「窄字符类型」和「宽字符类型」，由于算法竞赛几乎不会用到宽字符类型，故此处仅介绍窄字符类型。

窄字符型位数一般为 位，实际上底层存储方式仍然是整数，一般通过 ASCII 编码 实现字符与整数的一一对应，有如下三种：

• signed char：有符号字符表示的类型，表示范围在 之间。
• unsigned char：无符号字符表示的类型，表示范围在 之间。

• char 拥有与 signed char 或 unsigned char 之一相同的表示和对齐，但始终是独立的类型。

  char 的符号性取决于编译器和目标平台：ARM 和 PowerPC 的默认设置通常没有符号，而 x86 与 x64 的默认设置通常有符号。

  GCC 可以在编译参数中添加 -fsigned-char 或 -funsigned-char 指定将 char 视作 signed char 或 unsigned char，其他编译器请参照文档。需要注意指定与架构默认值不同的符号有可能会破坏 ABI，造成程序无法正常工作。

注意

与其他整型不同，char、signed char、unsigned char 是 三种不同的类型。

一般来说 signed char,unsigned char 不应用来存储字符，绝大多数情况下，这两种类型均被视作整数类型。

浮点类型

用于存储「实数」（注意并不是严格意义上的实数，而是实数在一定规则下的近似），包括以下三种：

• float：单精度浮点类型。如果支持就会匹配 IEEE-754 binary32 格式。
• double：双精度浮点类型。如果支持就会匹配 IEEE-754 binary64 格式。
• long double：扩展精度浮点类型。如果支持就会匹配 IEEE-754 binary128 格式，否则如果支持就会匹配 IEEE-754 binary64 扩展格式，否则匹配某种精度优于 binary64 而值域至少和 binary64 一样好的非 IEEE-754 扩展浮点格式，否则匹配 IEEE-754 binary64 格式。

浮点格式	位宽	最大正数	精度位数
IEEE-754 binary32 格式
IEEE-754 binary64 格式
IEEE-754 binary64 扩展格式
IEEE-754 binary128 格式

IEEE-754 浮点格式的最小负数是最大正数的相反数。

因为 float 类型表示范围较小，且精度不高，实际应用中常使用 double 类型表示浮点数。

另外，浮点类型可以支持一些特殊值：

• 无穷（正或负）：INFINITY.
• 负零：-0.0，例如 1.0 / 0.0 == INFINITY,1.0 / -0.0 == -INFINITY.
• 非数（NaN）：std::nan,NAN，一般可以由 0.0 / 0.0 之类的运算产生。它与任何值（包括自身）比较都不相等，C++11 后可以 使用 std::isnan 判断一个浮点数是不是 NaN.

无类型

void 类型为无类型，与上面几种类型不同的是，不能将一个变量声明为 void 类型。但是函数的返回值允许为 void 类型，表示该函数无返回值。

空指针类型

请参阅指针的 对应章节

定宽整数类型

C++11 起提供了定宽整数的支持，具体如下：

• <cstdint>：提供了若干定宽整数的类型和各定宽整数类型最大值、最小值等的宏常量。
• <cinttypes>：为定宽整数类型提供了用于 std::fprintf 系列函数和 std::fscanf 系列函数的格式宏常量。

定宽整数有如下几种：

• intN_t: 宽度 恰为 位的有符号整数类型，如 int32_t.
• int_fastN_t: 宽度 至少 有 位的 最快的 有符号整数类型，如 int_fast32_t.
• int_leastN_t: 宽度 至少 有 位的 最小的 有符号整数类型，如 int_least32_t.

无符号版本只需在有符号版本前加一个字母 u 即可，如 uint32_t,uint_least8_t.

标准规定必须实现如下 16 种类型：

int_fast8_t,int_fast16_t,int_fast32_t,int_fast64_t,

int_least8_t,int_least16_t,int_least32_t,int_least64_t,

uint_fast8_t,uint_fast16_t,uint_fast32_t,uint_fast64_t,

uint_least8_t,uint_least16_t,uint_least32_t,uint_least64_t.

绝大多数编译器在此基础上都实现了如下 8 种类型：

int8_t,int16_t,int32_t,int64_t,

uint8_t,uint16_t,uint32_t,uint64_t.

在实现了对应类型的情况下，C++ 标准规定必须实现表示对应类型的最大值、最小值、位宽的宏常量，格式为将类型名末尾的 _t 去掉后转大写并添加后缀：

• _MAX 表示最大值，如 INT32_MAX 即为 int32_t 的最大值。
• _MIN 表示最小值，如 INT32_MIN 即为 int32_t 的最小值。

注意

定宽整数类型本质上是普通整数类型的类型别名，所以混用定宽整数类型和普通整数类型可能会影响跨平台编译，例如：

示例代码

#include <algorithm>
#include <cstdint>
#include <iostream>
 
int main() {
  long long a;
  int64_t b;
  std::cin >> a >> b;
  std::cout << std::max(a, b) << std::endl;
  return 0;
}

int64_t 在 64 位 Windows 下一般为 long long int, 而在 64 位 Linux 下一般为 long int, 所以这段代码在使用 64 位 Linux 下的 GCC 时不能通过编译，而使用 64 位 Windows 下的 MSVC 时可以通过编译，因为 std::max 要求输入的两个参数类型必须相同。

此外，C++17 起在 <limits> 中提供了 std::numeric_limits 类模板，用于查询各种算数类型的属性，如最大值、最小值、是否是整形、是否有符号等。

#include <cstdint>
#include <limits>
 
std::numeric_limits<int32_t>::max();  // int32_t 的最大值, 2'147'483'647
std::numeric_limits<int32_t>::min();  // int32_t 的最小值, -2'147'483'648
 
std::numeric_limits<double>::min();  // double 的最小值, 约为 2.22507e-308
std::numeric_limits<double>::epsilon();  // 1.0 与 double 的下个可表示值的差,
                                         // 约为 2.22045e-16

类型转换

在一些时候（比如某个函数接受 int 类型的参数，但传入了 double 类型的变量），我们需要将某种类型，转换成另外一种类型。

C++ 中类型的转换机制较为复杂，这里主要介绍对于基础数据类型的两种转换：数值提升和数值转换。

数值提升

数值提升过程中，值本身保持不变。

Note

C 风格的可变参数域在传值过程中会进行默认参数提升。如：

示例代码

#include <stdarg.h>
#include <stdio.h>
 
void test(int tot, ...) {
  va_list valist;
  int i;
 
  // 初始化可变参数列表
  va_start(valist, tot);
 
  for (i = 0; i < tot; ++i) {
    // 获取第 i 个变量的值
    double xx = va_arg(valist, double);  // Correct
    // float xx = va_arg(valist, float); // Wrong
 
    // 输出第 i 个变量的底层存储内容
    printf("i = %d, value = 0x%016llx\n", i, *(long long *)(&xx));
  }
 
  // 清理可变参数列表的内存
  va_end(valist);
}
 
int main() {
  float f;
  double fd, d;
  f = 123.;   // 0x42f60000
  fd = 123.;  // 0x405ec00000000000
  d = 456.;   // 0x407c800000000000
  test(3, f, fd, d);
}

在调用 test 时，f 提升为 double，从而底层存储内容和 fd 相同，输出为

i = 0, value = 0x405ec00000000000
i = 1, value = 0x405ec00000000000
i = 2, value = 0x407c800000000000

若将 double xx = va_arg(valist, double); 改为 float xx = va_arg(valist, float);，GCC 应该给出一条类似下文的警告：

In file included from test.c:2:
test.c: In function ‘test’:
test.c:14:35: warning: ‘float’ is promoted to ‘double’ when passed through ‘...’
  14 |         float xx = va_arg(valist, float);
     |                                   ^
test.c:14:35: note: (so you should pass ‘double’ not ‘float’ to ‘va_arg’)
test.c:14:35: note: if this code is reached, the program will abort

此时的程序将会在输出前终止。

这一点也能解释为什么 printf 的 %f 既能匹配 float 也能匹配 double。

整数提升

小整数类型（如 char）的纯右值可转换成较大整数类型（如 int）的纯右值。

具体而言，算术运算符不接受小于 int 的类型作为它的实参，而在左值到右值转换后，如果适用就会自动实施整数提升。

具体地，有如下规则：

• 源类型为 signed char、signed short / short 时，可提升为 int。
• 源类型为 unsigned char、unsigned short 时，若 int 能保有源类型的值范围，则可提升为 int，否则可提升为 unsigned int。（C++20 起 char8_t 也适用本规则）
• char 的提升规则取决于其底层类型是 signed char 还是 unsigned char。
• bool 类型可转换到 int：false 变为 0，true 变为 1。
• 若目标类型的值范围包含源类型，且源类型的值范围不能被 int 和 unsigned int 包含，则源类型可提升为目标类型。3

注意

char->short 不是数值提升，因为 char 要优先提升为 int / unsigned int，之后是 int / unsigned int->short，不满足数值提升的条件。

如（以下假定 int 为 32 位，unsigned short 为 16 位，signed char 和 unsigned char 为 8 位，bool 为 1 位）

• (signed char)'\0' - (signed char)'\xff' 会先将 (signed char)'\0' 提升为 (int)0、将 (signed char)'\xff' 提升为 (int)-1, 再进行 int 间的运算，最终结果为 (int)1。
• (unsigned char)'\0' - (unsigned char)'\xff' 会先将 (unsigned char)'\0' 提升为 (int)0、将 (unsigned char)'\xff' 提升为 (int)255, 再进行 int 间的运算，最终结果为 (int)-255。
• false - (unsigned short)12 会先将 false 提升为 (int)0、将 (unsigned short)12 提升为 (int)12, 再进行 int 间的运算，最终结果为 (int)-12。

浮点提升

位宽较小的浮点数可以提升为位宽较大的浮点数（例如 float 类型的变量和 double 类型的变量进行算术运算时，会将 float 类型变量提升为 double 类型变量），其值不变。

数值转换

数值转换过程中，值可能会发生改变。

注意

数值提升优先于数值转换。如 bool->int 时是数值提升而非数值转换。

整数转换

• 如果目标类型为位宽为 的无符号整数类型，则转换结果是原值 后的结果。

  • 若目标类型位宽大于源类型位宽：

    • 若源类型为有符号类型，一般情况下需先进行符号位扩展再转换。

      如

      • 将 (short)-1（(short)0b1111'1111'1111'1111）转换为 unsigned int 类型时，先进行符号位扩展，得到 0b1111'1111'1111'1111'1111'1111'1111'1111，再进行整数转换，结果为 (unsigned int)4'294'967'295（(unsigned int)0b1111'1111'1111'1111'1111'1111'1111'1111）。
      • 将 (short)32'767（(short)0b0111'1111'1111'1111）转换为 unsigned int 类型时，先进行符号位扩展，得到 0b0000'0000'0000'0000'0111'1111'1111'1111，再进行整数转换，结果为 (unsigned int)32'767（(unsigned int)0b0000'0000'0000'0000'0111'1111'1111'1111）。

    • 若源类型为无符号类型，则需先进行零扩展再转换。

      如将 (unsigned short)65'535（(unsigned short)0b1111'1111'1111'1111）转换为 unsigned int 类型时，先进行零扩展，得到 0b0000'0000'0000'0000'1111'1111'1111'1111，再进行整数转换，结果为 (unsigned int)65'535（(unsigned int)0b0000'0000'0000'0000'1111'1111'1111'1111）。

  • 若目标类型位宽不大于源类型位宽，则需先截断再转换。

    如将 (unsigned int)4'294'967'295（(unsigned int)0b1111'1111'1111'1111'1111'1111'1111'1111）转换为 unsigned short 类型时，先进行截断，得到 0b1111'1111'1111'1111，再进行整数转换，结果为 (unsigned short)65'535（(unsigned short)0b1111'1111'1111'1111）。

• 如果目标类型为位宽为 的带符号整数类型，则 一般情况下，转换结果可以认为是原值 后的结果。4

  例如将 (unsigned int)4'294'967'295（(unsigned int)0b1111'1111'1111'1111'1111'1111'1111'1111）转换为 short 类型时，结果为 (short)-1（(short)0b1111'1111'1111'1111）。

• 如果目标类型是 bool，则是 布尔转换。

• 如果源类型是 bool，则 false 转为对应类型的 0，true 转为对应类型的 1。

浮点转换

位宽较大的浮点数转换为位宽较小的浮点数，会将该数舍入到目标类型下最接近的值。

浮点整数转换

• 浮点数转换为整数时，会舍弃浮点数的全部小数部分。

  如果目标类型是 bool，则是 布尔转换。

• 整数转换为浮点数时，会舍入到目标类型下最接近的值。

  如果该值不能适应到目标类型中，那么行为未定义。

  如果源类型是 bool，那么 false 转换为零，而 true 转换为一。

布尔转换

将其他类型转换为 bool 类型时，零值转换为 false，非零值转换为 true。

定义变量

简单地说5，定义一个变量，需要包含类型说明符（指明变量的类型），以及要定义的变量名。

例如，下面这几条语句都是变量定义语句。

int oi;
double wiki;
char org = 'c';

在目前我们所接触到的程序段中，定义在花括号包裹的地方的变量是局部变量，而定义在没有花括号包裹的地方的变量是全局变量。实际有例外，但是现在不必了解。

定义时没有初始化值的全局变量会被初始化为 。而局部变量没有这种特性，需要手动赋初始值，否则可能引起难以发现的 bug。

变量作用域

作用域是变量可以发挥作用的代码块。

全局变量的作用域，自其定义之处开始6，至文件结束位置为止。

局部变量的作用域，自其定义之处开始，至代码块结束位置为止。

由一对大括号括起来的若干语句构成一个代码块。

int g = 20;  // 定义全局变量
 
int main() {
  int g = 10;         // 定义局部变量
  printf("%d\n", g);  // 输出 g
  return 0;
}

如果一个代码块的内嵌块中定义了相同变量名的变量，则内层块中将无法访问外层块中相同变量名的变量。

例如上面的代码中，输出的 的值将是 。因此为了防止出现意料之外的错误，请尽量避免局部变量与全局变量重名的情况。

常量

常量是固定值，在程序执行期间不会改变。

常量的值在定义后不能被修改。定义时加一个 const 关键字即可。

const int a = 2;
a = 3;

如果修改了常量的值，在编译环节就会报错：error: assignment of read-only variable‘a’。

可以在编译的时候通过 -DLINUX 来控制编译出的代码，而无需修改源文件。这还有一个优点：通过 -DLINUX 编译出的可执行文件里并没有其他操作系统的代码，那些代码在预处理的时候就已经被删除了。

#define 还能使用 #、## 运算符，极大地方便调试。

运算

算术运算符

单目与双目运算符

算术运算符中有两个单目运算符（正、负）以及五个双目运算符（乘法、除法、取模、加法、减法），其中单目运算符的优先级最高。

其中取模运算符 % 意为计算两个整数相除得到的余数，即求余数。

而 - 为双目运算符时做减法运算符，如 2-1 ；为单目运算符时做负值运算符，如 -1 。

使用方法如下

op=x-y*z

得到的 op 的运算值遵循数学中加减乘除的优先规律，首先进行优先级高的运算，同优先级自左向右运算，括号提高优先级。

算术运算中的类型转换

对于双目算术运算符，当参与运算的两个变量类型相同时，不发生 类型转换 ，运算结果将会用参与运算的变量的类型容纳，否则会发生类型转换，以使两个变量的类型一致。

转换的规则如下：

• 先将 char ， bool ， short 等类型提升至 int （或 unsigned int ，取决于原类型的符号性）类型；
• 若存在一个变量类型为 long double ，会将另一变量转换为 long double 类型；
• 否则，若存在一个变量类型为 double ，会将另一变量转换为 double 类型；
• 否则，若存在一个变量类型为 float ，会将另一变量转换为 float 类型；
• 否则（即参与运算的两个变量均为整数类型）：
  • 若两个变量符号性一致，则将位宽较小的类型转换为位宽较大的类型；
  • 否则，若无符号变量的位宽不小于带符号变量的位宽，则将带符号数转换为无符号数对应的类型；
  • 否则，若带符号操作数的类型能表示无符号操作数类型的所有值，则将无符号操作数转换为带符号操作数对应的类型；
  • 否则，将带符号数转换为相对应的无符号类型。

例如，对于一个整型（ int ）变量 和另一个双精度浮点型（ double ）类型变量 ：

• x/3 的结果将会是整型；
• x/3.0 的结果将会是双精度浮点型；
• x/y 的结果将会是双精度浮点型；
• x*1/3 的结果将会是整型；
• x*1.0/3 的结果将会是双精度浮点型；

位运算符

位操作的意义请参考 位运算 页面。需要注意的是，位运算符的优先级低于普通的算数运算符。

自增/自减 运算符

有时我们需要让变量进行增加 1（自增）或者减少 1（自减），这时自增运算符 ++ 和自减运算符 -- 就派上用场了。

自增/自减运算符可放在变量前或变量后面，在变量前称为前缀，在变量后称为后缀，单独使用时前缀后缀无需特别区别，如果需要用到表达式的值则需注意，具体可看下面的例子。详细情况可参考 引用 介绍的例子部分。

i = 100;
 
op1 = i++;  // op1 = 100，先 op1 = i，然后 i = i + 1
 
i = 100;
 
op2 = ++i;  // op2 = 101，先 i = i + 1，然后赋值 op2
 
i = 100;
 
op3 = i--;  // op3 = 100，先赋值 op3，然后 i = i - 1
 
i = 100;
 
op4 = --i;  // op4 = 99，先 i = i - 1，然后赋值 op4

复合赋值运算符

复合赋值运算符实际上是表达式的缩写形式。可分为复合算术运算符 +=、-=、*=、/=、%= 和复合位运算符 &=、|=、^=、<<=、>>=。

例如，op = op + 2 可写为 op += 2，op = op - 2 可写为 op -= 2，op= op * 2 可写为 op *= 2。

条件运算符

条件运算符可以看作 if 语句的简写，a ? b : c 中如果表达式 a 成立，那么这个条件表达式的结果是 b，否则条件表达式的结果是 c。

比较运算符

其中特别需要注意的是要将等于运算符 == 和赋值运算符 = 区分开来，这在判断语句中尤为重要。

if (op=1) 与 if (op==1) 看起来类似，但实际功能却相差甚远。第一条语句是在对 op 进行赋值，若赋值为非 0 时为真值，表达式的条件始终是满足的，无法达到判断的作用；而第二条语句才是对 op 的值进行判断。

逻辑运算符

Result = op1 && op2;  // 当 op1 与 op2 都为真时则 Result 为真
 
Result = op1 || op2;  // 当 op1 或 op2 其中一个为真时则 Result 为真
 
Result = !op1;  // 当 op1 为假时则 Result 为真

逗号运算符

逗号运算符可将多个表达式分隔开来，被分隔开的表达式按从左至右的顺序依次计算，整个表达式的值是最后的表达式的值。逗号表达式的优先级在所有运算符中的优先级是 最低 的。

exp1, exp2, exp3;  // 最后的值为 exp3 的运算结果。
 
Result = 1 + 2, 3 + 4, 5 + 6;
//得到 Result 的值为 3 而不是 11，因为赋值运算符 "="
//的优先级比逗号运算符高，先进行了赋值运算才进行逗号运算。
 
Result = (1 + 2, 3 + 4, 5 + 6);
 
// 若要让 Result 的值得到逗号运算的结果则应将整个表达式用括号提高优先级，此时
// Result 的值才为 11。

成员访问运算符

这些运算符用来访问对象的成员或者内存，除了最后一个运算符外上述运算符都可被重载。与 & ， * 和 -> 相关的内容请阅读 指针 和 引用 教程。这里还省略了两个很少用到的运算符 .* 和 ->* ，其具体用法可以参见 C++ 语言手册 。

auto result1 = v[1];  // 获取v中下标为2的对象
auto result2 = p.q;   // 获取p对象的q成员
auto result3 = p -> q;  // 获取p指针指向的对象的q成员，等价于 (*p).q
auto result4 = &v;      // 获取指向v的指针
auto result5 = *v;      // 获取v指针指向的对象

C++ 运算符优先级总表

来自 C++ 运算符优先级 - cppreference ，有修改。

需要注意的是，表中并未列出 const_cast、static_cast、dynamic_cast、reinterpret_cast、typeid、sizeof...、noexcept 及 alignof 等运算符，因为它们的使用形式与函数调用相同，不会出现歧义。

分支

一个程序默认是按照代码的顺序执行下来的，有时我们需要选择性的执行某些语句，这时候就需要分支的功能来实现。选择合适的分支语句可以提高程序的效率。

if 语句

基本 if 语句

以下是基本 if 语句的结构。

if (条件) {
  主体;
}

if 语句通过对条件进行求值，若结果为真（非 0），执行语句，否则不执行。

如果主体中只有单个语句的话，花括号可以省略。

if...else 语句

if (条件) {
  主体1;
} else {
  主体2;
}

if...else 语句和 if 语句类似，else 不需要再写条件。当 if 语句的条件满足时会执行 if 里的语句，if 语句的条件不满足时会执行 else 里的语句。同样，当主体只有一条语句时，可以省略花括号。

else if 语句

if (条件1) {
  主体1;
} else if (条件2) {
  主体2;
} else if (条件3) {
  主体3;
} else {
  主体4;
}

else if 语句是 if 和 else 的组合，对多个条件进行判断并选择不同的语句分支。在最后一条的 else 语句不需要再写条件。例如，若条件 1 为真，执行主体 1，条件 3 为真而条件 1 和条件 2 都为假，执行主体 3，所有的条件都为假才执行主体 4。

实际上，这一个语句相当于第一个 if 的 else 分句只有一个 if 语句，就将花括号省略之后放在一起了。如果条件相互之间是并列关系，这样写可以让代码的逻辑更清晰。

在逻辑上，大约相当于这一段话：

解一元二次方程的时候，方程的根与判别式的关系：

• 如果 () 方程无解；
• 否则，如果 () 方程有两个相同的实数解；
• 否则 方程有两个不相同的实数解；

switch 语句

switch (选择句) {
  case 标签1:
    主体1;
  case 标签2:
    主体2;
  default:
    主体3;
}

switch 语句执行时，先求出选择句的值，然后根据选择句的值选择相应的标签，从标签处开始执行。其中，选择句必须是一个整数类型表达式，而标签都必须是整数类型的常量。例如：

int i = 1;  // 这里的 i 的数据类型是整型 ，满足整数类型的表达式的要求
 
switch (i) {
  case 1:
    cout << "OI WIKI" << endl;
}

char i = 'A';
 
// 这里的 i 的数据类型是字符型 ，但 char
// 也是属于整数的类型，满足整数类型的表达式的要求
switch (i) {
  case 'A':
    cout << "OI WIKI" << endl;
}

switch 语句中还要根据需求加入 break 语句进行中断，否则在对应的 case 被选择之后接下来的所有 case 里的语句和 default 里的语句都会被运行。具体例子可看下面的示例。

char i = 'B';
 
switch (i) {
  case 'A':
    cout << "OI" << endl;
    break;
 
  case 'B':
    cout << "WIKI" << endl;
 
  default:
    cout << "Hello World" << endl;
}

以上代码运行后输出的结果为 WIKI 和 Hello World，如果不想让下面分支的语句被运行就需要 break 了，具体例子可看下面的示例。

char i = 'B';
 
switch (i) {
  case 'A':
    cout << "OI" << endl;
    break;
 
  case 'B':
    cout << "WIKI" << endl;
    break;
 
  default:
    cout << "Hello World" << endl;
}

以上代码运行后输出的结果为 WIKI，因为 break 的存在，接下来的语句就不会继续被执行了。最后一个语句不需要 break，因为下面没有语句了。

处理入口编号不能重复，但可以颠倒。也就是说，入口编号的顺序不重要。各个 case（包括 default）的出现次序可任意。例如：

char i = 'B';
 
switch (i) {
  case 'B':
    cout << "WIKI" << endl;
    break;
 
  default:
    cout << "Hello World" << endl;
    break;
 
  case 'A':
    cout << "OI" << endl;
}

switch 的 case 分句中也可以选择性的加花括号。不过要注意的是，如果需要在 switch 语句中定义变量，花括号是必须要加的。例如：

char i = 'B';
 
switch (i) {
  case 'A': {
    int i = 1, j = 2;
    cout << "OI" << endl;
    ans = i + j;
    break;
  }
 
  case 'B': {
    int qwq = 3;
    cout << "WIKI" << endl;
    ans = qwq * qwq;
    break;
  }
 
  default: {
    cout << "Hello World" << endl;
  }
}

循环

有时，我们需要做一件事很多遍，为了不写过多重复的代码，我们需要循环。

有时，循环的次数不是一个常量，那么我们无法将代码重复多遍，必须使用循环。

for 语句

以下是 for 语句的结构：

for (初始化; 判断条件; 更新) {
  循环体;
}

执行顺序：

e.g. 读入 n 个数：

for (int i = 1; i <= n; ++i) {
  cin >> a[i];
}

for 语句的三个部分中，任何一个部分都可以省略。其中，若省略了判断条件，相当于判断条件永远为真。

while 语句

以下是 while 语句的结构：

while (判断条件) {
  循环体;
}

执行顺序：

e.g. 验证 3x+1 猜想：

while (x > 1) {
  if (x % 2 == 1) {
    x = 3 * x + 1;
  } else {
    x = x / 2;
  }
}

do...while 语句

以下是 do...while 语句的结构：

do {
  循环体;
} while (判断条件);

执行顺序：

与 while 语句的区别在于，do...while 语句是先执行循环体再进行判断的。

e.g. 枚举排列：

do {
  // do someting...
} while (next_permutation(a + 1, a + n + 1));

三种语句的联系

// for 语句
 
for (statement1; statement2; statement3) {
  statement4;
}
 
// while 语句
 
statement1;
while (statement2) {
  statement4;
  statement3;
}

在 statement4 中没有 continue 语句（见下文）的时候是等价的，但是下面一种方法很少用到。

// while 语句
 
statement1;
while (statement2) {
  statement1;
}
 
// do...while 语句
 
do {
  statement1;
} while (statement2);

在 statement1 中没有 continue 语句的时候这两种方式也也是等价的。

while (1) {
  // do something...
}
 
for (;;) {
  // do something...
}

这两种方式都是永远循环下去。（可以使用 break（见下文）退出。）

可以看出，三种语句可以彼此代替，但一般来说，语句的选用遵守以下原则：

1. 循环过程中有个固定的增加步骤（最常见的是枚举）时，使用 for 语句；
2. 只确定循环的终止条件时，使用 while 语句；
3. 使用 while 语句时，若要先执行循环体再进行判断，使用 do...while 语句。一般很少用到，常用场景是用户输入。

break 与 continue 语句

break 语句的作用是退出循环。

continue 语句的作用是跳过循环体的余下部分。下面以 continue 语句在 do...while 语句中的使用为例：

do {
  // do something...
  continue;  // 等价于 goto END;
// do something...
END:;
} while (statement);

break 与 continue 语句均可在三种循环语句的循环体中使用。

一般来说，break 与 continue 语句用于让代码的逻辑更加清晰，例如：

// 逻辑较为不清晰，大括号层次复杂
 
for (int i = 1; i <= n; ++i) {
  if (i != x) {
    for (int j = 1; j <= n; ++j) {
      if (j != x) {
        // do something...
      }
    }
  }
}
 
// 逻辑更加清晰，大括号层次简单明了
 
for (int i = 1; i <= n; ++i) {
  if (i == x) continue;
  for (int j = 1; j <= n; ++j) {
    if (j == x) continue;
    // do something...
  }
}

// for 语句判断条件复杂，没有体现「枚举」的本质
 
for (int i = l; i <= r && i % 10 != 0; ++i) {
  // do something...
}
 
// for 语句用于枚举，break 用于「到何时为止」
 
for (int i = l; i <= r; ++i) {
  if (i % 10 == 0) break;
  // do something...
}

// 语句重复，顺序不自然
 
statement1;
while (statement3) {
  statement2;
  statement1;
}
 
// 没有重复语句，顺序自然
 
while (1) {
  statement1;
  if (!statement3) break;
  statement2;
}

函数

函数的声明

编程中的函数（function）一般是若干语句的集合。我们也可以将其称作「子过程（subroutine）」。在编程中，如果有一些重复的过程，我们可以将其提取出来，形成一个函数。函数可以接收若干值，这叫做函数的参数。函数也可以返回某个值，这叫做函数的返回值。

声明一个函数，我们需要返回值类型、函数的名称，以及参数列表。

// 返回值类型 int
// 函数的名称 some_function
// 参数列表 int, int
int some_function(int, int);

如上图，我们声明了一个名为 some_function 的函数，它需要接收两个 int 类型的参数，返回值类型也为 int。可以认为，这个函数将会对传入的两个整数进行一些操作，并且返回一个同样类型的结果。

实现函数：编写函数的定义

只有函数的声明（declaration）还不够，他只能让我们在调用时能够得知函数的 接口 类型（即接收什么数据、返回什么数据），但其缺乏具体的内部实现，也就是函数的 定义（definition）。我们可以在 声明之后的其他地方 编写代码 实现（implement）这个函数（也可以在另外的文件中实现，但是需要将分别编译后的文件在链接时一并给出）。

如果函数有返回值，则需要通过 return 语句，将值返回给调用方。函数一旦执行到 return 语句，则直接结束当前函数，不再执行后续的语句。

int some_function(int, int);  // 声明
 
/* some other code here... */
 
int some_function(int x, int y) {  // 定义
  int result = 2 * x + y;
  return result;
  result = 3;  // 这条语句不会被执行
}

在定义时，我们给函数的参数列表的变量起了名字。这样，我们便可以在函数定义中使用这些变量了。

如果是同一个文件中，我们也可以直接将 声明和定义合并在一起，换句话说，也就是在声明时就完成定义。

int some_function(int x, int y) { return 2 * x + y; }

如果函数不需要有返回值，则将函数的返回值类型标为 void；如果函数不需要参数，则可以将参数列表置空。同样，无返回值的函数执行到 return; 语句也会结束执行。

void say_hello() {
  cout << "hello!\n";
  cout << "hello!\n";
  cout << "hello!\n";
  return;
  cout << "hello!\n";  // 这条语句不会被执行
}

函数的调用

和变量一样，函数需要先被声明，才能使用。使用函数的行为，叫做「调用（call）」。我们可以在任何函数内部调用其他函数，包括这个函数自身。函数调用自身的行为，称为 递归（recursion）。

在大多数语言中，调用函数的写法，是 函数名称加上一对括号 ()，如 foo()。如果函数需要参数，则我们将其需要的参数按顺序填写在括号中，以逗号间隔，如 foo(1, 2)。函数的调用也是一个表达式，函数的返回值 就是 表达式的值。

函数声明时候写出的参数，可以理解为在函数 当前次调用的内部 可以使用的变量，这些变量的值由调用处传入的值初始化。看下面这个例子：

void foo(int, int);
 
/* ... */
 
void foo(int x, int y) {
  x = x * 2;
  y = y + 3;
}
 
/* ... */
 
a = 1;
b = 1;
// 调用前：a = 1, b = 1
foo(a, b);  // 调用 foo
            // 调用后：a = 1, b = 1

在上面的例子中，foo(a, b) 是一次对 foo 的调用。调用时，foo 中的 x 和 y 变量，分别由调用处 a 和 b 的值初始化。因此，在 foo 中对变量 x 和 y 的修改，并不会影响到调用处的变量的值。

如果我们需要在函数（子过程）中修改变量的值，则需要采用「传引用」的方式。

void foo(int& x, int& y) {
  x = x * 2;
  y = y + 3;
}
 
/* ... */
 
a = 1;
b = 1;
// 调用前：a = 1, b = 1
foo(a, b);  // 调用 foo
            // 调用后：a = 2, b = 4

上述代码中，我们看到函数参数列表中的「int」后面添加了一个「&（and 符号）」，这表示对于 int 类型的 引用（reference）。在调用 foo 时，调用处 a 和 b 变量分别初始化了 foo 中两个对 int 类型的引用 x 和 y。在 foo 中的 x 和 y，可以理解为调用处 a 和 b 变量的「别名」，即 foo 中对 x 和 y 的操作，就是对调用处 a 和 b 的操作。

main 函数

特别的，每个 C/C++ 程序都需要有一个名为 main 的函数。任何程序都将从 main 函数开始运行。

main 函数也可以有参数，通过 main 函数的参数，我们可以获得外界传给这个程序的指令（也就是「命令行参数」），以便做出不同的反应。

下面是一段调用了函数（子过程）的代码：

// hello_subroutine.cpp
 
#include <iostream>
 
void say_hello() {
  std::cout << "hello!\n";
  std::cout << "hello!\n";
  std::cout << "hello!\n";
}
 
int main() {
  say_hello();
  say_hello();
}

c++进阶

类

类（class）是结构体的拓展，不仅能够拥有成员元素，还拥有成员函数。

在面向对象编程（OOP）中，对象就是类的实例，也就是变量。

C++ 中 struct 关键字定义的也是类，上文中的 结构体 的定义来自 C。因为某些历史原因，C++ 保留并拓展了 struct。

定义类

类使用关键字 class 或者 struct 定义，下文以 class 举例。

class ClassName {
  ...
};
 
// Example:
class Object {
 public:
  int weight;
  int value;
} e[array_length];
 
const Object a;
Object b, B[array_length];
Object *c;

与使用 struct 大同小异。该例定义了一个名为 Object 的类。该类拥有两个成员元素，分别为 weight,value；并在 } 后使用该类型定义了一个数组 e。

定义类的指针形同 struct。

访问说明符

不同于 struct 中的举例，本例中出现了 public，这属于访问说明符。

• public：该访问说明符之后的各个成员都可以被公开访问，简单来说就是无论 类内 还是 类外 都可以访问。
• protected：该访问说明符之后的各个成员可以被 类内、派生类或者友元的成员访问，但类外 不能访问。
• private：该访问说明符之后的各个成员 只能 被 类内 成员或者友元的成员访问，不能 被从类外或者派生类中访问。

对于 struct，它的所有成员都是默认 public。对于 class，它的所有成员都是默认 private。

关于 "友元" 和 "派生类"，可以参考下方折叠框，或者查询网络资料进行详细了解。

对于算法竞赛来说，友元和派生类并不是必须要掌握的知识点。

关于友元以及派生类的基本概念

访问与修改成员元素的值

方法形同 struct

• 对于变量，使用 . 符号。
• 对于指针，使用 -> 符号。

成员函数

成员函数，顾名思义。就是类中所包含的函数。

常见成员函数举例

class Class_Name {
  ... type Function_Name(...) { ... }
};
 
// Example:
class Object {
 public:
  int weight;
  int value;
 
  void print() {
    cout << weight << endl;
    return;
  }
 
  void change_w(int);
};
 
void Object::change_w(int _weight) { weight = _weight; }
 
Object var;

该类有一个打印 Object 成员元素的函数，以及更改成员元素 weight 的函数。

和函数类似，对于成员函数，也可以先声明，在定义，如第十四行（声明处）以及十七行后（定义处）。

如果想要调用 var 的 print 成员函数，可以使用 var.print() 进行调用。

重载运算符

何为重载

重载运算符，可以部分程度上代替函数，简化代码。

下面给出重载运算符的例子。

class Vector {
 public:
  int x, y;
 
  Vector() : x(0), y(0) {}
 
  Vector(int _x, int _y) : x(_x), y(_y) {}
 
  int operator*(const Vector& other) { return x * other.x + y * other.y; }
 
  Vector operator+(const Vector&);
  Vector operator-(const Vector&);
};
 
Vector Vector::operator+(const Vector& other) {
  return Vector(x + other.x, y + other.y);
}
 
Vector Vector::operator-(const Vector& other) {
  return Vector(x - other.x, y - other.y);
}
 
// 关于4,5行表示为x,y赋值，具体实现参见后文。

该例定义了一个向量类，并重载了 * + - 运算符，并分别代表向量内积，向量加，向量减。

重载运算符的模板大致可分为下面几部分。

/*类定义内重载*/ 返回类型 operator符号(参数){...}
 
/*类定义内声明，在外部定义*/ 返回类型 类名称::operator符号(参数){...}

对于自定义的类，如果重载了某些运算符（一般来说只需要重载 < 这个比较运算符），便可以使用相应的 STL 容器或算法，如 sort。

如要了解更多，参见「参考资料」第四条。

可以被重载的运算符

在实例化变量时设定初始值

为完成这种操作，需要定义 默认构造函数(Default constructor)。

class ClassName {
  ... ClassName(...)... { ... }
};
 
// Example:
class Object {
 public:
  int weight;
  int value;
 
  Object() {
    weight = 0;
    value = 0;
  }
};

该例定义了 Object 的默认构造函数，该函数能够在我们实例化 Object 类型变量时，将所有的成员元素初始化为 0。

若无显式的构造函数，则编译器认为该类有隐式的默认构造函数。换言之，若无定义任何构造函数，则编译器会自动生成一个默认构造函数，并会根据成员元素的类型进行初始化（与定义 内置类型 变量相同）。

在这种情况下，成员元素都是未初始化的，访问未初始化的变量的结果是未定义的（也就是说并不知道会返回和值）。

如果需要自定义初始化的值，可以再定义（或重载）构造函数。

关于定义（或重载）构造函数

使用 C++11 或以上时，可以使用 {} 进行变量的初始化。

关于 {}

class Object {
 public:
  int weight;
  int value;
 
  Object() {
    weight = 0;
    value = 0;
  }
 
  Object(int _weight = 0, int _value = 0) {
    weight = _weight;
    value = _value;
  }
 
  // the same as
  // Object(int _weight,int _value):weight(_weight),value(_value) {}
};
 
// the same as
// Object::Object(int _weight,int _value){
//   weight = _weight;
//   value = _value;
// }
//}
 
Object A;        // ok
Object B(1, 2);  // ok
Object C{1, 2};  // ok,(C++11)

关于隐式类型转换

销毁

这是不可避免的问题。每一个变量都将在作用范围结束走向销毁。

但对于已经指向了动态申请的内存的指针来说，该指针在销毁时不会自动释放所指向的内存，需要手动释放动态内存。

如果结构体的成员元素包含指针，同样会遇到这种问题。需要用到析构函数来手动释放动态内存。

析构 函数（Destructor）将会在该变量被销毁时被调用。重载的方法形同构造函数，但需要在前加 ~

默认定义的析构函数通常对于算法竞赛已经足够使用，通常我们只有在成员元素包含指针时才会重载析构函数。

class Object {
 public:
  int weight;
  int value;
  int* ned;
  Object() {
    weight = 0;
    value = 0;
  }
 
  ~Object() { delete ned; }
};

为类变量赋值

默认情况下，赋值时会按照对应成员元素赋值的规则进行。也可以使用 类名称() 或 类名称{} 作为临时变量来进行赋值。

前者只是调用了复制构造函数（copy constructor），而后者在调用复制构造函数前会调用默认构造函数。

另外默认情况下，进行的赋值都是对应元素间进行 浅拷贝，如果成员元素中有指针，则在赋值完成后，两个变量的成员指针具有相同的地址。

// A,tmp1,tmp2,tmp3类型为Object
tmp1 = A;
tmp2 = Object(...);
tmp3 = {...};

如需解决指针问题或更多操作，需要重载相应的构造函数。

更多 构造函数（constructor）内容，参见「参考资料」第六条。

参考资料

1. cppreference class
2. cppreference access
3. cppreference default_constructor
4. cppreference operator
5. cplusplus Data structures
6. cplusplus Special members
7. C++11 FAQ
8. cppreference Friendship and inheritance
9. cppreference value initialization

命名空间

概述

C++ 的 命名空间 机制可以用来解决复杂项目中名字冲突的问题。

举个例子：C++ 标准库的所有内容均定义在 std 命名空间中，如果你定义了一个叫 cin 的变量，则可以通过 cin 来访问你定义的 cin 变量，通过 std::cin 访问标准库的 cin 对象，而不用担心产生冲突。

声明

下面的代码声明了一个名字叫 A 的命名空间：

namespace A {
int cnt;
 
void f(int x) { cnt = x; }
}  // namespace A

声明之后，在这个命名空间外部，你可以通过 A::f(x) 来访问命名空间 A 内部的 f 函数。

命名空间的声明是可以嵌套的，因此下面这段代码也是允许的：

namespace A {
namespace B {
void f() { ... }
}  // namespace B
 
void f() {
  B::f();  // 实际访问的是 A::B::f()，由于当前位于命名空间 A
           // 内，所以可以省略前面的 A::
}
}  // namespace A
 
void f()  // 这里定义的是全局命名空间的 f 函数，与 A::f 和 A::B::f
          // 都不会产生冲突
{
  A::f();
  A::B::f();
}

using 指令

声明了命名空间之后，如果在命名空间外部访问命名空间内部的成员，需要在成员名前面加上 命名空间::。

有没有什么比较方便的方法能让我们直接通过成员名访问命名空间内的成员呢？答案是肯定的。我们可以使用 using 指令。

using 指令有如下两种形式：

1. using 命名空间::成员名;：这条指令可以让我们省略某个成员名前的命名空间，直接通过成员名访问成员，相当于将这个成员导入了当前的作用域。
2. using namespace 命名空间;：这条指令可以直接通过成员名访问命名空间中的 任何 成员，相当于将这个命名空间的所有成员导入了当前的作用域。

因此，如果执行了 using namespace std;，就会将 std 中的所有名字引入到全局命名空间当中。这样，我们就可以用 cin 代替 std::cin，用 cout 代替 std::cout。

using 指令可能会导致命名冲突！

有了 using 指令，C++ 语法基础 中的代码可以有这两种等价写法：

#include <iostream>
 
using std::cin;
using std::cout;
using std::endl;
 
int main() {
  int x, y;
  cin >> x >> y;
  cout << y << endl << x;
  return 0;
}

#include <iostream>
 
using namespace std;
 
int main() {
  int x, y;
  cin >> x >> y;
  cout << y << endl << x;
  return 0;
}

应用

在一些具有多个子任务的问题中，我们可以对每个子任务各开一个命名空间，在其中定义我们解决该子任务所需要的变量与函数，这样各个子任务间互不干扰，会在一定程度上方便调试，也会改善程序的可读性。

值类别

注意：这部分的内容很可能对算法竞赛无用，但如果你希望更深入地理解 C++，写出更高效的代码，那么本文的内容也许会对你有所帮助。

每个 C++ 表达式都有两个属性：类型 (type) 和值类别 (value category)。前者是大家都熟悉的，但作为算法竞赛选手，很可能完全不知道后者是什么。不管你在不在意，值类别是 C++ 中非常重要的一个概念。

关于名词的翻译

type 和 category 都可以翻译为「类型」或「类别」，但为了区分两者，下文中统一将 type 翻译为「类型」，category 翻译为「类别」。

从 CPL 语言的定义说起

左值与右值的概念最早出现在 C 语言的祖先语言：CPL。

在 CPL 的定义中，lvalue 意为 left-hand side value，即能够出现在赋值运算符（等号）左侧的值，右值的定义亦然。

C 和 C++11 以前

C 语言沿用了相似的分类方法，但左右值的判断标准已经与赋值运算符无关。在新的定义中，lvalue 意为 locate value，即能进行取地址运算 (&) 的值。

可以这么理解：左值是有内存地址的对象，而右值只是一个中间计算结果（虽然编译器往往需要在内存中分配地址来储存这个值，但这个内存地址是无法被程序员感知的，所以可以认为它不存在）。中间计算结果就意味着这个值马上就没用了，以后不会再访问它。

比如在 int a = 0; 这段代码中，a 就是一个左值，而 0 是一个右值。

常见的关于左右值的误解

以下几种类型是经常被误认为右值的左值：

• 字符串字面量：由于 C++ 兼容 C 风格的字符串，需要能对一个字符串字面量取地址（即头指针）来传参。但是其他的字面量，包括自定义字面量，都是右值。
• 数组：数组名就是数组首个元素的指针这种说法似乎误导了很多人，但这个说法显然是错误的，对数组进行取地址是可以编译的。数组名可以隐式的退化成首个元素的指针，这才是右值。

C++11 开始

从 C++11 开始，为了配合移动语义，值的类别就不是左值右值这么简单了。

考虑一个简单的场景：

std::vector<int> a{...};
std::vector<int> b;
b = a;

我们知道第三行的赋值运算复杂度是正比于 a 的长度的，复制的开销很大。但有些情况下，比如 a 在以后的代码中不会再使用，那么我们完全可以把 a 所持有的内存「转移」到 b 上，这就是移动语义干的事情。

我们姑且不管移动是怎么实现的，先来考虑一下我们如何标记 a 是可以移动的。显然不管能否移动，这个表达式的类型都是 vector 不变，所以只能对值类别下手。不可移动的 a 是左值，如果要在原有的体系下标记可以移动的 a，我们只能把它标记为右值。但标记为右值又是不合理的，因为这个 a 实际上拥有自己的内存地址，与其他右值有有根本上的不同。所以 C++11 引入了 亡值 (xvalue) 这一值类别来标记这一种表达式。

于是我们现在有了三种类别：左值 (lvalue)、纯右值 (prvalue)、亡值 (xvalue)（纯右值就是原先的右值）。

然后我们发现亡值同时具有一些左值和纯右值的性质，比如它可以像左值一样取地址，又像右值一样不会再被访问。

所以又有了两种组合类别：泛左值 (glvalue)（左值和亡值）、右值 (rvalue)（纯右值和亡值）。

有一个初步的感性理解后，来看一下标准委员会对它们的定义：

• A glvalue(generalized lvalue) is an expression whose evaluation determines the identity of an object, bit-field, or function.
• A prvalue(pure rvalue) is an expression whose evaluation initializes an object or a bit-field, or computes the value of an operand of an operator, as specified by the context in which it appears, or an expression that has type cv void.
• An xvalue(eXpiring value) is a glvalue that denotes an object or bit-field whose resources can be reused（usually because it is near the end of its lifetime）。
• An lvalue is a glvalue that is not an xvalue.
• An rvalue is a prvalue or an xvalue.

上述定义中提到了一个叫位域 (bit-field) 的东西。如果你不知道位域是什么，忽略它即可，后文也不会提及。

其中关键的两个概念：

• 是否拥有身份 (identity)：可以确定表达式是否与另一表达式指代同一实体，例如比较它们所标识的对象或函数的（直接或间接获得的）地址
• 是否可以被移动 (resources can be reused)：对象的资源可以移动到别的对象中

这 5 种类型无非就是根据上面两种属性的是与否区分的，所以用下面的这张表格可以帮助理解：

注意不拥有身份就意味着这个对象以后无法被访问，这样的对象显然是可以被移动的，所以不存在不拥有身份不可移动的值。

C++17 带来的新变化

从拷贝到移动提升了不少速度，那么我们是否能够优化的更彻底一点，把移动的开销都省去呢？

考虑这样的代码：

std::vector<int> make_vector(...) {
  std::vector<int> result;
  // ...
  return result;
}
 
std::vector<int> a = make_vector(...);

make_vector 函数根据一输入生成一个 vector。这个 vector 一开始在 make_vector 的栈上被构造，随后又被移动到调用者的栈上，需要一次移动操作，这显然很浪费，能不能省略这次移动？

答案是肯定的，这就是 RVO 优化，即省略拷贝。通常的方法是编译器让 make_vector 返回的对象直接在调用者的栈上构造，然后 make_vector 在上面进行修改。这相当与这样的代码：