C/C++ 必要记忆知识点

常用简记

一、头文件(主要针对C++)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
//防止VS安全报错
#define _CRT_SECURE_NO_WARNINGS

//C++ 输入输出流
#include <iostream>
cin >> a;
cout <<  ...  << endl;

//C 方式输入输出流(包含文件流)
#include <stdio.h>
scanf("%d",&a);	printf("%d",a);
fopen(...);		fcolse(...);

//C++ 输出格式控制符
#include <iomanip>
cout << setw(5) << ...

//C++ 文件输入输出流
#include <fstream>
ifstream in("a.txt",ios::in);
ofstream out("b.txt",ios::out);

//字符数组处理函数库
#include <cstring>//C++
#include <string.h>//C 方式
strcpy(s1,s2);
strcmp(s1,s2);

//数学函数库
#include <cmath>//C++ 
#include <math.h>//C 方式
sqrt(x);
exp(10);	pow(2.717,10);
log(2.717);	log10(100);//分别以e、10为底
sin(x);		asin(x);
abs(n);		fabs(x);
floor(x);	ceil(x);//向下取整、向上取整


//控制台输入输出函数库
#include <conio.h>
getchar(ch);	_getche(ch);	_getch(ch);//等待、有回显；不等，有回显；不等、无回显
putchar(ch);
kbhit();//检查是否有键盘输入，有则非0，无则0

//时间函数库
#include <time.h>

//辅助函数库
#include <stdlib.h>//C 方式
#include <cstdlib>//C++
malloc(...);		free(...);//分配
srand(time(NULL));	rand();//随机数
exit(ret);			system(...);//系统
atof("3.14");		atoi("25");//转换。字符串->浮点数，并返回。字符串->整数，并返回。
itoa(25,str,16);//以16进制，把整数25转换到字符串中并返回

//字符类型函数库
#incldue <ctype.h>
isdigit(...);	isalpha(...);//是数字？是字母？是则返回非0，否则0
islower(...);	isupper(...);//是小写字母？是大写字母？是则返回非0，否则0
isalnum(...);	isxdigit(...);//数字字母？十六进制数？
isspace(...);	iscntrl(...);//white space?是DEL字符（0x7F）？
tolower(...);	toupper(...);//返回值转换大小写

//Windows基础函数库
#include <Window.h>
Sleep(100);//当前程序睡眠100ms

本文档开始

一、原码与补码

十进制数字 -> 补码

（1）取绝对值，转二进制 --> 原码

（2）正数： -->补码

​ 负数：取反+1 --> 补码

（0不论看作正还是负，最终都会得到补码为00000000 00000000，其中看作负数时由高位溢出得到）

例：

十进制数 取绝对值，转二进制：原码 正数不动，负数取反加一：补码
0 00000000 00000000 00000000 00000000
10 00000000 00001010 00000000 00001010
-10 00000000 00001010 11111111 11110110
32767 01111111 11111111 01111111 11111111
-32767 01111111 11111111 10000000 00000001
-32768 10000000 00000000 10000000 00000000

（1）计算机的整数均用补码表示

（2）可以发现，不论原码还是补码，开头第一位的数字都一定遵循：

​ 正数 0

​ 负数 1

​ 开头第一位称为”符号位“

二、各数据类型所占字节及表示范围

​ 以VS2022 x86/32bit 为基准：

类型 类型标识符 字节 数值范围 数值范围
整型 [signed] int 4 -2147483648 ~ +2147483647 -2^31^ ~ +2^31^-1
无符号整型 unsigned int 4 0 ~ +4294967295 0 ~ 2^32^-1
短整型 short [int] 2 -32768 ~ +32767 -2^15^ ~ +2^15^-1
无符号短整型 unsigned short [int] 2 0 ~ 65535 0 ~ 2^16^-1
长整型 long [int] 4 -2147483648 ~ +2147483647 -2^31^ ~ +2^31^-1
无符号长整型 unsigned long [int] 4 0 ~ 4294967295 0 ~ 2^32^-1
长长整型 long long [int] 8 -9223372036854775808 ~ +92…807 -2^63^ ~ +2^63^-1
无符号… unsigned long long [int] 8 0 ~ 18446744073709551616 0 ~ 2^64^-1
字符型 [signed] char 1 -128 ~ +127 -2^7^ ~ +2^7^-1
无符号字符型 unsigned char 1 0 ~ 255 0 ~ 2^8^-1
单精度型 float 4 -3.4×10^38^ ~ +3.4×10^38^
双精度型 double 8 -1.7×10^308^ ~ +1.7×10^308^
长双精度型 long double 8 -1.7×10^308^ ~ +1.7×10^308^

（1）求字节数：

​ sizeof( )

（2）头文件

1
2
#include <climits>  //头文件中有预置定义
cout << INT_MIN << endl;

（3）浮点数有 有效位数 的限定，可能存在一定的误差

三、常量

cout << typeid(123LU).name() << endl;

1、整型常量

  • 4种表示方法

二进制：0b + 0~1

八进制：0 + 0~7

十进制：正常

十六进制：0x/0X + 0~9, a~f, A~F

  • 缺省为int 型，其他可加后缀

123

123L 123l

123U 123u

123UL 123ul 123LU 123lu

2、浮点型常量

  • 仅可用十进制，但有 2 种形式
    • 十进制数（带小数点的数字）
    • 指数形式（科学计数法）
  • e 前 e 后
    • e 前：尾数部分，必须有数
    • e 后：指数部分，必须整数

​ 可：1.23e4 1.23e-4 -1.23e-4

​ 不可：e4 1.23e4.5

  • 浮点数在内存中的存储分三部分：符号位、指数部分、尾数部分

    • float 单精度：

      31：0/1 符号位

      23~30：8 bit 指数

      0~22：23 bit 尾数

    • double 双精度：

      63：0/1 符号位

      52~62：11 bit 指数

      0~51：52 bit 尾数

    img

  • 浮点数的存储遵从 IEEE 754 规范

  • 浮点数有指定有效位数（float：6位，double：15位）

    • 超出有效位数则舍去（四舍五入），因此会产生误差

      常量1：123456.7890123456e5

      常量2：123456.7890123457e5

      上述两个常量在内存中存储都是0.123456789012346e11

      1.0 / 3 * 3 = ?

  • 浮点常量缺省为double 型，如需表示为float 型，可加后缀 f/F

    • 1.23 ：double 型 8 字节
    • 1.23F ：float 型 4 字节
    • 可用 sizeof(1.23) 或 typeif(1.23).name() 验证

3、字符常量

  • ASCII 码占用 1 字节，共可表示 256 个字符

    0xxxxxxx ：基本ASCII 码 128 个（0~127）

    1xxxxxxx ：扩展ASCII 码 128 个（128~255）

  • 基本ASCII 码分为“图形字符”和”控制字符”

    0~32、127 ：控制字符，34个

    33~126 ：图形字符，94个

  • 几个基本的ASCII 码值

    空格 数字0 字母A 字母a
    32 48 65 97
    0x20 0x30 0x41 0x61

  • 汉字表示

    GBK ：2字节

  • 输出表示方法

    • 一般表示’ ’

      可放空格、大多可见图形字符

    • 转义符表示’\ ’

      放字符、八进制、十六进制数

      八进制：‘\ddd’ （三位）

      十六进制：‘\xhh’ （两位，x 必须小写）

  • 一个字符常量多种表达形式

    • A

      ‘A’ ‘\101’ ‘\x41’

    • ESC（ASCII = 27）

      ‘\33’ ‘\033’ ‘\x16’ ‘\x1B’

    • 换行（ASCII = 10）

      ‘\n’ ‘\12’ ‘\012’ ‘\xA’ ‘\xa’ ‘\x0A’ ‘\x0a’

    • 双引号（ASCII = 34）

      ’ \“ ’ ‘\42’ ‘\042’ ‘\x22’

  • ‘0’ 与 '\0’的区别

    • ‘0’ ：ASCII = 48 ‘\60’ ‘\060’ ‘\x30’
    • ‘\0’ ：ASCII = 0 ‘\00’ ‘\000’ ‘\x0’ ‘\x00’

  • 控制字符中，除空格外，都不能直接表示，\ ’ " 等特殊字符也不能直接表示

  • C/C++ 严格区分字符、字符串，不可用’ 汉’

    • 单引号：字符
    • 双引号：字符串

4、字符串常量

  • 连续多个字符组成的字符序列
    • “abc123*#”
    • “\x61\x62\x63\061\62\x2a\043”
    • “\r\n\t \ \ A \ \ t \x1b \ " \1234\xft\x2f\33”
  • 字符串常量方式可表示汉字"同济"
  • 字符串常量在内存中的存放：每个字符的ASCII 码 + 字符串结束标志’\0’
  • 数字0，ASCII = 48；尾零’\0’，ASCII = 0
  • 区别：
    • 空字符串长度为0，但有尾零’\0’存在
    • 'A’字符常量，内存占 1 字节
    • "A"字符串常量，内存占 2 字节

5、符号常量

  • 用一个标识符代表的常量

    #define pi 3.14159

  • 优点：含义清晰，修改方便

四、变量

  • 标识符：用来标识变量名、符号常量名、函数名、数组名、结构体名、类名等的有效字符序列，称为标识符。

    由字母或下划线开头，由字母、数字、下划线组成

    标识符区分大小写（大小写敏感）

    长度 <= 32

  • 变量

    同级不能同名

    不能与关键字（int / float 等）同名

    VS2022允许使用中文做变量名，通用性差，不建议

    C++11标准支持auto自动定义类型，由初值决定类型，易错，不建议

    多个变量赋同一初值，要分开进行

1、整型变量

  • 数据的溢出在C++中不认为是错误

    1
    short a=32767, b=a+1;	//b得到为-32768

  • 赋值：短 => 长：低位 赋值，高位 填充符号位（短为signed）/ 填充0（短为unsigned）

  • 赋值：长 => 短：低位 赋值，高位 丢弃

2、浮点型变量

  • float 赋值给 double 一定正确

  • double 赋值给 float 不一定正确，且不同于整型的高位丢弃

    （VS2022会有inf（infinity 无穷）的形式，有warning）

1
2
3
double d = 1.23456e38;	//d    1.23456e+38
float f1 = d;			//f1   1.23456e+38
float f2 = d * 10;		//f2   inf

3、字符型变量

  • 注意变量与常量的区别
  • 与整数的互通性：可当作1字节的整数参与运算（signed、unsigned）

4、字符串型变量

  • C++无
  • 可用一维字符数组来表示字符串变量

5、常变量

  • 在程序执行过程中值不能改变的变量

  • const 数据类型 变量名 = 初值;

  • 常变量有分号，符号常量不用带分号

  • 必须在定义时赋初值，且执行过程中不能再次赋值，否则编译错误

  • 常变量与符号常量使用方法相似，但有本质区别

    （推荐使用常变量）

    常变量：有类型、有空间、有初始值（除了值不可变，其余同变量）

    符号常量：一个标识符替代一串字符

五、运算符

  • 参与运算的操作数的个数不同，有：一元、二元、三元运算符（单目、双目、三目运算符）

  • 唯一的三目运算符是第15组的” ：？“

  • 优先级：优先级越小，意为高，先运算。最高为1，最低为18。

  • 结合性：同级混合运算的结合方向。右结合意为从右到左进行运算。

1、算术运算符与算数表达式

  • 注意：整数相除，得到整数，不会是小数

    V1 = 1 / 3 ==> 0

1
2
3
+ -			//5级
* / %		//6级
均是双目，均是左结合

转换的优先级与整型提升

整型提升表示必定的转换，参与运算的最小数据类型是int

1
2
3
4
5
6
7
8
9
long double			//高
double
float
unsigned long long
long long
unsigned long
long				//低
unsigned [int]		//整型提升
int  <--------------char/u_char/short/u_short

  • 这种类型转换，由系统隐式进行

  • 类型转换时，不是一次全部转换成最高级，而是依次转换

    （正是依次转换，才使得 V1 = 1 / 3 * pi 得到0）

  • 类型转换不完全如此，这是简易规则

2、自增、自减运算符

前缀（优先级3，右结合）

++ 变量名 – 变量名 ==》 先自增、减1，后使用

后缀（优先级2，左结合）

变量名 ++ 变量名 – ==》先使用，后自增、减1

  • 不能对常量、表达式使用
  • 不主张对同一个变量的多个+±-出现在同一个表达式中（不同编译器处理可能不同）

3、强制类型转换

  • 必须在程序中显式使用
  • 强制类型转换后，原变量的值、类型不变（只是要转换后存在别的变量里）
（类型名）（表达式） 类型名（表达式） static_cast<类型名>（表达式）
(int)(a+b) int(a+b) static_cast(a+b)
(int)a int(a) static_cast(a+b)
C方式 C++方式 C++方式

4、赋值运算符与赋值表达式

  • 赋值表达式左边必须是变量名

  • 若赋值表达式左右类型不同，以左值为基准进行转换（会报错或warning）

  • 复合的赋值运算符：

    1
    2
    3
    4
    a += b;			//a=a+b;
    a *= b + 1;		//a=a*(b+1);

    +=  -=  *=  /=  %=	//优先级均16

  • 赋值表达式的值和变量的值相等

1
2
3
4
int a=b=c=5;		//×
int a=5,b=5,c=5;	//√
int a,b,c;
a=b=c=5;			//√

  • 赋值表达式的值可以参与其他表达式的运算

    1
    2
    3
    4
    5
    6
    7
    int a=12;
    a+=a-=a*a;		//得到a=-264
           1
        2
     3
    (a=3*5)=4*3;	//√
    a=3*5=4*3;		//×

5、逗号表达式

  • C++中级别最低的运算符（又称顺序求值运算符）
  • 整个逗号表达式的值为最后一个表达式的值

C++中任意类型的表达式均有值

算术表达式

赋值表达式、复合赋值表达式

逗号表达式

表达式类型由最后一个运算决定

六、C++ 输入输出格式化控制

​ 头文件：

1
#include <iomanip>
格式控制符 说明
oct 设置整数为8进制
dec 设置整数为10进制
hex 设置整数为16进制
setbase(n) 设置整数为n进制(n=8,10,16)
setfill(‘c’) 设置填充字符，c可以是字符常量或字符变量
setprecision(n) 设置实数的精度为n位。在以一般十进制形式输出时，n代表有效数字。在以fixed(固定小数位)形式和scientific(指数)形式输出时，n为小数位数
setw(n) 设置字段宽度为n
setiosflags(ios::fixed) 设置浮点数以固定的小数位数显示
setiosflags(ios::scientific) 设置浮点数以科学计数法（即指数形式）显示
setiosflags(ios::left) 输出数据左对齐
setiosflags(ios::right) 输出数据右对齐
setiosflags(ios::skipws) 忽略前导的空格
setiosflags(ios::uppercase) 在以科学计数法输出E和十六进制输出字母X时，以大写表示
setiosflags(ios::showpos) 输出正数时，给出“+”号
resetiosflags( * ) 终止已设置的输出格式状态，括号内为具体内容(本处用 * 替代)

（1）只有十进制有负数形式

（2）cin 读入char型时，空格是否有效由ios::skipws 决定

（3）ctrl + C 是结束程序

​ ctrl + Z 只有在一行的最开始才有效

七、C 方式输入输出格式化控制

1、printf(“%d”,a);

printf所用的格式字符的种类：

格式字符 说明
d, i 带符号的十进制形式整数(正数不带+)
o 八进制无符号形式输出整数(不带前导0)
x, X 十六进制无符号形式输出整数(不带前导0x)
u 十进制无符号形式输出整数
c 以字符形式输出(一个字符)
s 输出字符串
f 以小数形式输出浮点数
e, E 以指数形式输出浮点数
g, G 从f，e中选择宽度较短的形式输出浮点数

printf所用的附加格式字符的种类：

附加格式字符 说明
字母l 字母h 表示长整型整数，用于d,o,x,u前表示短整型整数，用于d,o,x,u前
正整数m 表示输出数据的宽度
正整数.n 对浮点数，表示n位小数对字符串，表示前n个字符
- 输出左对齐

2、scanf(“%d”,&a);

&表示取地址

&不能跟表达式/常量(理由与=、++、–等相同)

scanf所用的格式字符的种类：

格式字符 说明
d, i 输入带符号的十进制形式整数
o 输入八进制无符号形式整数(不带前导0)
x, X 输入十六进制无符号形式整数(不带前导0x)
u 输入十进制无符号形式整数
c 输入单个字符
s 输入字符串
f 输入小数/指数形式的浮点数
e,E,g,G 同f

scanf所用的附加格式字符的种类：

附加格式字符 说明
字母l 输入长整型数，用于d,o,x,u前输入double型数，用于f,e,g前
h 输入短整型数，用于d,o,x,u前
正整数n 指定输入数据所占的宽度
***** 本输入项不赋给相应的变量

特别说明：

VS系列认为scanf函数是不安全的输入，因此缺省禁止使用(编译报error)，如果想继续使用，必须在源程序一开始加定义

#define _CRT_SECURE_NO_WARNINGS

为了和其它编译器兼容，以及方便后续课程的学习，我们仍然会继续使用scanf

另：加 _CRT_SECURE_NO_WARNINGS 的程序在其它编译器中可正常使用

注：VS系列中C语言用于安全输入的函数是scanf_s，

使用方法同scanf，考虑到兼容性，不建议大家使用scanf_s，有兴 趣可以自行查阅有关资料

八、常用库函数

九、字符集与ASCII字符集

32-126是可显示字符

其余不可见，是控制字符或功能码

二进制 十进制 十六进制 字符/缩写 解释
00000000 0 00 NUL (NULL) 空字符
00000001 1 01 SOH (Start Of Headling) 标题开始
00000010 2 02 STX (Start Of Text) 正文开始
00000011 3 03 ETX (End Of Text) 正文结束
00000100 4 04 EOT (End Of Transmission) 传输结束
00000101 5 05 ENQ (Enquiry) 请求
00000110 6 06 ACK (Acknowledge) 回应/响应/收到通知
00000111 7 07 BEL (Bell) 响铃
00001000 8 08 BS (Backspace) 退格
00001001 9 09 HT (Horizontal Tab) 水平制表符
00001010 10 0A LF/NL(Line Feed/New Line) 换行键
00001011 11 0B VT (Vertical Tab) 垂直制表符
00001100 12 0C FF/NP (Form Feed/New Page) 换页键
00001101 13 0D CR (Carriage Return) 回车键
00001110 14 0E SO (Shift Out) 不用切换
00001111 15 0F SI (Shift In) 启用切换
00010000 16 10 DLE (Data Link Escape) 数据链路转义
00010001 17 11 DC1/XON (Device Control 1/Transmission On) 设备控制1/传输开始
00010010 18 12 DC2 (Device Control 2) 设备控制2
00010011 19 13 DC3/XOFF (Device Control 3/Transmission Off) 设备控制3/传输中断
00010100 20 14 DC4 (Device Control 4) 设备控制4
00010101 21 15 NAK (Negative Acknowledge) 无响应/非正常响应/拒绝接收
00010110 22 16 SYN (Synchronous Idle) 同步空闲
00010111 23 17 ETB (End of Transmission Block) 传输块结束/块传输终止
00011000 24 18 CAN (Cancel) 取消
00011001 25 19 EM (End of Medium) 已到介质末端/介质存储已满/介质中断
00011010 26 1A SUB (Substitute) 替补/替换
00011011 27 1B ESC (Escape) 逃离/取消
00011100 28 1C FS (File Separator) 文件分割符
00011101 29 1D GS (Group Separator) 组分隔符/分组符
00011110 30 1E RS (Record Separator) 记录分离符
00011111 31 1F US (Unit Separator) 单元分隔符
00100000 32 20 (Space) 空格
00100001 33 21 !
00100010 34 22 "
00100011 35 23 #
00100100 36 24 $
00100101 37 25 %
00100110 38 26 &
00100111 39 27 ’
00101000 40 28 (
00101001 41 29 )
00101010 42 2A *
00101011 43 2B +
00101100 44 2C ,
00101101 45 2D -
00101110 46 2E .
00101111 47 2F /
00110000 48 30 0
00110001 49 31 1
00110010 50 32 2
00110011 51 33 3
00110100 52 34 4
00110101 53 35 5
00110110 54 36 6
00110111 55 37 7
00111000 56 38 8
00111001 57 39 9
00111010 58 3A :
00111011 59 3B ;
00111100 60 3C <
00111101 61 3D =
00111110 62 3E >
00111111 63 3F ?
01000000 64 40 @
01000001 65 41 A
01000010 66 42 B
01000011 67 43 C
01000100 68 44 D
01000101 69 45 E
01000110 70 46 F
01000111 71 47 G
01001000 72 48 H
01001001 73 49 I
01001010 74 4A J
01001011 75 4B K
01001100 76 4C L
01001101 77 4D M
01001110 78 4E N
01001111 79 4F O
01010000 80 50 P
01010001 81 51 Q
01010010 82 52 R
01010011 83 53 S
01010100 84 54 T
01010101 85 55 U
01010110 86 56 V
01010111 87 57 W
01011000 88 58 X
01011001 89 59 Y
01011010 90 5A Z
01011011 91 5B [
01011100 92 5C \
01011101 93 5D ]
01011110 94 5E ^
01011111 95 5F _
01100000 96 60 `
01100001 97 61 a
01100010 98 62 b
01100011 99 63 c
01100100 100 64 d
01100101 101 65 e
01100110 102 66 f
01100111 103 67 g
01101000 104 68 h
01101001 105 69 i
01101010 106 6A j
01101011 107 6B k
01101100 108 6C l
01101101 109 6D m
01101110 110 6E n
01101111 111 6F o
01110000 112 70 p
01110001 113 71 q
01110010 114 72 r
01110011 115 73 s
01110100 116 74 t
01110101 117 75 u
01110110 118 76 v
01110111 119 77 w
01111000 120 78 x
01111001 121 79 y
01111010 122 7A z
01111011 123 7B {
01111100 124 7C |
01111101 125 7D }
01111110 126 7E ~
01111111 127 7F DEL (Delete) 删除

十、运算符优先级

运算符 描述 例子 可重载性
第一级别 ----- ----- -----
:: 作用域解析符 Class::age = 2; 不可重载
第二级别 ----- ----- -----
() 函数调用 isdigit(‘1’) 可重载
() 成员初始化 c_tor(int x, int y) : _x(x), _y(y*10){}; 可重载
[] 数组数据获取 array[4] = 2; 可重载
-> 指针型成员调用 ptr->age = 34; 可重载
. 对象型成员调用 obj.age = 34; 不可重载
++ 后自增运算符 for( int i = 0; i < 10; i++ ) cout 可重载
– 后自减运算符 for( int i = 10; i > 0; i-- ) cout 可重载
const_cast 特殊属性转换 const_cast(type_from); 不可重载
dynamic_cast 特殊属性转换 dynamic_cast(type_from); 不可重载
static_cast 特殊属性转换 static_cast(type_from); 不可重载
reinterpret_cast 特殊属性转换 reinterpret_cast(type_from); 不可重载
typeid 对象类型符 cout « typeid(var).name();cout « typeid(type).name(); 不可重载
第三级别(具有右结合性) ----- ----- -----
! 逻辑取反 if( !done ) … 可重载
not ! 的另一种表达 ----- -----
~ 按位取反 flags = ~flags; 可重载
compl ~的另一种表达 ----- -----
++ 预自增运算符 for( i = 0; i < 10; ++i ) cout 可重载
– 预自减运算符 for( i = 10; i > 0; --i ) cout 可重载
- 负号 int i = -1; 可重载
+ 正号 int i = +1; 可重载
* 指针取值 int data = *intPtr; 可重载
& 值取指针 int *intPtr = &data; 可重载
new 动态元素内存分配 long *pVar = new long;MyClass *ptr = new MyClass(args); 可重载
new [] 动态数组内存分配 long *array = new long[n]; 可重载
delete 动态析构元素内存 delete pVar; 可重载
delete [] 动态析构数组内存 delete [] array; 可重载
(type) 强制类型转换 int i = (int) floatNum; 可重载
sizeof 返回类型内存 int size = sizeof floatNum;int size = sizeof(float); 不可重载
第四级别 ----- ----- -----
->* 类指针成员引用 ptr->*var = 24; 可重载
.* 类对象成员引用 obj.*var = 24; 不可重载
第五级别 ----- ----- -----
* 乘法 int i = 2 * 4; 可重载
/ 除法 float f = 10.0 / 3.0; 可重载
% 取余数(模运算) int rem = 4 % 3; 可重载
第六级别 ----- ----- -----
+ 加法 int i = 2 + 3; 可重载
- 减法 int i = 5 - 1; 可重载
第七级别 ----- ----- -----
<< 位左移 int flags = 33 可重载
>> 位右移 int flags = 33 >> 1; 可重载
第八级别 ----- ----- -----
< 小于 if( i < 42 ) … 可重载
<= 小于等于 if( i 可重载
> 大于 if( i > 42 ) … 可重载
>= 大于等于 if( i >= 42 ) … 可重载
第九级别 ----- ----- -----
== 恒等于 if( i == 42 ) … 可重载
eq == 的另一种表达 ----- -----
!= 不等于 if( i != 42 ) … 可重载
not_eq !=的另一种表达 ----- -----
第十级别 ----- ----- -----
& 位且运算 flags = flags & 42; 可重载
bitand &的另一种表达 ----- -----
第十一级别 ----- ----- -----
^ 位异或运算 flags = flags ^ 42; 可重载
xor ^的另一种表达 ----- -----
第十二级别 ----- ----- -----
| 位或运算 flags = flags | 42; 可重载
bitor |的另一种表达 ----- -----
第十三级别 ----- ----- -----
&& 逻辑且运算 if( conditionA && conditionB ) … 可重载
and &&的另一种表达 ----- -----
第十四级别 ----- ----- -----
|| 逻辑或运算 if( conditionA || conditionB ) … 可重载
or ||的另一种表达 ----- -----
第十五级别(具有右结合性) ----- ----- -----
? : 条件运算符 int i = (a > b) ? a : b; 不可重载
第十六级别(具有右结合性) ----- ----- -----
= 赋值 int a = b; 可重载
+= 加赋值运算 a += 3; 可重载
-= 减赋值运算 b -= 4; 可重载
*= 乘赋值运算 a *= 5; 可重载
/= 除赋值运算 a /= 2; 可重载
%= 模赋值运算 a %= 3; 可重载
&= 位且赋值运算 flags &= new_flags; 可重载
and_eq &= 的另一种表达 ----- -----
^= 位异或赋值运算 flags ^= new_flags; 可重载
xor_eq ^=的另一种表达 ----- -----
|= 位或赋值运算 flags |= new_flags; 可重载
or_eq |=的另一种表达 ----- -----
<<= 位左移赋值运算 flags <<=2; 可重载
>>= 位右移赋值运算 flags >>= 2; 可重载
第十七级别 ----- ----- -----
throw 异常抛出 throw EClass(“Message”); 不可重载
第十八级别 ----- ----- -----
, 逗号分隔符 for( i = 0, j = 0; i < 10; i++, j++ ) … 可重载

十一、常用的字符串处理函数

★ 常用字符串处理函数

① strlen (const char s[]);

② strcat (char dst[], const char src[]);

③ strncat(char dst[], const char src[], const unsigned int len);

④ strcpy (char dst[], const char src[]);

⑤ strncpy(char dst[], const char src[], const unsigned int len);

⑥ strcmp (const char s1[], const char s2[]);

⑦ strncmp(const char s1[], const char s2[], const unsigned int len);

● 更多的字符串处理函数通过作业完成并理解

● 教材/参考资料中，很多形式是 const char *s，暂时忽略，待学习指针后再进一步理解

● 先不要考虑这些函数的返回值，待学习指针后再进一步理解

加头文件

1
2
#define _CRT_SECURE_NO_WARNINGS //若全是只读操作，不需要加_CRT_SECURE_NO_WARNINGS
#include <cstring>

1.strlen(const char s[])

功 能：求字符串的长度

输入参数：存放字符串的字符数组

返 回 值：整型值表示的长度

注意事项：返回第一个’\0’前的字符数量,不含’\0’

2.strcat(char dst[], const char src[])

功 能：将字符串src连接到字符串dst的尾部(含尾零)

输入参数：存放字符串dst的字符数组dst

​ 存放字符串src的字符数组src(只读)

返 回 值：改变后的字符数组dst

注意事项：字符数组dst要有足够的空间(两串总长+1)

3.strncat(char dst[], const char src[], const unsigned int n)

功 能：将字符串src的前n个字符连接到字符串dst的尾部

输入参数：存放字符串dst的字符数组dst

​ 存放字符串src的字符数组src(只读)

​ 要复制的长度n(只读，如果n超过src长度，则只连接src个)

返 回 值：改变后的字符数组dst

注意事项：字符数组dst要有足够的空间(原dst长度+n+1)

4.strcpy(char dst[], const char src[])

功 能：将字符串src复制到字符串dst中,覆盖原dst串

输入参数：存放字符串dst的字符数组dst

​ 存放字符串src的字符数组src(只读)

返 回 值：改变后的字符数组dst

注意事项：字符数组dst要有足够的空间(串src长+1)

5.strncpy(char dst[], const char src[], unsigned int n)

功 能：将字符串src的前n个复制到字符串dst中,覆盖原dst串

输入参数：存放字符串dst的字符数组dst

​ 存放字符串src的字符数组src(只读)

​ 要复制的长度n(只读，如果n超过src长度，则只复制src个)

返 回 值：改变后的字符数组dst

注意事项：字符数组dst要有足够的空间(min(串src长,n)+1)

6.strcmp(const char s1[], const char s2[])

功 能：比较字符串s1和字符串s2的大小

输入参数：存放字符串s1的字符数组s1(只读)

​ 存放字符串s2的字符数组s2(只读)

返 回 值：整型值(0:相等 >0:串1大 <0:串1小)

7.strncmp(const char s1[], const char s2[], const unsigned int n)

功 能：比较字符串s1和字符串s2的前n个字符的大小

输入参数：存放字符串s1的字符数组s1(只读)

​ 存放字符串s2的字符数组s2(只读)

​ 要比较的长度n(只读)

返 回 值：整型值(0:相等 >0:串1大 <0:串1小)