原来的写法

int score1 = 82, score2 = 95;
int score3 = 76, score4 = 88;
int score5 = 91;

求和还能写出来；如果要读取第 k 个分数呢？

给一组数据一个名字

每条语句都落在一个格子上

int a[5] = {10, 20, 30, 40, 50};
a[2] = 99;
cout << a[0] << " " << a[2];

只改第三个元素

10 99

先独立判断

下面的输出是什么？

int a[4] = {4, 7, 2, 9};
int i = 1;
cout << a[i + 1];

选择并说明理由

建议的起步习惯

int count[10] = {};
// 然后再做 count[x]++

计数、累加等操作，需要先给出可靠初值。

需要避开的写法

int count[10];
// 不要直接 count[3]++

未初始化的局部整型元素不能直接读取；不能指望得到某个固定“随机数”。

容量

定义时准备了 8 个格子。

当前有效数据

只读入了 3 个数，后续只处理 a[0] 到 a[2]。

本例 0≤n≤100，数值在 ±1000 内

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

输入顺序对应下标

从最后一个有效元素开始

for (int i=n-1; i>=0; i--)
    cout << a[i] << " ";

本例 i 用有符号 int；n=0 时从 -1 开始，不执行循环。

数组本身没有被改动

1 6 3 8

每经过一格，加入总和

long long sum = 0;
for (int i=0; i<n; i++)
    sum += a[i];
cout << sum;

用 8、3、6、1 手推

本例保证至少有一个数

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

为什么不直接从 0 开始？

线性查找的核心

int pos = -1;
for (int i=0; i<n; i++) {
    if (a[i] == target) {
        pos = i;
        break;
    }
}

本例 target=6

先独立判断

a 的容量为 5，n=5。下面的循环有什么问题？

for (int i=0; i<=n; i++)
    cout << a[i];

选择并说明理由

一个字符

char c = 'A';
cout << c;

一串字符

char s[] = "Cat";
cout << s;

先独立判断

下面两项分别是多少？

char s[8] = "code";
// sizeof(s) 和 strlen(s)

选择并说明理由

为字符数组限制输入长度

char s[20];
cin >> setw(20) >> s;
cout << s;

需要 <iomanip>；最多保存 19 个输入字符，再留一个 \0。

遇到空格停止

hello

本例一行至多 19 个字符

char s[20];
if (cin.getline(s, 20))
    cout << s;
else
    cout << "too long";

换行是边界，不是内容

hello world

本例已保证 s 正确终止

for (int i=0; s[i]!='\0'; i++)
    cout << s[i] << '\n';

末尾的 \0 不输出

C
a
t

需要 <cstring>

char s[20] = "hello";
cout << strlen(s);

返回的是长度

5

从这里读

写到这里

追加前

char s[12] = "red";
strcat(s, "blue");

追加后

redblue

输入长度在 0～19 之间

int len = static_cast<int>(strlen(s));
for (int i=len-1; i>=0; i--)
    cout << s[i];

边界分别想一遍

• 空串：len=0，i=-1，不进入循环。
• 一个字符：只访问 s[0]。
• 倒序访问不会自动改变原字符串。

先独立判断

这段程序的目标容量是否足够？

char s[6] = "cat";
// 想追加 "dog"

选择并说明理由

本例按 ASCII 英文字母处理

for(int i=0;s[i]!='\0';i++) {
    if(s[i]>='a' && s[i]<='z')
        s[i]=s[i]-'a'+'A';
}

数字、空格和标点保持原样

HELLO, J2!

本课主要处理

ASCII 兼容的英文字母、数字、标点和空格。

遇到 UTF-8 中文时

一个汉字通常占多个字节；逐字节大小写转换或倒序，不能直接当作“逐汉字”处理。

输入输出都能直接用

string s;
cin >> s;
cout << s;

空白分开两个词

hello

第二个词仍在输入流里。

也能读到空行

string s;
getline(cin, s);
cout << s.size() << "\n" << s;

看清字符个数

8
red blue

n 后面的换行还没读走

int n;
cin >> n;
cin.ignore(
    numeric_limits<streamsize>::max(),
    '\n');
string line;
getline(cin, line);

明确“下一行”这个约定

  hello world

两个接口效果一致

string s = "a b";
cout << s.size() << " "
     << s.length();

空格也算一个字符

3 3

只把空格换成下划线

for (size_t i=0; i<s.size(); i++) {
    if (s[i] == ' ') s[i] = '_';
}

每次只动一个下标

a_b_c

先判断，再访问

if (!s.empty()) {
    cout << s[0];
} else {
    cout << "empty";
}

两种等价的判空思路

• s.empty()：是否没有字符。
• s.size()==0：长度是否为 0。
• 读入可能为空时，不要无条件使用 s[0]。

产生一个新结果

string a="red", b="blue";
string c = a + "-" + b;
cout << a << " " << c;

red red-blue

把内容追加到原对象

string a="red";
a += "blue";
a += '!';
cout << a;

redblue!

先独立判断

下面哪个关系成立？

string a="9", b="10";

选择并说明理由

容易误解的判断

if (s.find("cat")) {
    // 不能这样判断是否找到
}

位置 0 转成 false，反而漏掉开头匹配。

明确比较返回标记

if (s.find("cat") != string::npos) {
    cout << "found";
}

每个标题前后都要分隔线

cout << "======\n";
cout << "START\n";
cout << "======\n";

希望程序读起来像这样

line();
cout << "START\n";
line();

函数放在 main 前面

void line() {
    cout << "======\n";
}
int main() {
    line();
    line();
    return 0;
}

两次调用，两次执行

======
======

方式一：先定义，再调用

void line() {
    cout << "======\n";
}
// 后面写 main，调用 line()

方式二：先声明，后面再定义

void line();  // 声明有分号
int main() { line(); }
void line() {
    cout << "======\n";
}

同一层定义，彼此调用

void line() { /* ... */ }
int main() {
    line();
    return 0;
}

不要嵌套定义

int main() {
    // 此处不能再定义 line 函数
    // void line() { ... }
}

函数体里可以调用已经声明的函数。

每次调用，都重新求实参的值

int n = 2;
stars(3);
stars(n);
stars(n+2);

依次输出

***
**
****

函数接收到自己的 x

void change(int x) {
    x = 99;
    cout << x << " ";
}
// main 中：
int a = 7;
change(a);
cout << a;

两份变量，不是同一个格子

99 7

先独立判断

调用结束后，main 中的 n 是多少？

void addOne(int x) { x++; }
// main 中：
int n=5;
addOne(n);
cout << n;

选择并说明理由

一眼能看懂的调用

repeat('*', 5);
repeat('A', 3);

先字符，后次数；与函数定义一致。

应该主动避免

// repeat(5, '*');
// repeat('*');
// repeat('*', 3, 2);

顺序颠倒可能发生类型转换而编译通过；参数缺少或多余通常会编译报错。

函数只负责这一行

void repeat(char c, int count) {
    for(int i=0;i<count;i++)
        cout<<c;
    cout<<'\n';
}

main 安排调用顺序

repeat('=', 8);
cout << "J2\n";
repeat('-', 8);

========
J2
--------

负责显示

void showSum(int a, int b) {
    cout << a+b;
}

调用后屏幕出现文字；调用表达式没有结果值。

负责计算

int add(int a, int b) {
    return a+b;
}

返回一个 int；调用者决定怎么使用它。

先用整数相除，可能已经截断

double average(int a, int b) {
    return (a+b)/2;
}

a=3、b=4 时，先算整数 7/2，结果是 3。

让除法从一开始就是浮点运算

double average(int a, int b) {
    return (a+b)/2.0;
}

3.5

顺着执行路径追踪

int twice(int x) {
    return x*2;
    cout << "after";
}
cout << twice(4);

真正发生的事

8

每条路径都有结果

int absolute(int x) {
    if (x<0) return -x;
    return x;
}

本例 x 在 ±1000 内

有问题的路径

int sign(int x) {
    if (x>0) return 1;
    // x<=0 时走到了末尾
}

一般非 void 函数到达末尾却不返回结果，会导致未定义行为。

先把所有情况列全

int sign(int x) {
    if (x>0) return 1;
    if (x<0) return -1;
    return 0;
}

没有结果值，也能结束这次调用

void show(int n) {
    if (n<0) {
        cout << "invalid";
        return;
    }
    cout << n;
}

注意写法

• void 函数用 return;。
• int 函数用 return 一个 int 结果。
• return 结束函数；break 只退出所在的那层循环。

先独立判断

调用 classify(0) 的返回值是多少？

int classify(int x) {
    if (x>=0) return 1;
    return -1;
}

选择并说明理由

在代码块内声明

int a=3;
{
    int b=5;
    cout << a+b;
}
// 这里不能使用 b

从外向内可见，反向不成立

同名不表示共享

void first() { int x=3; }
void second() { int x=8; }
int main() {
    int x=5;
    first();
    cout << x;
}

这三份 x 互相独立

最近的一层先找到

int x=10;
{
    int x=3;
    cout << x << " ";
}
cout << x;

内层结束，外层重新可见

3 10

外层把一整行包起来

for (int i=1; i<=3; i++) {
    for (int j=1; j<=4; j++)
        cout << "*";
    cout << "\n";
}

3 行，4 列

****
****
****

换行在内层循环结束后，在外层循环内部。

2 行、3 列的执行顺序

这里的行列坐标从 0 开始

for(int i=0;i<2;i++)
    for(int j=0;j<3;j++)
        cout<<i<<","<<j<<" ";

0,0 0,1 0,2 1,0 1,1 1,2

约定 1≤rows,cols≤20

int rows, cols;
cin >> rows >> cols;
for(int i=1;i<=rows;i++) {
    for(int j=1;j<=cols;j++)
        cout<<"*";
    cout<<"\n";
}

两个方向分别控制

*****
*****

只改行数，不会改变每行的星号数。

先列关系表

由表得到边界

for(int i=1;i<=4;i++) {
    for(int j=1;j<=i;j++)
        cout<<"*";
    cout<<"\n";
}

*
**
***
****

n=4 时的关系

从数量推出循环边界

for(int i=1;i<=n;i++) {
    for(int j=1;j<=n-i+1;j++)
        cout<<"*";
    cout<<"\n";
}

****
***
**
*

四条边上输出星号

坐标从 1 开始

bool edge = i==1 || i==rows
         || j==1 || j==cols;
if (edge) cout << "*";
else cout << " ";

下三角，只保留 j≤i

for(int i=1;i<=3;i++) {
    for(int j=1;j<=i;j++)
        cout<<j<<"x"<<i<<"="
            <<i*j<<" ";
    cout<<"\n";
}

先看 3 行版本

1x1=1
1x2=2 2x2=4
1x3=3 2x3=6 3x3=9

循环决定有哪些位置；表达式决定每个位置打印什么。

先独立判断

按代码逐行数一数。

for(int i=1;i<=3;i++)
    for(int j=1;j<=i;j++)
        cout<<"*";

选择并说明理由

a、b 都从 1、2、3 中选

for(int a=1;a<=3;a++)
    for(int b=1;b<=3;b++)
        cout<<a<<","<<b<<" ";

每个格子代表一组选择

有序对 (1,2) 与 (2,1) 是不同选择。

只关心两个不同下标的组合

for(int i=0;i<n;i++)
    for(int j=i+1;j<n;j++)
        cout<<i<<","<<j<<" ";

n=4 时

0,1 0,2 0,3 1,2 1,3 2,3

每一行都在 j=3 前停下

for(int i=1;i<=2;i++) {
    for(int j=1;j<=4;j++) {
        if(j==3) break;
        cout<<j;
    }
    cout<<"\n";
}

外层继续执行下一行

12
12

j=2 时不执行 cout

for(int i=1;i<=2;i++) {
    for(int j=1;j<=3;j++) {
        if(j==2) continue;
        cout<<j;
    }
    cout<<"\n";
}

for 随后仍会执行 j++

13
13

2 行 × 3 列

先找行，再找列

int a[2][3];
// a[1][2]：第 2 行第 3 列

两个下标都从 0 开始。第一对方括号选行，第二对选列。

每一对内层大括号是一行

int a[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};

把代码对应到格子

每行按自己的初值填充

int a[3][4] = {
    {1, 2},
    {3}
};

没有给初值的格子全部为 0

列数仍然给定

int a[][3] = {
    {1,2,3},
    {4,5,6}
};

编译器推导出 2 行，每行 3 个元素。

为什么列数很重要？

每行多宽，决定了这一行如何分组，也决定两个坐标如何定位元素。

先读，再改

int a[2][3]={{1,2,3},{4,5,6}};
cout << a[1][0] << "\n";
a[0][2] = 9;
cout << a[0][2];

只修改第一行第三列

4
9

先独立判断

这句 cout 输出什么？

int a[2][3]={{2,4,6},{8,10,12}};
cout << a[1][1];

选择并说明理由

外层 i，内层 j

for(int i=0;i<2;i++)
    for(int j=0;j<3;j++)
        cout<<a[i][j]<<" ";

访问顺序 1 → 2 → 3 → 4 → 5 → 6

1 2 3 4 5 6

外层 j，内层 i

for(int j=0;j<3;j++)
    for(int i=0;i<2;i++)
        cout<<a[i][j]<<" ";

访问顺序 1 → 4 → 2 → 5 → 3 → 6

1 4 2 5 3 6

本例 1≤n,m≤10，元素在 ±1000 内

int n,m; cin>>n>>m;
int a[10][10] = {};
for(int i=0;i<n;i++)
    for(int j=0;j<m;j++)
        cin>>a[i][j];

输入 n 行，每行 m 个整数

实际使用左上 n×m 个格子；不能拿整块容量当作有效数据。

累加器写在双层循环外

long long sum=0;
for(int i=0;i<n;i++)
    for(int j=0;j<m;j++)
        sum += a[i][j];
cout << sum;

1 到 6 的总和

21

累加器在外层里面初始化

for(int i=0;i<n;i++) {
    int sum=0;
    for(int j=0;j<m;j++)
        sum += a[i][j];
    cout << sum << "\n";
}

每行有自己的结果

6
15

p、q 是合法的行下标

for(int j=0;j<m;j++) {
    int temp=a[p][j];
    a[p][j]=a[q][j];
    a[q][j]=temp;
}

p=0、q=1

列的位置不变，整行数据一起移动。

原表 a：2×3

新表 b：3×2

分散保存

string name[3];
int score[3];
int id[3];

如果只交换 score，不交换 name 和 id，信息就错配了。

把同一人的字段打包

同一种类型，可以创建多个对象

Student a;
Student b;

彼此有各自的成员

a.name 与 b.name 是不同对象的姓名字段；修改其中一个，不会自动修改另一个。

依次对应 name、score、id

Student a{"Ada", 92, 1};
Student b{};

初值列表不是按字段名字猜

本例姓名没有空格

Student s{};
cin >> s.name >> s.score >> s.id;
cout << s.name << " " << s.score;

读入之后，对象完整保存三项数据

Ada 92

先独立判断

下面输出什么？

Student a{"Ada",92,1};
Student b=a;
b.name="Bob";
cout<<a.name;

选择并说明理由

只显示成绩不少于 90 的记录

for(int i=0;i<n;i++) {
    if(students[i].score>=90)
        cout<<students[i].name<<"\n";
}

当前三条记录

Ada
Coco

先成绩降序，再编号升序

bool before(Student a, Student b) {
    if(a.score != b.score)
        return a.score > b.score;
    return a.id < b.id;
}

本例编号互不相同

使用 > 或 <，表达严格在前

return a.score > b.score;

成绩相同就返回 false；反过来比较也应为 false。

不能使用 >= 当降序规则

// 错误：
// return a.score >= b.score;

输入 3 条：姓名、成绩；编号自动生成

成绩降序，编号升序

Coco 92 2
Ada 92 3
Bob 85 1

输入文件示例

12 30

输出文件示例

42

运行工作目录是 /course/run

ifstream fin("sum.in");

不自动等于源文件目录

IDE、终端、评测系统，可能设置不同的工作目录。文件明明存在却打不开时，先检查实际运行位置。

默认打开会截断原有内容

ofstream fout("sum.out");
if (!fout) return 1;
fout << answer << "\n";
fout.flush();
if (!fout) return 1;

对象结束时会自动关闭

局部文件流离开作用域时自动关闭；也可以在需要时主动 close()。

完整程序按这条路线组织

本页示例的约定

• 工作目录有 sum.in。
• 输入两个 ±1000 内的整数。
• 输出 sum.out；重新运行会覆盖它。
• 成功后可打开输出文件核对。

调用前：a=3，b=8

int a=3,b=8;
swap(a,b);
cout<<a<<" "<<b;

8 3

适用对象要有相应交换操作

• 两个 int 变量。
• 两个 string 对象。
• 本课的两个同类型结构体对象。

自己的比较函数

bool bigger(int a,int b) {
    return a>b;
}
sort(a,a+n,bigger);

标准比较器

#include <functional>
sort(a,a+n,greater<int>());

两种写法都表示从大到小；比较时相等要返回 false。

先独立判断

a 容量至少为 6，下面调用会排序哪些下标？

sort(a+2,a+5);

选择并说明理由

单列规则

例如 3+1

   11₂
+  01₂
------
  100₂

个位 1+1 写 0 进 1，下一位再处理进位。

100₂−1₂

  100₂
- 001₂
------
  011₂

用十进制核对

本例 0≤n≤10⁹

int digit[32]={}, count=0;
while(n>0) {
    digit[count++]=n%2;
    n/=2;
}
for(int i=count-1;i>=0;i--)
    cout<<digit[i];

0 要单独处理

if(n==0) {
    cout<<0;
    return 0;
}

按 3 位一组，转八进制

1101011₂
→ 001 | 101 | 011
→   1     5     3
→ 153₈

按 4 位一组，转十六进制

1101011₂
→ 0110 | 1011
→    6      B
→ 6B₁₆

先独立判断

10110₂ 转八进制，哪种分组正确？

// 每个八进制位，对应 3 个二进制位

选择并说明理由

低 8 位翻转示意

只想观察低 8 位，要再加掩码

unsigned int x=13u;
cout << ((~x) & 255u);

242

先独立判断

下面表达式的结果是什么？

5u ^ 3u
// 5 = 00000101
// 3 = 00000011

选择并说明理由

满足约定

异或为 3

7 和 9 各一对，剩下单独的 3。

不满足约定

异或为 0

没有括号，含义走偏

x & 1u == 0u
// 等价分组：
x & (1u == 0u)

先取最低位，再比较

(x & 1u) == 0u

先独立判断

下面表达式的值是多少？

1u << 2 + 1

选择并说明理由

以空白分开的字段

cin >> name >> score;

适合没有空格的姓名等字段。

整行内容，包括中间的空格

getline(cin, line);

之前使用 >> 时，要按输入约定处理剩余换行。

标准输入输出

题目要求标准输入输出时，不保留无条件的文件重定向。

明确要求文件时

按规定的名称和格式读写，确认实际工作目录。

r 进制 → 十进制

value=value*r+digit;

数码合法；从左到右累积；结果不溢出。

十进制 → r 进制

digit=n%r;
n/=r;

余数从低位产生，最后逆序；0 要有明确输出。