编程要素

数据类型

基本数据类型

• 逻辑型：bool，1字节8位
  • true：非0
  • false：0
• 字符型：char，1字节8位
  • 有符号 signed：-128 ~ 127（$-2^7$ ~ $2^7 - 1$）
  • 无符号 unsigned：0 ~ 255（$0$ ~ $2^8 - 1$）
• 短整型：short int，2字节16位
  • 有符号 signed：-32768 ~ 32767
  • 无符号 unsigned：0 ~ 65535
• 整型：int，4字节32位
  • 有符号 signed：-2147483648 ~ 2147483647（$-2^{31}$ ~ $2^{31} - 1$）
  • 无符号 unsigned：0 ~ 4294967295（$0$ ~ $2^{32} - 1$）
• 长整型：long，4字节32位
  • 有符号 signed：-2147483648 ~ 2147483647（$-2^{31}$ ~ $2^{31} - 1$）
  • 无符号 unsigned：0 ~ 4294967295
• 超长整型：long long，8字节64位
  • 有符号 signed：-9223372036854775808 ~ 9223372036854775807（$-2^{63}$ ~ $2^{63} - 1$）
  • 无符号 unsigned：0 ~ 18446744073709551615（$0$ ~ $2^{64} - 1$）
• 实型
  • 单精度：float，8字节32位：-3.4e38 ~ 3.4e38，7位有效数字
  • 双精度：double，8字节64位：-2.1e109 ~ 2.1e109，17位有效数字
  • 长双精度：long double，16字节128位：-1.2e4932 ~ 1.2e4932，17位有效数字

复合数据类型

• 数组：基本变量类型 数组名[数组长度]
• 结构体
  • struct 结构体名称 {
    • 基本数据类型1 成员名1;
    • 基本数据类型2 成员名2;
    • 基本数据类型3 成员1;
    • 基本数据类型 方法1();
  • };
• 类
  • class 类名称 {
    • 基本数据类型1 成员名1;
    • 基本数据类型2 成员名2;
    • 基本数据类型1 方法1();
    • 基本数据类型 方法2();
  • };
• 共用体
  • union 结构体名称 {
    • 基本数据类型1 变量名称1;
    • 基本数据类型2 变量名称2;
  • };
• 枚举
  • enum 枚举名称 {
    • 枚举项1;
    • 枚举项2;
  • };

指针类型

• 基本指针：基本数据类型 * 基本指针名称
• 复合指针：基本数据类型 ** 复合指针名称

空类型

• void

变量

变量的概念

变量是计算机中的一个存储单元，在程序运行过程中，其值可以改变的量。

变量的定义

• 变量的定义形式：[类型名称 变量名称1, 变量名称2;]
• 例：float f;

变量的范围

• 全局变量
  • 概念：全局变量是指在函数之外定义的(外部)变量，全局变量的有效范围为从定义变量的位置开始一直到本源文件结束。
  • 全局变量使用全局(静态)内存区，可使用的内存范围较大，仅受内存大小的限制。
  • 内存大小：
    • 128 MB 全局(静态)内存区：$128 * 1024 * 1024$ Byte = $32 * 1024 * 1024$ 4(int)类型的一维数组 = $6 * 1024 * 4(int)$类型的二维数组
    • 最大长度 100000 的一维数组或最大长度 1000 的二维数组要放在外部定义(全局变量)
    • 256 MB 全局(静态)内存区：$256 * 1024 * 1024$ Byte = $64 * 1024 * 1024$ 4(int)类型的一维数组 = $8 * 1024 * 4(int)$类型的二维数组
    • 最大长度 400000 的一维数组或最大长度 2000 的二维数组要放在外部定义(全局变量)
    • 512 MB 全局(静态)内存区：$512 * 1024 * 1024$ Byte = $128 * 1024 * 1024$ 4(int)类型的一维数组 = $3 * 1024 * 4(int)$类型的二维数组
    • 最大长度 1600000 的一维数组或最大长度 4000 的二维数组要放在外部定义(全局变量)
• 局部变量
  • 概念：局部变量是指在函数或程序块之内定义的(内部)变量，它只在本函数或程序块范围内有效。
  • 局部变量使用栈内内存，可使用的内存范围较小，一般上限是 2 MB。
  • 2 MB 栈内存区 = $2 * 1024 * 1024$ Byte = $512 * 1024$ 4(int)类型一维数组 = $724 * 4$ (int)类型二维数组
  • 最大长度 10000及以内的一维数组或最大长度 100 以内的二维数组可以放在函数内部定义(局部变量)
  • 注：当全局变量和局部变量重名时，起作用的是局部变量。

常量

常量的概念

常量是在程序运行过程中，其值保持不变的量。

常量的定义

1. #define 宏定义(放在主函数之前，结尾没有分号)
   • #define MAXSIZE 100 比如数组的最大长度 MAXSIZE，圆周率 PI等
2. const 类型名 常量名=常量值 (即赋有初值)
   • const int inf = 0x7FFFFFFF; 相当于 const int inf = 2147483647;

运算符

运算符的概念

运算符用于执行程序代码运算，会针对一个以上操作数项目来进行运算。

运算符的分类

1. 算术运算符：+、-、*、/、% 5个
2. 关系运算符：>、<、==、<=、>=、!= 6个
3. 逻辑运算符：&&、||、! 3个
4. 位运算符：<<、>>、~、|、^、& 6个
5. 赋值运算符
   • 基本赋值运算符：=
   • 复合赋值运算符：+=、-=、*=、/=、%=、&=、|=、^=、<<=、>>=
     • n = 2 表示 n 赋值给 n
     • i += 2 相当于 i = i + 2
     • x &= 7 相当于 x = x & 7
6. 条件运算符：?:
7. 逗号运算符：,
8. 指针运算符：*、&
9. 求字节数运算符：sizeof()
10. 强制运算符：(变量类型)
11. 成员运算符：.、->
12. 下标运算符：[]
13. 函数调用运算符：()
14. 符号运算符：+(正号)、-(负号)
15. 自增运算符
    • ++(自加)
      • 每次自身加1
      • 前置 ++i：先引用再加1
      • 后置 i++：先加1再引用
16. 自减运算符
    • --(自减)
      • 每次自身减1
      • 前置 --i：先引用再减1
      • 后置 i--：先减1再引用

表达式

表达式的概念

表达式是由操作数(常量)、运算符、分括号等(如标号)、自由变量和约束变量等以能求得数值的有意义排列方法所得的组合。(如果变量在表达式中，那么变量在表达式之外另行赋值变量。)

• 表达式 2 + 3 中，2、3 是操作数，+ 是运算符，i++ 也是表达式，相当于 i = i + 1

子主题2

语句

语句的概念

语句是程序的最小可执行单位。

语句以;为结束

语句的分类

1. 控制语句：改变程序运行顺序或执行不同部分执行不同次数的语句。
   • (1) if()...else... 条件语句
   • (2) for() 循环语句
   • (3) while() 循环语句
   • (4) do...while() 循环语句
   • (5) continue 跳过语句
   • (6) break 中止语句
   • (7) switch 分支语句
   • (8) return 返回语句
   • (9) goto 跳转语句
2. 表达式语句：由表达式加一个分号组成。i++;
3. 函数调用语句：由函数调用加一个分号组成。output(n);
4. 复合语句(语句块)：用{}把语句和声明组合起来的语句块。if() {}
5. 空语句：只有一个分号，;

C语言用法的屏幕输入输出

格式化输入 scanf()

• 输入整型变量：scanf("%d", &n);
• 输入长整型变量：scanf("%lld", &ll);
• 输入单精度浮点数：scanf("%f", &f);
• 输入双精度浮点数：scanf("%lf", &db);
• 输入字符类型变量：scanf("%c", &ch);
• 输入字符串类型变量：scanf("%s", &str);

格式化输出 printf()

• 输出整型变量：printf("%d\n", n);
• 输出超长整型变量：printf("%lld\n", ll);
• 输出单精度浮点数，并保留3位小数：printf("%.3f\n", f);
• 输出双精度浮点数，并保留3位小数：printf("%.3lf\n", db);
• 输出字符类型变量：printf("%c", ch);
• 输出字符串类型变量：printf("%s", str);
• 输出两位输出整数：printf("%3d\n", n);

常用转义字符

• \n 换行：将光标移到下一行进行后续打印
• \t 水平制表：将光标跳到下一个制表位置
• \a 报警：使计算机发出鸣响
• \b 退格：使光标后退(例如向左移动)一个位
• \r 回车：将光标移到当前行(不换行)下的开头
• \ 反斜杠：打印一个反斜杠字符
• \' 单引号：打印一个单引号字符
• \" 双引号：打印一个双引号字符

字符输入

• getchar()：ch = getchar();

字符输出

• putchar()：putchar(ch);

字符串输入

• gets()：gets(stdin); —— 2022年开始，不再可用

字符串输出

• puts()：puts(str); —— 2022年开始，不再可用

C++语言用法的屏幕输入输出

从标准输入设备读取数据

• cin >> 操作符
  • cin >> n;：输入整型变量
  • cin >> db;：输入双精度浮点数
  • ch = cin.get();：截取一个字符
  • cin.getline(str, sizeof(str));：读取整行字符串

向标准输出设备输出数据

• cout << 等价于 cout.operator<<()
  • 使用非科学计数法输出整数：cout << fixed << setprecision(0) << ll << endl;
  • 输出双精度浮点数，并保留3位小数：cout << fixed << setprecision(3) << db << endl;
  • 使用两位输出整数：cout << setw(3) << n << endl;

数据流重定向的文件输入输出

• freopen()
  • 打开读取文件：freopen("data.in", "r", stdin);
  • 打开写入文件：freopen("data.out", "w", stdout);
• fclose()
  • 关闭读取文件：fclose(stdin);
  • 关闭写入文件：fclose(stdout);

字符串格式化输入输出

从字符串读取格式化输入 sscanf()

• int day, year;
• char weekday[20], month[20], dtm[100];
• strcpy(dtm, "Saturday March 25 1989");
• sscanf(dtm, "%s %s %d %d", weekday, month, &day, &year);
• printf("%s, %d, %s\n", weekday, month, day, year);

格式化输出到字符串 sprintf()

• char str[80];
• sprintf(str, "PI 的值 = %f", M_Pi);
• puts(str); // PI 的值 = 3.141593

基本数学函数

取绝对值

• 整数取绝对值：abs(n)
• 浮点数取绝对值
  • float fabsf(float arg);
  • double fabs(double arg);
  • long double fabsl(long double arg);
• 以下数学函数的用法全部类同
  • 无后缀：double
  • f后缀：float
  • l后缀：long double

取整

• 向上取整：ceil(db)
• 向下取整：floor(db) 相当于 int(db)
• 四舍五入取整：round(db)

幂运算

• 乘方：pow(x, y)
• 开平方：sqrt(db)
• 开立方：cbrt(db)
• 开任意次方：pow(x, 1/y)
• 开平方和的平方：hypot(x, y) 相当于 sqrt(x * x + y * y)

指数函数运算

• 以e为底的指数运算：exp(x)
  • e=1+1/1!+1/2!+1/3!+...+1/n!
• 以2为底的指数运算：exp2(x)
  • e=2+1/1!+1/2!+1/3!+...+1/n!

对数函数运算

• 以e为底的对数运算：log(x)
• 以2为底的对数运算：log2(x)
• 以10为底的对数运算：log10(x)
• 任意数为底的对数：换底公式 log(a)/log(b)；log(8)/log(2)=3

三角函数

• 正弦函数：sin(x)
• 余弦函数：cos(x)
• 正切函数：tan(x)
• 反正弦函数：asin(x)
• 反余弦函数：acos(x)
• 反正切函数：atan(x)

交换变量

• swap(a, b)

求最大值

• max(a, b)

求最小值

• min(a, b)

基本STL模板函数

排序

• sort()：sort(arr+1, arr+1+n, cmp);
  • bool cmp(node a, node b) { return x.value < y.value; }

反转

• reverse()：reverse(arr+1, arr+1+n);

去重

• unique()：int cnt = unique(arr+1, arr+1+n) - (arr+1);
  • n = (arr+1);