信息学竞赛 CPP 基础篇

c++语言概述

聊聊cpp的历史，背景，特点。。。

语言简史—里程碑

• 1972 c语言的最早版本，目标是开发unix系统
• 1989 c语言的第一个标准 ANSI C 著名的c89/c90
• 1980 贝尔实验室，==c语言 + 面向对象== ==>> 第一个c++版本

• 1994 第一个C++标准 ANSI C++

• 1998/1999 STL等提案的确认，ANSI/ISO标准，被认为==标准c++==

  所有编译器都默认支持 著名的c++99标准, 并非是每个编译器100%实现了该标准

• 2011 大幅度引入新特性，修正了很多缺陷或改进语法 ==>> c++11，

  一般的编译环境都需要加编译选项

• 2014,2017,2020 。。。进行了一些修正，引入很多特性，有人反对

c/c++是成功的

40年对计算机语言是很长的，这期间大浪淘沙，不断有新秀登场

delphi, java, c#，go, rust 现代的设计理念

python ruby php js … 脚本语言更灵活、敏捷

c/c++一直保持大量的用户群，在操作系统，嵌入式，实时等关键领域垄断地位

c/c++ 历久弥新的原因？

1. 平衡易用性（对人友好）和直达性（对机器高效）

   简洁高效，非必要不过度抽象 ==>> 执行效率

1. 兼容性很重要！！！

c++ 完全兼容 c，现代的编译器兼容上个世纪80年代的库

高质量的库，种类多，数量大，是资产，也是包袱。。。

编译速度？ 通过预编译头等策略

c++语言的特性

• 编译型 编译 vs 解释，半编译，JIT

• 静态类型 编译器可以更多地介入和监督。 有利于：编译期间发现错误 有利于：编译器对目标代码进行深度优化

• 弱类型 编译器非必要不强迫。

• 源码保护 从产品很难复原出源码。维护著作权。

勿于浮沙筑高塔

c/c++ 是威力巨大的利器！！！

前提是：使用者需要==真正充分理解==其运作原理，特性，才能驾驭它。

不能似是而非，一知半解

此武器，用好了，一招制敌！

实时效果反馈

1.c++对c语言主要添加了什么特性？

• A 面向切面

• B 面向对象

• C 面向函数

• D 面向并发

2.c++是哪种类型的高级语言？

• A 编译型

• B 解释型

• C JIT（即时编译)

• D 虚拟机

答案 1=>B 2=>A

开发环境介绍

子曰： 工欲善其事，必先。。。

原始方案

纯文本编辑器 + 命令行

• 纯文本编辑器

linux/Unix: vi, vim, emacs

windows: 记事本，notepad++, ultraEdit

• 命令行窗口

windows： cmd窗口，powershell

linux: bash, csh, ksh

• 编译环境 编译器是任务是：把源代码翻译成机器能执行的二进制指令

  • 微软的： vs默认 cl.exe
  • GNU的： gcc/g++
  • 苹果的： clang 支持 c, c++, objective-c

• 第一个程序 helloworld

1. 编辑器编写代码，并保存为 a.cpp

    #include <stdio.h>
    int main()
    {
        printf("hello!\n");
        return 0;
    }

2. 编译为可执行文件： g++ a.cpp
3. 执行exe文件： a

轻量 IDE

代码着色，自动编译，代码补全？？

vscode: 现代，网页风格，主题丰富，插件丰富

vscode可以支持很多语言的开发，需要安装相应的插件。

vscode可以根据扩展名，自动识别语言的类型，给出插件建议。

一般按照建议，安装语言默认插件即可。

sublimeText：反应快，界面主题丰富，扩展强，安装容易，有商业支持

devCpp, codeBlocks 开源，简洁

devcpp 是开源产品，文件很小，无需安装。不用建立工程，直接对.cpp, .c 文件操作

devcpp 是很多竞赛，考试的指定编译环境

重型 IDE

重型的优势：

代码着色，代码补全，语法检查，提示等更准确

对软件的==工程化==开发支持好，比如调试，测试，重构，优化等

vc++6.0 国内（尤其高校）曾经十分流行

很古老了，win98时代的产品。微软出品，品质还是能保底的。尤其调试功能很容易上手。

vs系列

当然强大！一般是收费的。

visual studio 2010 社区版，学习，调试

QtCreator

Qt开发套件的标配工具，有开源版本。

对初学者，重量级武器唯一缺点：再小的任务也要先建立个项目，然后。。。

安装体积大，耗时。。。不算缺点

实时效果反馈

1.下列哪个不是纯文本编辑器？

• A notepad++

• B sublimeText

• C vim

• D WPS

2.下列说法正确的是？

• A c++语言开发必须使用 IDE

• B c++ 开发环境下无法编译 c 语言风格的程序

• C g++ 与 gcc 编译器类似，只是默认就链接了 c++的标准库

• D 微软的visual studio套件默认使用clang编译器

答案 1=>D 2=>C

基本数据类型

概览

c++的数据类型分为：

基本数据类型：布尔，整数，浮点

派生类型：修饰类型，指针类型，用户定义的复合类型等

基本类型表

基本类型占用空间

现在就开始实验，不要依赖于文档

ps. 一般IDE注释和取消注释的方案：行选中，ctrl + /

sizeof(变量) 或者 sizeof(类型) 来探测

sizeof 是关键字，不是函数

不同的平台，不同的硬件，不同的编译环境可以有差异，不要武断！

类型修饰符

==short== 更短

==long== 更长

==signed== 有符号

==unsigned== 无符号

如果省略了基本类型，默认为 int

short = short int

unsigned = unsigned int

类型能多次修饰

long long = long long int

类型的可能取值范围

#include <limits>

std::numeric_limits<类型>::max() 或 min() 求最大值，最小值

unsigned 能表示更大的数值范围

unsigned 在移位操作时很重要

类型的别名

typedef 可以给类型赋予别名，与原名等价

书写更简便，尤其时复合类型时

例如：typedef long long int LL;

实时效果反馈

1.使用 sizeof 关键字会获得何种信息？

• A 变量或类型占用内存的字节数

• B 变量包含元素的个数

• C 变量的级别

• D 变量生存时间

2.unsigned int 与 signed int 占用内存大小关系是？

• A 前者更多

• B 后者更多

• C 占用内存相同

• D 与平台和编译器版本有关

答案

1=>A 2=>C

变量及其作用域

变量好比一个小盒子，能容纳数据，有名字，有地址，有大小，类型。。。

两个重要概念：

• 生存期：什么时候分配内存，什么时候释放内存
• 作用域：在什么位置可见，什么位置不可见

全局变量

定义在函数外的变量，静态的生存期

• 全局变量可以初始化，可以用表达式
• 全局变量可以在多个函数间，多个文件间共享
• 全局位置不能执行非定义语句

int a = 100;
int b = 200;
int c;
c = a + b;  // 编译错误！
int main()
{
    cout << c << endl;
    return 0;
}

此是反面教材, 不能在全局位置执行其它语句

变量可以在声明时初始化，也可以只声明。 当未初始化时，变量的值是随机的，此是很多bug发源地

局部变量：

函数内部定义，函数执行时存在

局部变量可以和全局同名，会产生覆盖效果

变量赋值

赋值是最常见的动作，但其意义非凡！！

理解这个很重要，澄清将来的指针动作全靠它！

变量是一个小盒子，装着数据。 a = b; 的意思是：把 b 中的数据复制一份，放到 a 中。 a 中原来的数据被“踩死”了。

试试看，a b 现在值多少？

int a = 5, b = 8;
a = a + b;
b = a - b;
a = a - b;
cout << a << "," << b << endl;

……?????#$@

如何交换两个变量？

如何交换：酱油和醋，找个空瓶子 空瓶 = 酱油；酱油 = 醋；醋 = 空瓶；

【示例】交换 a, b 变量的值

int a = 5, b = 8;
int t = a; a = b; b = t;
cout << a << "," << b << endl;

这样做，还有什么缺点吗？

大括号作用域

大括号开辟了，新的一层，嵌套作用域

• 大括号作用域可以嵌套，实际上局部作用域就是==最外一层==大括号。
• 大括号作用域可以嵌套覆盖
• 编程习惯：尽量缩小变量的作用域。

更好的交换变量方法？？？

int a = 5, b = 8;
{ int t = a; a = b; b = t; }
cout << a << "," << b << endl;

实时效果反馈

1.在全局作用域==不==可以对变量做哪些事情？

• A 声明变量

• B 给变量赋一个初始值

• C 在变量初始值中使用表达式

• D 执行声明，初始化以外的其它语句

2.局部变量的作用域是？

• A 本程序范围内

• B 本函数范围内

• C 最近一层的左大括号到右大括号

• D 可以被全局变量覆盖掉

答案

1=>D 2=>C

常数与常量

先看看最粗略的内存结构。

常数

也叫立即数，或者“字面量”，就是硬编码到程序中的那些“死”数据。

• 字符常数 单引号：’A’, ‘x’ 有些字符无法表示，可以直接整数，或：转义字符

   char a = 'A';
   char b = 9;
   char c = 66;

  ‘\t’ 与 9 是同等效果的 ‘\n’ 是什么？它的 ASCII 码是多少? 可以实验确定

char a = '\n'; 
int x = a; 
cout << x << endl;

• 整型常数 默认是 int，需要长整数需要加 LL 考考你，一年有多少秒？ int a = 365 * 24 * 60 * 60 * 1000; ???

  十六进制表示法： 0xff, 0xBA3C

  二进制与十六进制有天然对应关系：

  cout << hex << x<< endl;

• 浮点型常数 可以使用 f 或 d 尾标表示类型 可以使用科学计数法表示更大的数字 0.5e12, 3.18e-20

常量

用 const 修饰的变量，它占用数据区内存，但编译器保证你不能修改它的值。

常量必须在定义时初始化

编译器的保证只是形式上的，你可以绕开编译器，强行改变其值！ 常量的用处：

• 多个地方用到同一个常量，内存只有一份拷贝。
• 程序中不希望修改的量，避免“笔误”
• 程序中不希望出现魔法数字，这样不利于将来的变更

枚举类型

把一组常数符号化，比如：星期，职称等有限种类的情形

enum week{Mon, Tue, Wed, Thu, Fri, Sat, Sun} a; 实际上相当于：

enum week{Mon, Tue, Wed, Thu, Fri, Sat, Sun};
enum week a;

这实际上是同时定义了三样东西： 类型： enum week 类型中的常数符号： Wed, Sat 等 该类型的变量： a

enum 的典型错误用法：

enum week{Mon, Tue, Wed, Thu, Fri, Sat, Sun};
int a = Thu;
//a = 100;
cout << a << endl;

可以通多 typedef 来定义enum的别名，避免定义多个变量时的尴尬。

typedef enum {Mon, Tue, Wed, Thu, Fri, Sat, Sun} WEEK;

实时效果反馈

1. 下面关于常量的说法，==不==正确的是

• A 常量初始化后，用任何方法都不能更改其值

• B 常量必须在声明时初始化

• C 多次引用常量，只占用一份内存

• D 常量的初始化可以使用表达式

2.下列定义 enum 类型的别名，哪个==不正确==?

• A typedef enum {yes,no} YN

• B typedef enum {yes=1,no} YN;

• C typedef enum YN_ {yes,no} YN;

• D typedef enum {yes,no} YN;

答案

1=>A 2=>A

类型修饰符

• 对大类型进行细化， short long signed unsigned
• const 常量，
• volatile 不要进行自动优化

存储修饰符

• auto 默认的类型，称为：自动变量、栈变量、局部变量 c++17 已经把 auto 挪为他用，不再是类型修饰符
• register 直接放寄存器中，速度快。c++17 开始废弃

• static 修饰，静态空间，与全局变量同在

• extern 跨文件的伪声明

  并不分配内存，只是告诉编译器，全局变量会在另一个地方声明

内存的类型

程序分配的内存，主要在“栈”和“堆”这两部分。“堆”比“栈”复杂

• 只读代码: 存代码，也包括立即数，以及定常资源
• 静态空间： 存放static变量，全局变量，常量
• 栈区（stack）： 自动变量，函数执行时的上下文环境
• 堆（heap）: 程序运行中，动态地申请及归还

• 堆和栈的比较

优美的栈

后进先出的结构（LIFO）

对比：heap 是什么结构？ 自由进出

• 栈能实现沿着原路返回的功能 想一想: 很多人爬山，山脚下堆放衣服，回来拿衣服的时，怎样不会纠缠在一起？？
• 特点是：自动分配，自动释放
• 缺点： 栈溢出 stackoverflow

实时效果反馈

1.下面关于c++栈空间的说法，正确的是？

• A 常量分配在栈空间

• B 常数（立即数）分配在栈空间

• C 全局变量分配在栈空间

• D 自动变量分配在栈空间

2.可执行程序被加载入内存后，二进制代码被存在哪个内存位置？

• A 静态空间

• B 栈空间

• C 只读空间

• D 堆空间

答案

1=>D 2=>C

基本运算符

a+b, p = x->f() 12;

本质上说，运算符就是一种函数，只是表现形式更加人性化

==目==的概念

目就是参加运算操作数的个数

• 主要有单目，双目，三目（只有一个运算符）
• 同一运算符也可以有多目 a-b 和 -a 称为运算符的重载形式
• 运算符有优先级和结合律

算数运算符

• 整除，求余 试一试： 如何让 a 不断重复 0 1 2 0 1 2 ...

  思考题：a, b 是两个月份值，求 a 月 到 b 月，距离多少个月？

• 浮点运算有舍入误差

• 字符型可以参与整数的运算 试一试: 把小写字母转为大写字母

关系运算符

大于，小于，等于，不等于 。。。

不同类型的数比较—-陷阱！ 浮点数精确比较—-陷阱！

逻辑运算符

表示：与 或 非 的概念 && || !

• 注意优先级： !a&&b的意思是：(!a) && b，而不是: !(a&&b) a || b && c 的意思是： a || (b && c)， 而不是：(a||b) && c
• 逻辑运算符有短路求值特性，当心！

其它

• 赋值=本身是个运算符，结合律：右结合 所以才有：a = b = c； 意思是： a = (b = c)
• ( ) 是运算符，它的意思是强制转换，有可能丢失精度 如何取：天花板？地板？ 3.5 -> 3 3.5 -> 4 如何四舍五入？
• 还有很多高级的运算符，后续用到再讲

实时效果反馈

1.*p++ = x == y 正确的含义是：

• A (*(p++) = x ) == y

• B *(p++) = (x == y)

• C ((*p)++) = (x == y)

• D (((*p)++) = x) == y

2. 四则运算符多数都是既==单目==又==双目==，只有一个例外，它是：

• A +

• B -

• C *

• D /

答案

1=>B 2=>D

选择与分支

根据条件的真假，决定执行哪路代码 if .. else.. switch ?: 都有这个能力

if 的条件中尽量用 bool, 其它类型会强制转为bool

• if 的条件中可能会发生短路求值现象 if(a表达式 && b表达式) ... 当 a表达式为假的时候，b表达式根本不会执行 同理，if(a表达式 || b表达式) ...

int a = 5, b = 8;
int x = 100;
if(a>10 && (x=b)){
    cout << "here" << endl;
}
cout << x << endl;

单 if 语句

尽量使用这个语句，避免 else

试一试： 给定年份，求是不是闰年

bool leap_year = x % 4 == 0 && x % 100 != 0 || x % 400 == 0;

晕不晕？ 可以采用渐进的方案，逐渐接近目标：假设修正法

if .. else

if 语句是可以嵌套的，嵌套是 bug 的发源地之一（哪个else 对应哪个if）

• 试一试：给定 a, b, c 三个数，求居中的一个(假设没有相等的情况)

int a = 5, b = 2, c = 8;
if(a>b){
    if(b>c)
        cout << b << endl;
    else
        if(c>a) cout << a << endl;
        else    cout << c << endl;
}
else{
    if(b<c)
        cout << b << endl;
    else
        if(c<a) cout << a << endl;
        else    cout << c << endl;
}

有很多的改进方法：

• 使用函数，避免 if 嵌套
• 使用 ?: 表达式
• 使用”冒泡排序法”

// 伪代码
if(a>b) a <---> b
if(b>c) b <---> c
if(a>b) a <---> b
print(b)

?: 表达式

?: 是唯一的三目运算符

xxx = a ? b : c;  //重点在求值，不在分支

与 if else 相比，它的重点是求值，而不是：执行一系列动作 改进的求居中方案：

int a = 5, b = 2, c = 8;
if(a>b && a>c) cout << (b > c? b : c) << endl;
if(b>a && b>c) cout << (a > c? a : c) << endl;
if(c>a && c>b) cout << (a > b? a : b) << endl;

• 试一试： 给定 a, b, c 三个数，求最大值 不要想复杂了，这可以用”擂台赛”的方式解决 提示： 先让 a 上台，然后挑战者与之比试，胜者留在擂台，继续接受挑战。。。

实时效果反馈

1.下列说法正确的是：

• A if 条件表达式只能接受bool量

• B if 必须与 else 配对使用

• C ?: 表达式可以用 if … else 改写

• D if else 嵌套越多越高效

2. 当 if 分支只有一个语句时，下列说法错误的是：

• A 可以省略大括号

• B 可以与 if 写在同一行上

• C 可以省略条件语句的圆括号

• D 可以把条件取反，并且交换 if else 的分支部分

答案

1=>C 2=>C

switch

当分支情况较多时，

if .. else if …. else if …. else …

嵌套过多，维护不方便。

switch(表达式){
case 1:
   代码块1;
   break;
case 2:
    代码块2;
    break;
default:
    默认处理
}

要求：

switch 圆括号中的值必为：整数，字符 或者 枚举类型

如果不满足这个要求，可以用表达式换算为符合要求。 示例： 对学生成绩进行分类，输出：A, B, C, D, E 5个等级

分类标准：

int score = 85;
char level = 'E';
switch (score / 10) {
case 9:
case 10:
   level = 'A';
    break;
case 8:
    level = 'B';
    break;
case 7:
    level = 'C';
    break;
case 6:
    level = 'D';
}
cout << level << endl;

与 if .. else 的比较

示例：对学生成绩进行分类，输出：A, B, C, D, E 5个等级 可以假设修正法，先假设不及格 满足了某个条件再修正它

常见的bug

• 忘记了 default
• 忘记了在每个case中写 break;

实时效果反馈

1.关于switch语句，正确的说法是：

• A 有些场景，switch无法用 if .. else 来代替

• B switch中必须包含 default 分支

• C switch 的条件表达式中可以接受浮点数值

• D switch 的 case 中不强制要求break; 语句

2. 下列关于switch说法，错误的是：

• A 当某个case检测成功时，执行该case块的代码，然后跳出 switch语句

• B 每个case 块可以有多条语句，且不需要大括号

• C default 块当所有case都不满足必会执行

• D default 块当有某个case满足时，也可能会执行

答案

1=>D 2=>A

while循环

循环是程序逻辑的关键点，是代码复杂度的源泉，需要谨慎对待

最可靠的循环—死循环

while(true){
    执行一些动作；
}

配合的出口语句：break if (条件) break;

示例： 对学生成绩进行分类，输出：A, B, C, D, E 5个等级

int score = 100;
int a = score - 60;
char level = 'E';
while(true){
    if(a<0) break;
    level--;
    a -= 10;  // a = a - 10;
    if(level=='A') break;  // 封顶
}
cout << level << endl;

示例： 已知正整数x，从低位到高位，输出每个十进制数位 提示：通过不断整除，消掉最后一位，直到变成0

while 和 do..while

do-while 循环并不常用，所有情况，可以用内部的break来解决

实时效果反馈

1.关于break，正确的说法是：

• A break可以跳出循环，或者switch

• B break 跳出本层大括号

• C break 跳出本函数

• D break结束本程序

2. 下列关于while循环的说法，正确的是：

• A while循环必然会终止

• B while 循环体中可以没有任何语句

• C while 循环不能嵌套使用

• D while循环的条件可以不写

答案

1=>A 2=>B

for循环

当我们已知执行次数的时候，用 for 循环更方便一些。

for 循环的语法：

for(初始化循环变量; 循环保持条件; 循环变量变化){
    循环体
}

• 循环变量的生存期 循环变量仅仅在 for 语句范围内有效，是局部变量，放在栈中 循环变量的生存期，比循环体内的局部变量更长

相当于：
for语句{
   循环变量 i ...
   {
      循环体内，可以有自己的局部变量
   }
}

• continue 直接进入下一轮循环 if(条件) continue; 越过循环的某些轮次不做

示例 打印九九乘法表 可以用双层嵌套

for(int j=1; j<=9; j++){
    for(int i=1; i<=j; i++){
        int k = i * j;
        cout << j << "x" << i << "=" << k << " ";
    }
    cout << endl;
}

示例 100以内的素数 素数：就是不能再等分的数，比如：2，5，19.... 最小的素数是2 设计思路：

for(n 从 2 到 100){
    先标记：n 是素数
    for(从 2 开始到 n-1 试着除 n){
        如果能除尽 {
            标记：n 不是素数
            跳出循环;
        }
    }
    if(标记为素数) 输出 n;
}

示例 分解质因数

90 = 2 x 3 x 3 x 5 设计思路：

for(i 从 2 到 n-1){
    if(n 能除开 i){
        输出 i
        n = n / i
        设法阻止 i 的自增行为
    }
}
if(剩下的 n > 1) 输出 n;

实时效果反馈

1.关于for的循环变量，正确的说法是：

• A 循环变量在每轮循环重新分配

• B 循环变量只能是整数

• C 循环变量不能是char

• D 循环变量的生存期大于循环体内的局部变量的生存期

2. 下列关于循环的说法，正确的是：

• A while 循环至少会执行一次

• B for 循环会至少执行一次

• C do-while 循环会至少执行一次

• D 所有循环都可能一次也不执行

答案

1=>D 2=>C

函数入门

函数，在数学上的定义：对于输入的若干值，返回唯一的值。

函数的定义

返回值类型  函数名(输入参数列表 。。。){
    函数体
    return 返回值
}

例子：

int myadd(int a, int b){
    int t = a * 10 + b;
    return t;
}

调用它的方法：int x = myadd(5, 8);

函数定义时的参数，称为：形式参数，简称：形参 调用函数时，传给它的参数，称为：实际参数，简称：实参

• 一般的情况下，形参的改变不影响实参。

• 形参是局部变量，在栈中分配

• 形参的寿命小于实参

函数的用处

函数是重要的==抽象==手段

1. 人类解决复杂问题的法宝：大问题分解为小问题 这就是著名的自顶向下的设计
2. 避免重复做某件事，去掉冗余 (don’t repeat yourself) 重复是恶趣之始 拷贝是万恶之源
3. 消除 if..else 的嵌套，增加可读性 【三数取中】的例子，再次函数版本的实现： 三个数居中 = 两两最大值的最小值
4. 消除 循环嵌套，增加可读性 【九九乘法表】的例子，再次函数版实现

// 输出乘法表的某一项
// row: 行号，i: 列号
void t99_item(int row, int i)
{
    cout << i << "x" << row << "=" << row * i;
}
// 输出乘法表的一行
// row: 行号
void t99_row(int row)
{
    for(int i=1; i<=row; i++){
        t99_item(row,i);
        cout << " ";
    }
}
int main()
{
    for(int i=1; i<=9; i++){
        t99_row(i);
        cout << endl;
    }
    return 0;
}

返回值

返回值可以没有， 类型写 void 有返回值的时候，调用方也可以当作没有来用。 有返回值的时候，忘记了返回会怎样？

实时效果反馈

1.关于函数的说法，错误的是：

• A 使用函数可以避免重复代码

• B 使用函数可以把使程序更容易读懂

• C 使用函数可以把大问题分解为小问题

• D 使用函数可以提高执行速度

2. 下列关于返回值的说法，正确的是：

• A 有返回值的函数，调用方必须接收返回值

• B 没有返回值的函数，调用方也可以假装接收返回值

• C 有返回值的函数，如果忘记了返回，会返回默认值

• D c++只能返回一次值（不能多个）

答案

1=>D 2=>D

指针入门

指针就是存放其它变量地址的小盒子 所说的地址，是虚拟内存的地址，本质上就是整数，默认以十六进制表示

指针的定义

类型 * 指针名 初始化： 指针 = &某变量

通过指针，访问被指向的变量

可以读取 myxx = *p; 也可以写入 *p = ... 要十分谨慎 通过指针写入是危险的，这是c++强大的原因，也是bug发源地

可以在参数中使用指针

形参是指针类型时，可以改变实参的值 我们可以利用这个特性，间接地实现多个返回值。

【示例】 交换连个变量

void swap(int* a, int* b)
{
    int t = *a;
    *a = *b;
    *b = t;
}

【示例】 改写三数居中的例子，使用冒泡排序法 冒泡排序： 如果相邻的连个元素逆序，则交换它们 多次重复这个动作 伪代码如下：

int mid(int a, int b, int c)
{
    // 我们心中的目标是： a <= b <= c
    if(a > b) 交换a,b
    if(b > c) 交换b,c
    ...
}

可以返回指针类型

避免返回局部变量的地址

int* f(){
    int a = 100;
    //....
    return &a;
}
int main(){
    int* p = f();
    ....
}

当我们拿到返回值的时候，变量 a 已经被释放了。 我们的指针指向了已经无效的内存，产生了：悬挂指针 这是很常见的bug之源

实时效果反馈

1.对指针类型，说法正确的是？ __

• A 虚拟内存的地址，本质上就是整数

• B 对 cpu 的一种特殊的指令

• C 程序的特殊区域

• D c++语言独有的秘密武器

2. 悬挂指针是怎么产生的？

• A 一个指针长时间没用，被回收了

• B 一个指针指向了无效的内存

• C 一个指针，其值为0

• D 一个指针，长夜漫漫，黯然神伤

答案

1=>A 2=>B

引用类型

引用在语义上看，是：别名机制 在实现上，被转换为对指针的操作。

int a = 100;
int& b = a;
b++;  //实际上就是 a++

变量可以看作是：内存中小盒子， 变量名可以看作是盒子的标签 引用则可以想象为盒子上的另一个标签 就是说，一个盒子有多少个名字

有了指针，为什么还要引入别名？

1. 为了语义上更清晰，更接近人的思考习惯。 【改写】 swap 函数

   void swap(int& a, int& b)
   {
       int t = a;
       a = b;
       b = t;
   }
   int main()
   {
       int a = 5, b = 8;
       swap(a, b);
       cout << a << "," << b << endl;
       return 0;
   }

2. 引用是不能运算的（比如++，—），只能去引用原来的值 相当于给“指针”这匹野马，套上约束，使用上更安全。

3. 不存在空引用，但空指针很普遍，是bug之源

4. 创建时初始化，不存在随机垃圾内存现象

5. 引用绑定了一个目标，不能中途更换，指针随便

引用可以作为函数参数，也可以是返回值

当作形参时，可以看作实参的别名 当作返回值时，注意不要引用已经释放的变量

返回不存在的对象的引用，与返回不存在的对象的指针，都是典型的错误。

实现多返回

表面上看，c++的函数只能返回一个值，无法实现多值返回。

实际上，我们可以变通。

【示例】 通过引用实现返回多个值的效果 编写一个函数，传入a,b，返回a除以b的商，和余数

提示：可以用参数接收返回值。

实时效果反馈

1.引用和指针的关系：

• A 引用比指针操作更快

• B 引用比指针有更多的操作，功能更强大

• C 引用总是比指针更省内存

• D 引用比指针更安全，更人性化

2. 哪个==不是==使用引用的优点

• A 必须初始化，不可能有垃圾值

• B 无法更换绑定的变量，防止误操作

• C 不能进行++ —的运算，更安全

• D 看起来更酷，更唬人

答案

1=>D 2=>D

数组入门

数组的由来

1. 3个数求最大值

   int a=5, b=2, c=8;
   int m = a;
   if(b>m) m = b;
   if(c>m) m = c;

1. 10个数求最大值

   不可能定义 10 个变量啊！！

   。。。要不 100 个数？？

   int a[9] = {9,7,2,5,3,6,1,4,8};
   int m = a[0];
   for(int i=1; i<9; i++){
    if(a[i]>m) m = a[i];
   }
   cout << m << endl;

1. 一个变量名，能操纵多个变量

   • 通过==下标==（index）来操纵每个元素

   • 下标从==0==开始到==n-1==

   • 可以对元素==读==，也可以==写==

     ... = a[5];   // 读取
     a[5] = ...    // 写入

​ 当心！ ​ c++ 不会去保证下标合理（不做运行时检查）

数组是什么？

数组就是存在一起的一组相同类型的变量

int a[3]; //定义含有三个元素的整型数组

1. 每个变量的地址是==紧挨着==的
2. 每个变量都是==相同==的类型（意味着占用相同大小的空间）
3. 只有一个名字，才能==统一==操作

数组存在哪里？

答曰：栈

（更严格地说，还可以是静态空间，比如：全局数组）

• 一般情况下，数组是局部变量

• 局部变量在==栈==中分配空间

• 自动分配，自动释放

怎么知道数组占用多大空间？

两种方案？

1. 元素个数 x 单个元素的大小

   #define N 100
   ...
   int a[N];
   x = sizeof(int) * N;

1. sizeof(数组变量名)

   #define N 100
   ...
   int a[N];
   x = sizeof(a);

元素初始化

1. 指定元素个数

   int a[3] = {10,20,50};

1. 不指定元素个数（自动推断）

   int a[] = {3,6,9};

1. 指定值的个数少于元素个数

   int a[10] = {10,20,30};

   当心！

   没有赋初始值的元素是==随机值==

拓展

1. ==长定==数组，就是数组创建后，大小就==固定==了，无法改变

   • 通常，大小直接常数，或define一个常数（==定长==数组，编译器知道大小）

     // 怎样避免魔法数字？？
     #define N 10   // 老方案
     const int N = 10;  // 新方案（提倡）

• c++99 中允许使用==变量==（运行时求值）

  int n = f(2)+@$@#$@!...;  //一顿操作猛如虎，最后得到一个数
  int a[n];  // 初始化免谈，因为编译器也不知道到底有多大！！

1. 动态数组是：开始时有个==初始==大小，将来可以==按需==扩大或缩小

   许多高级语言中的数组就是这个。

   通过==重新分配==内存，并==拷贝==旧的内容来实现。

实时效果反馈

1.下列说法正确的是__

• A 数组的大小一经创建就无法改变了

• B 数组中可以包含不同类型的数据

• C 数组在定义时，必须赋给初始值

• D 如果不对数组赋初始值，其值为0

2.对数组的下标，说法==错误==的是__

• A 数组的下标总是从 0 开始

• B 数组的下标最大为：元素个数-1

• C 当访问a[N]的时候（N是数组a的大小），会产生下标越界

• D 可以使用负数下标

答案

1=>A 2=>D

函数进阶

• 数学上的函数是：

输入数据 ===> 函数（加工机器） ===>吐出一个值

• 程序中的函数行为更复杂

  主要表现在函数执行时，可能会影响调用者

  也叫“副作用”

被调方（callee）如何影响主调方（caller）

1. 返回值

   这是最正经的渠道，调用方自己来决定如何使用返回值

   可以：

   x = f(...)  // 接收返回值

   也可以：丢弃

2. 指针参数

   参数类型为指针的话，就复杂了，callee 直接操刀。。。

3. 形参是：指针的指针

   比如： int** p

   这个就更恐怖了，实质与前述相同

4. 形参是：引用

   这个看着唬人，实际上最后，还是转换为指针的方案

指针形参

这种方式，好比调用方准备了一个盒子，把盒子地址传过去，被调方往里塞东西

讨饭的例子。。。

其本质是：两个指针指向同一个东西

void f(int* p) { *p = .... }
....
int x = ...
int* a = &x;
f(a);

【示例】数组排序

冒泡排序法

每一趟排序，把最大的归位

核心代码：

void bubble_sort(int* a, const int N)
{
    for(int j=0; j<N-1; j++){
        for(int i=0; i<N-j-1; i++){
            if(a[i]>a[i+1]) swap(a[i],a[i+1]);
        }
    }
}
// 调用方：
int a[] = {3,5,9,2,1,4,6};
bubble_sort(a, sizeof(a) / sizeof(int));

指针的指针形参

这是为了修改调用方指针本身（不是指针指向的值），使得它指向所需的内容

【示例】

准备一个整数数组，准备2个指针 p 和 q

调用函数 f 后，使得p指向==第一个==负数，q指向==最后一个==负数

void f(int* a, const int N, int** p, int** q)
{
    for(int i=0; i<N; i++){
        if(a[i]<0) {
            *p = &a[i];
            break;
        }
    }
    for(int i=N-1; i>=0; i--){
        if(a[i]<0){
            *q = &a[i];
            break;
        }
    }
}

来看调用方

int a[] = {3, 5, -3, 9, -5, 2, 1, -1, -2, 4, 6};
const int N = sizeof(a) / sizeof(int);
int *p, *q;  // int* p, q;
f(a, N, &p, &q);
cout << *p << ", " << *q << endl;

有的人晕车，有的人晕船，。。。

c/c++程序员==不能==晕指针，那好比美丽的鸟儿有==恐高症==。

秘诀：

只要对照这两个例子，找共性。

• 要回填的值是什么类型？ 比如是 A

  。。。我们要修改A类型的东西。。。那么，要通知别人什么信息？。。。。

• 传递的参数是什么类型？必然是：A*

• 当 A = int 时，我们得到了 `int*`

实时效果反馈

1.下列关于冒泡排序，说法正确的是__

• A 100个元素冒泡排序，共需要比较99次

• B 100个元素冒泡排序，需要比较99 + 98 + 97 + … + 1 次

• C 一趟冒泡排序可以找到最大值和最小值

• D 完全逆序的数据，需要更多的比较次数

2.示例题目中，我们使用了指针的指针，目的是__

• A 让一个指针，指向另一个指针

• B 取得指针的地址

• C 回填一个指针类型的数据

• D 炫耀一下指针的颜值

答案

1=>B 2=>C

数组与指针进阶

子曰：了解事物本质的方法是：观察事物的行为

数组名字的本质

1. 准备两个数组 a, b，一个指针 p

2. 观察下面的实验：

   int a[3] = {1, 2, 3};
   int b[3] = {1, 2, 3};
   int* p = a;
   cout << (a == b) << endl; // == 的含义？
   cout << a << endl;
   cout << b << endl;
   cout << p << endl;
   a = b;  //编译不过去！
   cout << sizeof(a) << "," << sizeof(p) << endl;

1. 观察如下实验：

   int a[3] = {1,2,3};
   cout << a << endl;   // 它的值是多少？类型？等同不？
   cout << &a << endl;
   cout << &a[0] << endl;  // &(a[0])

   结果相同，这三者==等同==不？

2. 观察如下实验：

   int a[3] = {1,2,3};
   cout << a << endl;
   cout << &a << endl;
   cout << a + 1 << endl;
   cout << &a + 1 << endl;
   cout << (a == &a) << endl;

1. 思考与结论：

   数组不会作为整体来==比较==，或者==赋值==，输出的时候，与指针无二

   数组名不能被赋值，它只是编译器记录的信息，不是变量。

   数组名取大小，包含了数组长度信息；赋值给指针，则==丢掉==了这个信息

   数组名取地址，得到一个指向整个数组类型的==指针==

重点：

• 指针的==值==，决定了它指向哪块数据

• 指针的==类型==，决定了它的运算行为（比如 +1 的行为）

数组作为参数传递

子曰: 真知来源于实践

做下面的实验：

指针的运算

探究：p + 1 的含义

int a;
int* p = &a; cout << p << endl;
p++; cout << p << endl;
char b;
char* q = &b; cout << q << endl;
q++; cout << q << endl;

结论：

p + n 真实的增量是 n * sizeof(单个元素)

指针运算与[ ]运算的等效性

*(p + n) === p[n]

*p === p[0]

请反复验证:

指针可以当数组用；数组也可以当指针用

子曰：c语言中本没有数组，它只是指针的幻影

拓展：数组引用（用作参数的时候，有区别）

//作为形式参数时：
int (&p)[3]  //携带了长度信息
int p[3], int p[], int* p //是等同的

实时效果反馈

1.a是整型数组，int* p = a+1 的含义是__

• A 与 int* p = &a[1]; 等同

• B 把数组 a 的第二个元素赋值给 p

• C 把表示数组的首地址的整数加 1，给了p

• D 把数组中的每个元素都加 1, 并把数组地址给 p

2.对于函数 void f(int p[3]), 说法正确的是__

• A 调用时，必须传入一个含有三个元素的整型数组

• B 函数内部：sizeof(p) 会返回 12

• C 函数内部用 *(p+1) = … 是错误的写法，应该： p[1] = …

• D 调用时，传入任何 int* 类型的实参，都能编译通过

答案

1=>A 2=>D

数组元素搬运

数组的拷贝

// 错误的拷贝方案
int a = {1,2,3};
int b = {7,8,9};
a = b;

需要自己定义函数 mycopy

mycopy(…) 如何安排 mycopy 的参数？关键是==长度==信息。

两种设计风格：

// 目标指针，源指针，拷贝个数
void mycopy(int* dst, int* src, const int n);

// 目标指针，源指针，源阻拦索
void mycopy(int* dst, int* src, int* src_end)；`

它们都很灵活，可以支持部分拷贝

void mycopy(int* dst, int* src, int* src_end)
{
    for(int* p = src; p < src_end; p++) *dst++ = *p;
}
void mycopy(int* dst, int* src, const int n)
{
    for(int i=0; i<n; i++) dst[i] = src[i];
}
void show(int* a, const int n)
{
    for(int i=0; i<n; i++) cout << a[i] << " ";
    cout << endl;
}
int main()
{
    int a[] = {1,2,3,4,5};
    int b[] = {10,20,30,40,50,60};
    //mycopy(b+2, a+2, 3);
    mycopy(b+2, a+2, a+2+3);
    show(b,6);
    return 0;
}

数组拷贝大坑—overlap

当源位置与目标位置==重叠==的时候，我们的代码失效了

秘诀 拷贝的次序很重要！！

void mycopy(int* dst, int* src, int* src_end)
{
    if(dst==src) return;
    int n = src_end - src;
    if(dst>src)
        for(int i=n-1; i>=0; i--) dst[i] = src[i];
    else
        for(int i=0; i<n; i++) dst[i] = src[i];
}

数组元素的删除

• 数组元素的删除，就是把元素后面的内容，向前平移（本质=overlap拷贝）

数组元素的插入

• 插入一个元素，就意味着：需要把那个位置开始的后面内容，向后平移
• 本质是向后平移，空出位置

注意：

数组的结构决定了，它不适用于频繁地插入和删除，尤其数组很大的时候

如果需要，我们可以使用：==链表==，==哈希表==，==块链==等更复杂的结构

实时效果反馈

1.怎样把数组元素，正确地从地址A，搬运到地址B

• A 从低地址到高地址拷贝每个元素

• B 从高地址到低地址拷贝每个元素

• C 先拷贝中间地址重叠的部分，后拷贝两边的

• D 根据 A, B 的位置关系，决定拷贝的次序

2.关于向数组中插入元素, 说法正确的是__

• A 调用 a.insert(索引，值);

• B 插入元素后，数组变大了

• C 先要把插入位置开始的元素都向后移动，为新来的元素腾出空间

• D 在数组的任何位置插入新元素都是相同的代价

答案

1=>D 2=>C

插入排序法

问题：

给定一个数组，用简单插入法，排序。（模拟，扑克牌抓牌的动作）

要点 把一个元素插入到有序的表中，并让表的长度增长

方案

我们尽量不利用额外的空间。

1. 可以把数组分开成两个区域，左边是排好序的，右边是待排序的。
2. 从右边拿一个数，插入左边适当的位置
   • 寻找恰当的位置
   • 把那个位置的数据向后平移
   • 放入插入的数据
3. 重复2，直到没有剩余数据

场景

实现

int* find_pos(int* begin, int* end, int x)
{
    for(int* p = begin; p<end; p++){
        if(*p >= x) return p;
    }
    return NULL;
}
void mycopy(int* dst, int* src, int* src_end)
{
    if(dst==src) return;
    int n = src_end - src;
    if(dst>src)
        for(int i=n-1; i>=0; i--) dst[i] = src[i];
    else
        for(int i=0; i<n; i++) dst[i] = src[i];
}
void mysort(int* a, const int N)
{
    for(int*p=a; p<a+N; p++){
        int t = *p;
        int* q = find_pos(a, p, t);
        if(q!=NULL){
            mycopy(q+1, q, p);
            *q = t;
        }
    }
}

拓展

简单插入排序，比较的次数很多

我们可以采用==折半查找==来提高效率

实时效果反馈

1.关于简单插入排序，说法正确的是__

• A 排序较慢，且与待排的数据情况无关

• B 当数据基本有序时，排序会更快

• C 当数据是==逆序==时，排序更快

• D 当数据都相同的时候，排序最慢

2.关于空指针，正确的说法是__

• A 空指针也是一个普通的指针，其值为0

• B 空指针不指向任何位置

• C 空指针指向它自己

• D 空指针指向NULL

答案

1=>B 2=>A

二维数组

二维数组的存储规律

列优先，存完第一行，存第二行，。。。

二维数组元素访问方法

a[行号][列号] = ...

【示例】，填写一个数组，如下数据：

可以利用存储关系，用一维方式来填充

int a[3][6];
int *p = &a[0][0];  // == &(a[0][0])
for(int i=0; i<sizeof(a)/sizeof(int); i++) p[i] = i+1;

传递给函数的参数类型

弄清这几个类型：

【实战1】

// 已知二维数组中的字母阵列，请输出如下图形：
A B C D
E F G H 
I J K L

【实战2】

二维数组边沿初始化

把边数组的”边框“清零

void show(int* a, const int W, const int H)
{
    for(int j=0; j<H; j++){
        for(int i=0; i<W; i++){
            cout << a[j*W+i] << " ";
        }
        cout << endl;
    }
}
void clear_border(int* a, const int W, const int H)
{
    for(int j=0; j<H; j++){
        for(int i=0; i<W; i++){
            if(i>0 && i<W-1 && j>0 && j<H-1) continue;
            a[j*W+i] = 0;
        }
    }
}
//..... 调用处：
    int a[3][6];
    int *p = &a[0][0];  // == &(a[0][0])
    for(int i=0; i<sizeof(a)/sizeof(int); i++) p[i] = i+1;
    clear_border(&a[0][0],6,3);
    show((int*)a,6,3);

实时效果反馈

1.关于二维数组，说法正确的是__

• A 二维数组就是一个数组的元素本身又是数组

• B 二维数组中，每行的元素个数可以不同

• C 二维数组的数据可能分别存储在多个位置

• D 二维数组作为参数类型传入函数时，保持了宽度和高度信息

2.二维数组的第x个元素，所在的列号算法是：

• A x / 数组宽度

• B x % 数组宽度

• C x / 数组高度

• D x % 数组高度

答案

1=>A 2=>B

动态内存分配

内存的分配与释放

栈空间(stack)的分配与释放是自动进行的，是隐式的

堆空间(heap)的分配与释放是代码显式操作行为

堆像辽阔的海滩，我们可以随意挖坑，也别忘记了填坑。

有的坑特别巨大，有的很小，有的保留一年，有的三秒消失…..

使用场合（目的）

• 不能事先确定需要多少空间，以及需要占用多久

  • 比较栈：事先可以确定变量到底占用多少空间，也能确定用多久。

  （后来的必定比先来的短命）

• 需要的空间太大，栈不够用

内存的管理的一般原则：谁申请，谁释放。但有时无奈。

函数的设计模式，当我需要一些数据（好比需要一些肉），

1. 直接返回在栈中，用完即可自动释放

1. 调用方提供空间，并负责释放：”把肉放在我的碗里“

1. 函数方提供碗和肉，调用方使用完毕后，别忘记归还碗（动态申请的最普遍用法）

使用方法

malloc用法：

void* malloc(申请字节数);

需要include头，一般可以用 stdlib

• 需要自己计算到底需要多少字节内存
• 返回的指针需要强制
• 不会做初始化，返回的内存中的内容是随机值
• 配合 free, 千万不要忘记释放

int a[3] = {10,20,30};
int* b = (int*)malloc(sizeof(int) * 3);
for(int i=0; i<3; i++) b[i] = a[i];
cout << b[2] << endl;
free(b);

new/delete 用法：

• new 类型 [ 个数]；
• 返回元素类型的指针，不用强制转换
• 配合 delete [ ] 使用

==当心！== 释放时，别忘记了方括号

int a[3] = {10,20,30};
//int* b = (int*)malloc(sizeof(int) * 3);
int* b = new int [3];
for(int i=0; i<3; i++) b[i] = a[i];
cout << b[2] << endl;
//free(b);
delete [] b;

实例

设计一个函数，传入整数，返回所有的因子

例如：传入30，则返回 [2,3,5,6,10,15]

设计策略，被调用方动态分配内存，主调方用完释放。

int* get_factor(int x)
{
    int n = 1; // 多分配一个用于结束标志
    for(int i=2; i<x; i++) if(x%i==0) n++;
    int* data = (int*)malloc(n * sizeof(int));
    n = 0;
    for(int i=2; i<x; i++) if(x%i==0) data[n++] = i;
    data[n] = -1;
    return data;
}
// 以下是调用方：
    int* a = get_factor(60);
    for(int* p=a; *p>0; p++) cout << *p << " ";
    cout << endl;
    free(a);

拓展：

calloc 的用处： 需要初始化时

realloc 的用处： 惯例内存惯例时

实时效果反馈

1.malloc和new的区别，说法正确的是__

• A new是在静态空间中分配内存，malloc在堆空间分配

• B new初始化内存，malloc不初始化

• C new返回正确的类型，malloc总是返回void*

• D 为数组开辟空间，必须用 new [ ]

2.如果在函数中返回动态分配的内存，怎样告诉主调方内存大小呢？：

• A 可以用 sizeof(指针)的方式求取

• B 可以通过在内存结尾放特殊标志通知主调方

• C 可以返回两个值（指针和大小）

• D 可以返回指针与大小的和

答案

1=>C 2=>B

筛法求素数

到目前，最古老的筛法，仍然是求素数的最有效解法之一。

普通素数算法

核心是：bool is_prime(int x) 如果 x 是素数，就返回 true

bool is_prime(int x)
{
    for(int i=2; i<x; i++) if(x%i==0) return false;
    return true;
}

小知识

素数的密度， 当n很大时，在 n 附近为: $$ p(n) = \frac{1}{ln(n)} $$ 也就是说，在10000附近，大约 ln(10000) ~= 9.2 个数中出现一个素数

n 越大，这个数字越准确。

筛法

【示例】求第1000000(百万)个素数

在数组中放入自然数，划掉2的倍数，。。。

从2开始，找到第一个没有划掉的数 3，划掉所有3的倍数

。。。

// 把p指向位置数字的整数倍划去
void put_tag(int* p, int* end)
{
    for(int*q = p + *p; q<end; q += *p) *q = -1;
}
// 从当前位置找一个最靠近的没有划去的数字
int* next_pos(int* p, int* end)
{
    while(++p<end && *p <0);
    return p<end ? p : NULL;
}
// 取得第 x 个素数
int get_nth(int x)
{
    const int N = x * 20;  //需要筛选 N 个数字
    int* a = new int [N];  // 堆上分配
    for(int i=0; i<N; i++) a[i] = i+2;  //初始化
    int* p = a;  // 标尺，即将标记它的所有倍数
    while(p!=NULL){
        put_tag(p, a+N);
        p = next_pos(p, a+N);  // 指向下一个没有被划掉的数
    }
    int t = -1;
    for(int i=0; i<N; i++){
        if(a[i] > 0) x--;
        if(x==0) {
            t = a[i];
            break;
        }
    }
    delete [] a;
    return t;
}

实时效果反馈

1.素数的出现规律是__

• A 素数的出现不确定，没有一定规律

• B 在某个局部没有规律，但总体上数越大越稀少

• C 按指数规律减少

• D 按线性规律减少

2. 求第n个素数时，为什么要动态分配内存？

• A 因为不确定需要多少内存

• B 这个内存需要一直保留，函数返回也不释放

• C 内存的申请者和释放者不在同一函数里

• D 内存可能很大，栈空间不够

答案

1=>B 2=>D

指针数组与数组指针

指针数组

指针数组是一个数组，它的每个元素都是指针，这个指针可以是任何类型

当然，也可以是指向另一个数组的指针（可以仿造出类似java中的不等长数组）

int* p[9];  // p 是含有9个元素的数组，每个元素类型为 int*
p[0] = new int[1]; // 第一个指针指向：一个元素的数组
p[1] = new int[2]; // 第二个指针指向：二个元素的数组

【示例】用指针数组，保存如下的三角矩阵：

这只是用于教学的例子，当只有这么少的数据的时候，没有必要大动干戈

这里假设我们锱铢必较，一定要节省每一个字节的内存

int** get_table()
{
    int **p = new int* [9+1]; //多分配一个，末尾存NULL
    for(int j=0; j<9; j++){
        p[j] = new int[j+1+1]; //多分配一个，开始存个数
        p[j][0] = j+1;
        for(int i=1; i<j+1+1; i++) p[j][i] = i*(j+1);
    }
    p[9] = NULL;
    return p;
}

注意： 当我们返回给调用者一个动态申请的内存时，需要想办法告诉它内存的大小信息。

因为，返回的指针本身不携带任何额外信息。

调用方，用完如何释放

int** p = get_table();
cout << (p[4])[0] << endl;
for(int** q=p; *q; q++) delete [] *q;
delete [] p;

数组指针

相对而言，数组指针用的比较少。

它的定义形如： int (*p)[5]

它的类型是： int (*)[5]

这里，使用括号，是因为：[ ]的优先级高

用途

可以用于，指向二维数组中的第二维数组；

它本身携带了宽度信息（不是指针携带，是指针类型携带，这个类型是给编译器看的）。

但，鉴于它==怪异==的类型，一般初学者不喜欢，宁可多传递一个宽度信息。

【示例】修改二维数组每行的第一个数

//n 是二维数组的高度信息，宽度信息在指针类型中携带了
void f(int (*p)[3], int n)  
{
    for(int i=0; i<n; i++){
        p[i][0] *= p[i][0];
    }
}

调用方：

int a[3][3] = {{1,2,3},{4,5,6},{7,8,9}};
f(a,3);
cout << a[2][0];

其实，int (*p)[5] 与 int p[][5] 是等价的。

与int p[100][5]也是等价的，100被编译器忽略了

自己动手替换一下试试看。

实时效果反馈

1.关于指针数组，正确的说法是__

• A 指针数组是说：一个指针，可以当数组用

• B 指针数组是说：一个指针，指向了数组

• C 指针数组是一个装满了指针的数组

• D 指针数组是一个二维数组

2. 当作为形参时，下列哪个类型定义是数组指针？

• A int** p

• B char (p)[5]

• C char* p[5]

• D (int*) p[5]

答案

1=>C 2=>B

const 修饰符

修饰的花样

const 可以放在被修饰类型的左边或右边，默认是向左结合的

• 当修饰普通变量的时候

const int M = 5;
int const N = 6;  // 本来这个是标准写法，但看着别扭