资源简介

(共8张PPT)
第
八
课
循环语句之while
循环体
非零
零
表达式
1、while 语句 常称
为“当型”循环语句
注：只要给定的条件为真，
while 循环语句会重复执行
一个目标语句。
例1：显示10到20
int main ()
{
int a = 10; // 局部变量声明
while( a < 20 ) // while 循环执行
{
cout << "a 的值：" << a << endl;
a++;
}
return 0;
}
作业1：
从1加到20的结果是多少？
例 ：求1+2+3+4+5+···+100。
#include
main()
{ int i,sum=0;
i=1;
while(i<=100)
{ sum=sum+i;
i++;
}
printf("%d",sum);
}
循环初值
循环终值
循环变量增值
循环条件
循环体
例2：
例3：计算1到20之间的偶数和？
int main ()
{
int a = 1;
while( a < =20 )
{
if(a%2==0) a++;
}
cout<return 0;
}
作业：计算1到100之间的奇数和？
◆(共11张PPT)
第
二十二
课
结构体的扩展
学习目标
1. 理解运算符重载的含义及其使用。
2. 理解成员函数的含义及其使用。
学习目标：
结构体扩展：
在 C++ 中，由于类（class）技术的出现使结构体功能得到了很大的增强。本课简单介绍一些与信息学竞赛有关的运算符重载和成员函数知识，其他更详细、复杂的内容请参阅相关书籍和资料。
运算符重载
“运算符重载”常用于解决结构体或自定义数据类型的加法、减法等特殊含义的运算。运算符重载的一般格式为：
类型名 operator 运算符 (const 类型名 变量)const{
…
}
例题：
作业统计：
【问题描述】
为了了解学生的课后作业负担情况，需要统计学生连续若干天完成作业所需的总时间。现在，输入某位学生 n 天完成作业的时间，格式为时、分、秒，最后输出这位学生 n 天完成作业的总时间（秒）。
【输入格式】
第 1 行一个正整数 n，表示有 n 天；
第 2~ 第 n+1 行，每行 3 个整数，分别代表时、分、秒。
【输出格式】
一行信息，表示这个学生完成作业的总时间，具体格式见输出样例。
【输入样例】
3
1 20 30
1 20 45
1 19 30
【输出样例】
4hour 0minute 45second
例题分析：
本题需要把若干时间（时、分、秒）相加，但又不是普通的加法运算。所以，可以利用运算符重载，另外定义一个“+”运算，实现对两个结构体变量的加法。
#include
using namespace std;
struct worktime{
// 声明一个结构体类型 worktime 记录学生完成作业的时间
int hr,minut,sec; // hr,minut,sec 分别代表时分秒
worktime operator +(const worktime x)const{ // 对 + 进行重新定义
worktime tmp;
tmp.sec = (sec + x.sec) % 60;
tmp.minut = (minut + x.minut + (sec + x.sec) / 60) % 60;
tmp.hr = hr + x.hr + (minut + x.minut + (sec + x.sec) / 60) / 60;
return tmp; }
};
int main(){
worktime stu,sum;
int n;
cin >> n;
sum.hr = sum.minut = sum.sec = 0;
for(int i = 1; i <= n; i++){
cin >> stu.hr >> stu.minut >> stu.sec;
sum = sum + stu;
// 两个结构体 sum 和 stu 通过重载 + 运算符 进行加法运算
}
cout << sum.hr << ” hour ” << sum.minut << ” minute ” << sum.sec << ” second ” ;
return 0;
}
代码编写：
成员函数
在 C++ 中，允许在结构中定义函数，该函数称为“成员函数”。描述形式如下：
struct 结构名 {
数据成员
成员函数
};
身高问题
例题2：
【问题描述】
输入 n 个学生的信息，每个学生信息包括姓名、身高、学号。编程输出身高最高的学生的信息。
【输入格式】
第 1 行一个正整数 n，表示学生个数，n≤100。
以下 n 行，每一行依次输入学生的姓名、身高、学号。
【输出格式】
输出最高的学生信息，如存在身高一样的请输出学号小的那个同学。
【输入样例】
5
John 172 20160302
David 173 20160306
Jason 168 20160309
Jack 152 20160311
Kitty 147 20160319
【输出样例】
David 173 20160306
代码如下：
#include
using namespace std;
struct stu{
string name;
int heigh;
int num;
void input(){
cin >> name >> heigh >> num;
}
void output(){
cout << name << “ “ << heigh << “ “ << num << endl;
}
};
stu a[110];
int main(){
int n;
stu maxn;
maxn.heigh = maxn.num = 0;
cin >> n;
for(int i = 1; i <= n; i++){
a[i].input();
if(a[i].heigh > maxn.heigh) maxn = a[i];
else if(a[i].heigh == maxn.heigh && a[i].num < maxn.num) maxn = a[i];
}
maxn.output();
return 0;
}(共10张PPT)
第
二十
课
函数综合应用举例
学习目标
1. 熟练应用函数和结构化编程思想解决一些实际问题。
2. 学会函数的单步跟踪，并进一步理解递归函数的执行过程。
学习目标：
例题
例1、孪生素数
【问题描述】
在素数的大家庭中，大小之差为2的两个素数称之为一对“孪生素数”，如3和5、17 和 19 等。请你编程统计出不大于自然数 n 的素数中，孪生素数的对数。
【输入格式】
一行一个正整数 n，1≤n≤2 31 。
【输出格式】
若干行，每行两个整数，之间用一个空格隔开，从小到大输出每一对孪生素数。
【输入样例】
100
例题解析
首先，大于 2 的两个连续自然数不可能都是素数，大于 2 的偶数也一定不是素数。所以，从3 开始穷举一个自然数 s，检查 s 和 s+2 是不是都为素数，是则输出这对孪生素数。然后，s=s+2，继续寻找下一对孪生素数。
代码如下：
#include
using namespace std;
bool prime(int n){
for(int i = 2; i*i <= n; i++)
if(n % i == 0) return false;
return true;
}
int main(){
int n,i = 3;
cin >> n;
while(i <= n-2){
if(prime(i) && prime(i+2)) cout << i << “ “ << i+2 << endl;
i += 2;
}
return 0;
}
例题2
题目描述
输入 x,y(1582≤x题目分析
因为 1582≤x闰年的定义。
可以用数组存下每次从 xx 扫描到 yy 找到的闰年年份；也可以扫描两次，一次计数，一次输出闰年。这里我用了第二种方法。
#include
using namespace std;
int main()
{
int a,b,s=0;//s要清零
cin>>a>>b;
for(register int i=a; i<=b; i++)
if(i%400==0||i%4==0&&i%100)
s++;
cout<for(register int i=a; i<=b; i++)
if(i%400==0||i%4==0&&i%100)//如果是闰年，输出。
cout<return 0;
}
代码编写：
题目描述
输入 n(n\le100)n(n≤100) 个不大于 100000 的整数。
要求全部储存在数组中，去除掉不是质数的数字，依次输出剩余的质数。
例题3
#include
using namespace std;
bool isprime(int n){
if(n<2)return 0;//0和1都不是
for(int i=2;i*i<=n;++i){
if(n%i==0)return 0;//有1和它本身以外的其他因子就不是素数了
}
return 1;}
int a[105];
int main(){
int n;
cin>>n;
for(int i=1;i<=n;++i){
cin>>a[i];//读入数组里的第i个数
if(isprime(a[i]))cout<return 0;
}
代码编写：(共14张PPT)
第
二十六
课
函数指针及扩展
学习目标
1. 理解并学会使用函数指针。
2. 了解函数指针数组。
3. 了解引用与指针的区别。
4. 了解指向结构体的指针。
学习目标：
函数指针及扩展：
程序中需要处理的数据都保存在内存空间，而程序以及函数同样也保存在内存空间，C++支持通过函数的入口地址（指针）访问函数。另一方面，有些函数在编写时要调用其他的辅助函数，但是尚未确定，在具体执行时，再为其传递辅助函数的地址。比如排序函数 sort （a，a+n，cmp），其中的比较函数 cmp 是根据需要传递给 sort 的，就是传递了一个函数指针。
函数指针就是指向函数的指针变量，定义格式如下：
类型名（* 函数名）（参数）;
例题1:
阅读并上机调试以下程序，体会函数指针的使用。
#include
using namespace std;
int test (int a){return a * a;}
int main(){
cout << test << endl; // 或者 &test, 输出函数的地址
int (*fp) (int a); // 声明一个指向函数的指针变量 fp
fp = test; // 或者 &test, 将函数 test 的入口地址传给 fp
cout << fp(5) << endl; // 调用函数
cout << (*fp)(10) << endl;
return 0;
}
使用函数指针注意问题：
：
1）定义函数指针要与函数原型一致。如，函数为“int test (int)；”，则函数指针声明为“int (*fp) (int)；”。
2）获取函数的地址有两种方式：一种是直接使用函数名，如 test 或者 fp = test；另一种是使用取地址符，如 &test 或者 fp = &test。
3）调用函数有两种方式：一种是直接使用函数名，如 fp(5)；另一种是使用函数指针调用函数，如 (*fp)(5)。
4）函数指针还支持一种结合 typedef 的定义方式。参见下一页例1的另一个程序：
5）可以定义一个数组存放多个函数指针。
例题：
阅读并上机调试以下程序。
#include
using namespace std;
int add(int a,int b){return a + b;}
typedef int (*addp)(int,int); // 声明一个函数指针变量 addp
int main(){
addp fp = add;
// 定义 addp 类型的函数指针 fp, 并赋值为 add
cout << fp(2,3) << endl; // 程序输出 5
return 0;
}
例题：模拟计算器
【问题描述】
输入两个正整数 m 和 n，再输入一个代表运算方案的数字 k：
1 代表求 m+n 的值；2 代表求m-n 的值；3 代表求 m×n 的值；
4 代表求 m/n 的值（整除）。请函数指针数组编程模拟计算器，输出相应的运算结果。
【输入格式】
第 1 行为 2 个正整数 m 和 n；
第 2 行为 1 个正整数 k，1≤k≤4。
【输出格式】
一行一个整数，表示相应的运算结果。
【输入样例】
6 8
1
【输出样例】
14
程序代码：
#include
#include
using namespace std;
int cal1(int a,int b){return a + b;}
int cal2(int a,int b){return a - b;}
int cal3(int a,int b){return a * b;}
int cal4(int a,int b){return a / b;}
typedef int (*f)(int a,int b); // 自定义一个函数指针变量类型 f
int main(){
freopen( “ cal.in ” , ” r ” ,stdin);
freopen( “ cal.out ” , ” w ” ,stdout);
int m,n,k;
f a[4] = {cal1,cal2,cal3,cal4};
// 定义函数指针数组 a,4 个元素 , 每个元素为 f 类型 , 并且分别赋初值
cin >> m >> n >> k;
cout << a[k-1](m,n) << endl; // 用 a[k-1]() 来调用相应的函数
return 0;
}
例3：
阅读并上机调试以下程序，体会引用变量的使用。
#include
using namespace std;
int main(){
int a = 10,b = 20;
int *f;
int &ra = a;// 定义一个引用变量 ra, 同时初始化
f = &a;
cout << “ a= ” << *f << endl;
ra += 5;
cout << “ a= ” << *f << endl;
return 0;
}
例题：
阅读并上机调试以下程序，体会引用参数。
#include
using namespace std;
void change1(int &m,int &n){// 引用参数
int t = m;
m = n;
n = t;
return;
}
void change2(int *m,int *n){// 指针参数
int t = *m;
*m = *n;
*n = t;
return;
}
void change3(int m,int n){// 普通变量参数
int t = m;
m = n;
n = t;
return;
}
int main(){
int x = 7,y = 160;
change1(x,y);
cout << x << “ “ << y << endl;
change2(&x,&y);
cout << x << “ “ << y << endl;
change3(x,y);
cout << x << “ “ << y << endl;
return 0;
}
例题：
阅读并上机调试以下程序，体会指向结构体变量的指针。
#include
using namespace std;
struct tstudent{
int num;
char name[20];
char sex;
int age;
};
tstudent x = {13, ” lihao ” , ’ m ’ ,35};
tstudent *p;
int main(){
p = &x;
cout << x.num << endl;
cout << (*p).name << endl;
cout << p->age << endl;
return 0;
}
程序分析
1）运行程序，输出：
13
Lihao
35
2）一个指向结构体变量的指针就是该变量占据的内存空间的起始地址，如图 8.4-1 所示（下一页）。
3）访问结构体成员的方法为：结构体名 . 成员名。
使用指针访问结构体成员有两种方式：结构体名 -> 成员名，或者（* 指针变量名）. 成员名。例如p->name，或者（*p）.name，但不能写成 *p.name。
4）如果函数的参数是一个结构体变量（按值传递），那么函数调用时就要复制整个结构体，效率不高。这种情况下，一般使用指针参数或者引用参数。(共18张PPT)
第
二十三
课
指针的概念
学习目标
1. 理解指针的概念。
2. 学会定义和使用指针。
学习目标：
指针定义：
指针是 C++ 语言的一个重要概念，也是 C++ 语言的重要特色。C++ 语言的高度灵活性及极强的表达能力，在很大程度上表现在巧妙而灵活的运用指针。通过指针可以有效地表示复杂的数据结构；能够方便地处理数组和字符串；能够动态地分配内存，直接对内存地址进行操作；利用指针作为函数参数，能够实现“一次函数调用，有多个返回值”的目的。因此，必须深入学习和理解指针的概念，体会和掌握指针的各种操作，熟练应用指针去实践编程。
指针概念：
对于“int a = 3;”，系统会在内存的某个区域开辟连续4个字节的单元存储。对 a 的操作就是对该内存区域进行操作，至于是具体的哪4个单元，我们并不关心。
内存单元的位置（编号）叫作“地址”，可以通过取地址操作符“&”获得一个变量 a 的起始地址（首个存储单元的地址）：&a。
指针也是一个变量。和普通变量不同的是，指针变量里存储的数据是一个内存地址，就好像一个指示器，指引着你去该内存地址开始的一块内存区域存取数据。
指针的定义和使用
：
指针变量的定义格式为：
数据类型 *指针变量;
可以通过赋值语句给指针变量赋值，例如“p = &a；”表示把变量 a 的内存地址赋值给 p，如图 8.1-1 所示。
指针变量初始化：
int *p = NULL；
例题
例1：数字变化
【问题描述】
输入两个不同的整数，把较小的那个数翻倍并输出。
【输入格式】
一行两个整数（int 范围以内），之间用一个空格隔开。
【输出格式】
一行一个整数，较小数翻倍后的结果。
【输入样例】
2 3
【输出样例】
4
#include
using namespace std;
int main(){
int a,b;
int *p;
cin >> a >> b;
if(a < b) p = &a;
else p = &b;
cout << *p * 2 << endl;
// 取出 p 指向的内存单元里的整数，乘以 2 输出
return 0;
}
代码编写：
例题解析：
1） 变量 a 和 b 一旦定义，系统就会给它们分配内存空间，
而且在程序运行过程中，其内存地址是固定不变的，
这种存储方式称为“静态存储”。
2） 指针变量 p 定义后，其地址空间是不确定的，默认是 NULL。
当执行到 p = &a 或者 p = &b 时，p 才指向 a 或者 b 的地址，才能确定 p 的值。
这种储存方式称为“动态存储”。
3） 指针的动态性，还体现在可以根据需要，通过函数 new（）随时申请。
阅读程序，写出程序的运行结果。
例题2：
#include
using namespace std;
int main(){
int *p;
char *q;
p = new(int);
q = new(char);
*p = 65;
*q = *p;
cout << *p << “ “ << *q << endl;
return 0;
}
例题解析：
1）运行程序，输出结果为“65 A”。
2）程序中声明了两个指针类型：一个指向整数类型的指针 p 和一个指向字符类型的指针 q ，分别通过 new(int) 和 new(char) 为 p 和 q 向内存申请空间。
3）“*p = 65；”把 65 这个整数存放到 p 所指向的内存单元。
4）“*q = *p； ”把 p 所指向的内存单元里的值赋值给 q 所指向的内存单元，由于 q 指向的是一个字符类型，而 p 指向的是一个整数类型，在赋值的时候执行了类型的强制转换，最终 q 所指向的内存单元里存储的是 65 号字符即为 A。
指针理解：
指针类型：
从语法角度看，把指针定义语句里的指针名字去掉，剩下的部分就是这个指针的类型，也就是指针本身所具有的类型。
int *ptr; // 指针的类型是 int *
char *ptr; // 指针的类型是 char *
int **ptr; // 指针的类型是 int **
int (*ptr)[3]; // 指针的类型是 int(*)[3]
int *(*ptr)[4]; // 指针的类型是 int *(*)[4]
指针所指向的类型：
当通过指针来访问指针所指向的内存区域时，指针所指向的类型决定了编译器将把那片内存区域里的内容当作什么来看待。从语法上看，把指针定义语句中的指针名字和名字左边的指针声明符“*”去掉，剩下的就是指针所指向的类型。
int *ptr; // 指针所指向的类型是 int
char *ptr; // 指针所指向的类型是 char
int **ptr; // 指针所指向的类型是 int *
int (*ptr)[3]; // 指针所指向的类型是 int()[3]
int *(*ptr)[4]; // 指针所指向的类型是 int *()[4]
在指针的算术运算中，指针所指向的类型有很大的作用。指针的类型和指针所指向的类型是两个不同的概念。
指针的值：
指针的值是指针本身存储的数值，这个值将被编译器当作一个地址，而不是一般的数值。在位长 32 位的系统中，内存地址都是 32 位的，所以所有类型的指针的值都是一个 32 位整数。指针所指向的内存区域就是从指针的值所代表的那个内存地址开始，长度为sizeof （指针所指向的类型）的一片内存区域。我们说一个指针的值是 X，就相当于说该指针指向了以 X 为首地址的一片内存区域。指针所指向的内存区域和指针所指向的类型是两个完全不同的概念。
指针本身所占据的内存区
用函数 sizeof （指针的类型）测一下就知道了。在 32 位的系统中，指针本身占据了 4 字节的长度。
例题
阅读程序，写出程序的运行结果。
#include
using namespace std;
int main(){
int *p,*q;
p = (int *)malloc(40);
// 动态申请 40 字节用来存放 int 类型，并返回首地址给 p
q = p;
*p = 1;
p++;
*p = 2;
free(q);// 释放刚才申请的 40 字节的空间
return 0;
}
例题解析：
（1）单步跟踪程序，发现执行完“*p = 1;”，q和p为同一个地址，*p和*q的值也都是1。
（2）继续跟踪程序，执行完“*p = 2;”，p 指向了下一个整数空间，在原来的地址上加4，因为一个整型占4个字节。*p 的值也变成了2。
（3）程序中的“free(q);”是释放一开始申请的40个字节的内存空间，是配合malloc()使用。注意释放的是内存，q和p的地址还在，指针并没有被释放，指针仍然指向原来的存储空间。指针是一个变量，只有程序结束时才被销毁。释放了内存空间后，原来指向这块空间的指针还是存在，只不过现在指针指向的内容是未定义的，里面可能会有一些垃圾内容。继续跟踪看看p、q、*p、*q的值。(共12张PPT)
第
二十四
课
指针的引用与运算
学习目标
1. 理解并学会引用指针。
2. 掌握指针的常用运算。
学习目标：
指针的引用：
首先理解指针变量与普通变量的区别和对应关系。例如，定义一个指针变量“int *p；”和一个普通变量“int a；”，关于两者之间的各种引用方式对应关系如下：
1）“p”等同于“&a”，表示的是内存地址。
2）“*p”等同于“a”，表示变量里存储的实际数据。
3）“*p = 3；”等同于“a = 3；”，表示变量的赋值方法。
指针的运算
如果定义的是局部指针变量，其地址就是随机的，直接操作会引发不可预测的错误。所以，指针变量一定要初始化后才能引用。
由于指针变量存储的是内存地址，所以也可以执行加法、减法运算，一般用来配合数组进行寻址操作。
例题：
：
阅读并上机调试以下程序，体会指针变量的加法运算。
#include
using namespace std;
int main(){
int a[100],n;
cin >> n;
for(int i = 0; i < n; i++) cin >> a[i];
int *p = &a[0]; // 指针 p 指向数组首元素的地址
for(int i = 0; i < n; i++){
cout << *p << endl;
p++; // 指针每次往后移动一个区域
}
return 0;
}
例题解析：
1）程序的作用是输入 n 及 n 个整数，使用指针变量依次遍历输出。
2）程序中的“p++” 是广义的“p = p + 1 ”，本质上是“p + sizeof(int)”。
3）注意，“*p+3”和“*（p+3）”是不同的。对于本题，前者是指 a[0]+3，而后者是指 a[3]。
例题2：
【问题描述】
输入 n 个正整数，要求对这 n 个数中的奇数和偶数分别求和。
【输入格式】
第 1 行 1 个正整数 n，1≤n≤5000。
以下 n 行，每行一个正整数（1~20000 之间）。
【输出格式】
2 行 2 个整数。第 1 行为所有奇数之和，第 2 行为所有偶数之和。
【输入样例】
5
3
10
7
5
8
【输出样例】
15
18
代码如下：
#include
using namespace std;
int main(){
int n,a[5011];
int *p,*s1,*s2; //s1 和 s2 指向的单元分别存放偶数和、奇数和
cin >> n;
for(int i = 0; i < n; i++) cin >> a[i];
p = &a[0];
s1 = new(int); // 申请一个存放整数类型的内存空间，把地址记录在 s1 中
*s1 = 0; // 累加器赋初值 0
s2 = new(int); // 申请一个存放整数类型的内存空间，把地址记录在 s2 中
*s2 = 0; // 累加器赋初值 0
for(int i = 0; i < n; i++){
if(*p % 2 == 0) *s1 += *p;
else *s2 += *p;
p++;
}
cout << *s2 << endl << *s1 << endl;
return 0;
}
阅读并上机调试以下程序，体会无类型指针的使用。
例题3：
#include
using namespace std;
int main(){
int a = 10;
double b = 3.5;
void *p;
p = &a;
cout << *(int *)p << endl;
p = &b;
cout << *(double *)p << endl;
return 0;
}
例题4：
阅读并上机调试以下程序，体会多重指针的使用。
#include
using namespace std;
int main(){
int a = 10;
int *p;
int **pp;
p = &a;
pp = &p;
cout << a << “ = ” << *p << “ = ” << **pp << endl;
return 0;
}
作业：
输入一个长度最大为100的字符串，以字符数组的方式储存，再将字符串倒序储存，输出倒序储存后的字符串。(共11张PPT)
第
二十五
课
指针与数组
学习目标
1. 理解数组指针。
2. 学会使用指针实现数组操作。
3. 学会使用指针实现字符串操作。
学习目标：
指针与数组：
在 C++ 中，数组名在一定意义上可以被看成指针。“数组的指针”是指整个数组在内存中的起始地址，“数组元素的指针”是指数组中某个元素所占存储单元的地址。一般可以使用“下标法”访问数组元素，如 a[5]；也可以使用“地址法”访问数组元素，因为数组名就代表数组在内存中的起始地址，也就是 a [0] 的地址，如 a+4 就表示 a [4] 的地址；也可以通过“指针法”访问数组元素，通过数组的指针或者数组元素的指针访问数组元素，能使目标程序质量更高，占用内存更少，运行速度更快。
例题1:
阅读并上机调试以下程序，体会数组的指针和数组元素的指针。
#include
using namespace std;
int main(){
int a[] = {10,11,12,13,14,15};
int *p = a+4;
cout << *a;
cout << “ “ << *(a+3);
cout << “ “ << *(++p) << endl;
return 0;
}
例题解析：
：
1）运行程序，输出“10 13 15”。
2）程序中直接拿数组名 a 当指针用。但是 a 始终是静态的，是不可变的，不能做“a = a+4；”运算，而指针可以做“++p”或“p = p+4；”运算。
3）语句“scanf （ “ %d “ ，&n）；”其实就是指针的意思。如果是数组，就不需要加取地址符“&”。
例题2：
阅读并上机调试以下程序，体会动态数组的定义和使用。
#include
using namespace std;
int main(){
int n,*a;
cin >> n;
a = new int [n];
// 申请 n 个连续的 int 类型内存空间（动态数组），并返回首地址给 a
for(int i = 0; i < n; i++) cin >> a[i];
for(int i = 1; i < n; i++) a[i] += a[i-1];
for(int i = 0; i < n-1; i++) cout << a[i] << “ “ ;
cout << a[n-1] << endl;
return 0;
}
例题分析：
1）运行程序，输入 10 及如下 10 个数“1 2 3 4 5 6 7 8 9 10”，
输出“1 3 6 10 15 21 28 36 45 55”。
2）因为指针可以动态申请空间。那一次申请 100 个变量空间，
系统给的地址是连续的，就可以当成数组使用，这就是“动态数组”的一种。
3）在信息学竞赛中遇到大批量数据的情况下，数组开小只能拿部分分，
开大又可能爆空间，此时就可以定义和使用动态数组。
例题3：
阅读并上机调试以下程序，体会使用指针实现字符串的输入输出及存储。
#include
#include
using namespace std;
int main(){
char *s;
s = new char; // 给 s 申请一个地址
cin >> s; // 输入字符串以空格或者回车结束
cout << s << endl;
cout << strlen(s);
return 0;
}
程序说明：
运行程序，输入“hello world!”。
输出：
hello
5
使用指针实现字符串的输入、输出及存储，与普通数组类似。只是在使用前一定要给字符串变量指定一个地址。
行列转换
作业：
【问题描述】
对于一个 n×m 的稀疏矩阵，按照行、列、值的格式读入 k 个元素（其他位置的值为 0），再输出这些数。
【输入格式】
第 1 行 3 个整数，表示 n、m 和 k，每两个数之间用一个空格隔开。
以下 k 行，按照“行优先（从上到下、从左到右）”的方式读入 k 个非 0 元素。每行 3 个数，依次为行号、列号、元素值，每两个数之间用一个空格隔开。
【输出格式】
输出k个数，按照“列优先（从左到右、从上到下）”的方式输出，每两个数之间用一个空格隔开。
【输入样例】
4 5 3
1 2 12
1 4 23
4 3 45
【输出样例】
12 45 23(共13张PPT)
第
二十一
课
结构体的引入和应用
学习目标
1. 理解结构体的概念和应用背景。
2. 学会使用结构体解决一些实际问题。
学习目标：
结构体：
在存储和处理大批量数据时，一般会使用数组来实现，但是每一个数据的类型及含义必须一样。如果需要把不同类型、不同含义的数据当作一个整体来处理，如 1000 个学生的姓名、性别、年龄、体重、成绩等，怎么处理呢？
C++ 提供了结构体（struct）来解决这类问题。
结构体的定义
C++ 中的结构体是由一系列具有相同类型或不同类型的数据构成的数据集合，也叫结构。
使用结构体，必须要先声明一个结构体类型，再定义和使用结构体变量。结构体类型的声明格式如下：
struct 类型名{
数据类型1 成员名1;
数据类型2 成员名2;
…
};
定义结构体变量
定义结构体变量格式如下：
struct 结构体类型名 变量名列表;
也可以把结构体类型声明和变量定义合在一起，格式如下：
struct 类型名{
数据类型1 成员名1;
数据类型2 成员名2;
…
} 变量名;
结构体的使用
结构体变量具有以下特点：
（1）可以对结构体变量的整体进行操作。
例如：swap(a[i],a[j])
（2）可以对结构体变量的成员进行操作。
引用结构体变量中成员的格式为：
结构体变量名. 成员名
（3）结构体变量的初始化方法与数组类似。
例1、学生信息
【问题描述】
输入一个学生的信息，包括姓名、性别、年龄、体重，再输出这些信息。
【输入格式】
一行，依次是学生的姓名、性别、年龄、体重。
【输出格式】
一行，依次是姓名、性别、年龄、体重（体重保留一位小数）。
【输入样例】
zhangsan m 20 90.5
【输出样例】
zhangsan m 20 90.5
例题1：
#include
using namespace std;
struct student{
string name;
char sex;
int age;
double weight;
};
int main(){
student stu;
cin >> stu.name >> stu.sex >> stu.age >> stu.weight;
cout << stu.name << “ “ << stu.sex << “ “ << stu.age << “ “ ;
cout << fixed << setprecision(1) << stu.weight << endl;
return 0;
}
代码如下：
年龄排序
例题2：
【问题描述】
输入 n 个学生的信息，包括姓名、性别、出生年月。要求按年龄从小到大依次输出这些学生的信息。数据保证没有学生同年同月出生。
【输入格式】
第一行一个整数 n，表示学生人数，n≤100。
接下来 n 行，每一行依次输入学生的姓名、性别、出生年份、出生月份。
【输出格式】
按年龄从小到大，一行输出一个学生的原始信息。
【输入样例】
5
John male 1999 12
David female 1999 8
Jason male 1998 11
Jack female 1998 8
Kitty female 2000 7
【输出样例】
Kitty female 2000 7
John male 1999 12
David female 1999 8
Jason male 1998 11
Jack female 1998 8
代码如下：
#include
using namespace std;
struct stu{string name;
string sex;
int year,month;
};
const int MAXN = 110;
stu a[MAXN];
int main(){
int n;
cin >> n;
for(int i = 1; i <= n; i++)
cin >> a[i].name >> a[i].sex >> a[i].year >> a[i].month;
for(int i = 1; i <= n; i++)
for(int j = i+1; j <= n; j++)
if(a[i].year < a[j].year || a[i].year == a[j].year && a[i].month < a[j].month)
swap(a[i],a[j]);
for(int i = 1; i <= n; i++){
cout<< a[i].name << ” ” << a[i].sex << ” ” ;
cout<< a[i].year << ” ” << a[i].month << endl;
}
return 0;
}
现有 (N≤1000) 名同学，每名同学需要设计一个结构体记录以下信息：学号（不超过 100000 的正整数）、学业成绩和素质拓展成绩（分别是 0 到 100 的整数）、综合分数（实数）。每行读入同学的姓名、学业成绩和素质拓展成绩，并且计算综合分数（分别按照 70% 和 30% 权重累加），存入结构体中。还需要在结构体中定义一个成员函数，返回该结构体对象的学业成绩和素质拓展成绩的总分。
然后需要设计一个函数，其参数是一个学生结构体对象，判断该学生是否“优秀”。优秀的定义是学业和素质拓展成绩总分大于 140140 分，且综合分数不小于 8080 分。
输入格式
第一行一个整数 N。
接下来 N 行，每行 3 个整数，依次代表学号、学业成绩和素质拓展成绩。
输出格式
N 行，如果第 i 名学生是优秀的，输出 Excellent，否则输出 Not excellent。
例题3：
代码如下：
#include
using namespace std;
int n;
double ok=0;//用来储存综合分数。这里一定要是浮点型！不然就会WA（我的血泪史啊）
struct xs{//结构体
int xh,a1,a2;//xh是学号，a1是学业成绩，a2素质拓展成绩。
}a[1010];
int main(){
cin>>n;
for(int i=1;i<=n;i++){
cin>>a[i].xh>>a[i].a1>>a[i].a2;
ok=a[i].a1*0.7+a[i].a2*0.3;//计算并储存存综合分数
if(ok>80&&a[i].a1+a[i].a2>140){//判断
cout<<"Excellent"<}else{
cout<<"Not excellent"<}
}
return 0;//拜拜！
}(共8张PPT)
第
九
课
循环语句之do.....while
do-while语句和用do-while语句实现循环
do-while语句的特点:先执行循环体，然后判断循环条件是否成立。
一般形式: do
｛ 循环体语句｝
while (表达式)；
执行过程：先执行一次指定的循环体语句，
然后判别表达式，当表达式的值为非零
(“真”) 时，返回重新执行循环体语句，如
此反复，直到表达式的值等于0为止，此
时循环结束。
例题：
求1到5的和
#include
int main()
{ int i，sum=0;
i=1;
do
{sum=sum+i;
i++;
}
while(i<=5);
cout<}
练习1：
1、编写程序求12+22+32+…+n2,直到累
加和大于或等于10000为止。
答案：
#include
using namespace std;
int main()
{int i，sum;
i=0;sum=0;
while (sum<=10000)
{ sum=sum+i*i;
i++;
}
cout<}
作业：
编写程序，求1-3+5-7+…-99+101的值。(共17张PPT)
第
六
课
控制语句——if
在一个if 语句中可以又出现另一个if语句，这称为if语句的嵌套或多重if语句。其一般形式为：
if （表达式_1）
if （表达式_11）语句1；
else 语句2；
else
if （表达式_12） 语句3；
else 语句4；
程序执行流程
如图(c)所示。
图(c)
else 总是与上面最近的 if 配对
if( )
if( )语句1；
else
if( )语句2；
else 语句3；
if( )
if( )语句1；
else
if( )语句2；
else 语句3；
if( )
{ if( )语句1；}
else
if( )语句2；
else 语句3；
加花括号改变配对关系
逻辑运算符
逻辑与 && 二项都成立才算成立
逻辑或 || 任有一项成立就成立
逻辑非 ! 单项运算，将结论取反
条件 P 条件 Q P && Q P || Q !P
TRUE 1 TRUE 1 TRUE 1 TRUE 1 FALSE 0
TRUE 1 FALSE 0 FALSE 0 TRUE 1 FALSE 0
FALSE 0 TRUE 1 FALSE 0 TRUE 1 TRUE 1
FALSE 0 FALSE 0 FALSE 0 FALSE 0 TRUE 1
例3-3 编写一个程序，输入一个x，根据下面的函数输出y的值。
1 （x>0）
y ＝ 0 （x=0）
-1 （x<0）
#include
using namespace std;
int main()
{
float x; int y;
cin>>x;
if (x>=0)
if (x>0) y=1;
else y=0;
else y = -1;
cout<return 0;
}
改写成如下形式：
#include
using namespace std;
int main()
{
float x;
int y;
cin>>x;
y=0;
if (x>=0)
if (x>0) y=1;
else y=-1;
cout<return 0;
}
对吗？
例3-3 编写一个程序，输 入一个x，根据下面的函数输出y的值。 && ||
1 （x>0 且 x<10）
（x=0）
-1 （x<-10 或 x>10）
y ＝ 0
逻辑运算符
a 在 20 ～ 30 之间 if( a>=20 && a<=30 )
x 是 100 以内的奇数 if( x>0 && x<100 && x%2==1 )
语、数、外任何一门超 95 if( yw>95 || sx>95 || yy>95 )
x 是 3 或 5 的倍数 if( x%3==0 || x%5==0 )
x 既不是 3 的倍数， 又不是 5 的倍数 if( x%3!=0 && x%5!=0 )
if( !( x%3==0 || x%5==0 ) )
注意不要写出类似 if( 1 <= x <= 100 ) 的错误形式
条件语句 条件？值1:值2
if(a>b)
c=a;
else
c=b;
c = a>b a : b;
c 在赋值时，依赖于 a>b 这个条件
if(a>=0)
f=1;
else
f=-1;
f = a>=0 1 : -1;
f 是 1 还是 -1 ，依赖于 a>=0 这个条件
条件语句 条件？值1:值2
if(c==a+b)
cout << ”right” << endl;
else
cout << ”wrong” << endl;
cout << (c==a+b ”right”:”wrong”) << endl;
输出时，由条件决定输出内容（因优先级关系，括号不能省略）
if(a>0)
i=3;
else
j=5;
a>0 i=3:j=5;
根据条件，分别执行独立的语句
（3）if…else if语句
在C++程序还经常使用如下结构：
if（表达式_1）语句1
else if（表达式_2）语句 2
else if（表达式_3）语句 3
…
else if（表达式_n）语句 n
else语句n+1
这种嵌套的if语句构成的序列是编写多路判定的最一般的方法。
它的执行过程是：如果表达式1的值为真，则执行语句1；否则，如果表达式2的值为真，则执行语句2；……；如果if后的表达式都不为真，则执行语句n+1。每一个语句可以是单个语句，也可以是用花括号括起来的一组语句即复合语句。
当n=3时，程序执行的流程如图(d)所示。
图(d)
例3-4 输入一个百分制的考试成绩，要求按照下面的规则打印出等级。
对应规则为：90～100分等级为“A”，80～89分等级为“B”，70～79分等级为“C”，60～69分等级为“D”，0～59分等级为“E”。
#include
using namespace std;
int main()
{
int s要求按照下面的规则打印出等级。
对应规则为：90～100分等级为“A”，80～89分等级为“B”，70～79分等级为“C”，60～69分等级为“D”，0～59分等级为“E”。core;
使用if 语句的注意事项：
（1）三种形式的if语句中在if后面都有“表达式”，一般为逻辑表达式或关系表式。
例如，if（a＝＝b && x＝＝y）cout<<‘a＝b，x＝y”； 在执行if语句时先对表达式求解，若表达式的值为0，按“假”处理，若表达式的值为非0，按“真”处理，执行指定的语句。
例如：有以下if语句：if（3） cout<<“O.K.”；
是合法的，执行结果输出“O.K.”，因为表达式的值为3，按 “真”处理。由此可见，表达式的类型不限于逻辑表达式，可以是任意的数值类型（包括整型，实型、字符型指针型数据）。
（2）第二、第三种形式的if语句中，在每个else前面有一分号，
整个语句结束处有一分号。
例如：if （x>0）
cout<else
cout<<－x；
各有一个分号
这是由于分号是C语言中不可缺少的部分，这个分号是if语句中的内嵌语所要求的。如果无此分号，则出现语法错误。else子句不能作为语句单独使用它必须是if语句的一部分与if配对使用,而且是：每个else与最近的一个if配对。
（3）在if和else后面可以只含一个内嵌的操作语句（如上例），
也可以有多个操作语句，此时用花括号“{}”将几个语句括
起来成为一个复合语句。
什么是复合语句：
它是使用花括号“{ }”将多条语句括起来组合而成的一种语句格式。
格式为：
{ 〔局部定义变量〕；
语句1；
语句2；
……
语句n；
}
作业：
从键盘输入班级平均成绩，编写一个程序，要求按照下面的规则打印出等级。
对应规则为：90～100分等级为“优秀”，80～89分等级为“良好”，60～79分等级为“及格”，0～59分等级为“不及格”。(共9张PPT)
第
七
课
选择语句之switch
switch语法：
switch(表达式){
case 表达式1 :
语句1;
break; // 可选的
case 表达式2 :
语句2；
break; // 可选的
// 您可以有任意数量的 case 语句
default : // 可选的
表达N;}
switch 语句解释：
1. 一个 switch 语句允许测试一个变量等于多个值时的情况。每个值称为一个 case，且被测试的变量会对每个 switch case 进行检查
2. case 后面的表达式必须与 switch 中的变量具有相同的数据类型，且必须是一个常量或字面量。
3、当被测试的变量等于 case 中的常量时，case 后跟的语句将被执行，直到遇到 break 语句为止。
4、当遇到 break 语句时，switch 终止，控制流将跳转到 switch 语句后的下一行。
switch语句解释
5、不是每一个 case 都需要包含 break。如果 case 语句不包含 break，控制流将会 继续 后续的 case，直到遇到 break 为止。
6、一个 switch 语句可以有一个可选的 default case，出现在 switch 的结尾。default case 可用于在上面所有 case 都不为真时执行一个任务。default case 中的 break 语句不是必需的。
实例：
作业：
用switch语句实现两个数的四则运算（加减乘除）。提示：定义两个整型变量和一个char变量来存储+-*/符号。
作业：
用switch语句实现从键盘输入数字，输出相应的星期几，如1，输出星期一。(共14张PPT)
第
三
课
累 加
累加
sum=sum+i;
从1加到5
例1:
练习：从1加到10结果为多少？
细胞分裂
02
1个细胞，第1次分裂成2个，第2次2个分裂成4个，……，请你编一程序，算一下第5次分裂成几个？
int n=1;
n=n*2;
n=n*2;
n*=2;
n*=2;
n*=2;
n*=2
复合的运算符:
n=n*2;
*=
s=s-i;
s-=i;
s=s/i;
s/=i;
1个细胞，第1次分裂成3个，第2次3个分裂成9个，……，请你编一程序，算一下第6次分裂成几个？
谢谢大家的聆听
END
◆(共13张PPT)
第
十八
课
函数的参数及三种调用方式
学习目标
1. 理解形式参数与实际参数。
2. 理解参数传递的三种方式。
函数的数据类型是函数返回值类型（若数据类型为VOID,则无返回值）。
参数是函数与函数之间实现通信的数据“接口”。函数调用的过程就是调用者带着实际参数（如果有）执行函数，将实际参数“传递”给形式参数，执行完函数体后再将计算得到的返回值传递给调用者（如果有）。
在未调用函数前，函数中的形式参数并不分配内存空间。只有在被调用执行时，才被分配临时存储空间。函数调用结束后，形式参数的内存空间将被操作系统立刻收回。
函数的参数
函数参数
实际参数可以是任何符合形式参数类型的常量、变量、表达式。函数参数传递的过程就是实际参数和形式参数相结合的过程，必须遵守三个一致。
（1） 个数一致。
（2） 顺序一致。
（3） 类型一致。
注：形式参数（形参）表可以是空的，也可以有多个形参，形参之间用逗号隔开，不管有无参数，函数名后面的圆括号都必须有。
函数的参数
函数的形式从结构上说可以分为三种：无参函数、有参函数、空函数，它们的定义形式相同。
如：编写 一个阶乘的函数，给此函数取一个名字如 js
int js(int n)
{
int s =1
for (int i=1;i<=n;i++)
s*=i
return s
}
本例中函数名是js，只有一个int型自变量n，函数js是int型。
例题
例1、打印字符三角形
【问题描述】
编写一个函数 print (n,ch)，表示打印一行 n 个英文字母 ch，并换行。然后，在函数 main() 中输入 n 和 ch，调用函数 print() 打印一个字符三角形。
【输入格式】
一行一个整数 n 和一个英文字母 ch，之间用一个空格隔开，1≤n≤20。
【输出格式】
n 行，第 i 行有 i 个字母 ch。
【输入样例】
3 a
【输出样例】
a
aa
aaa
程序如下：
#include
using namespace std;
void print(int i,char ch){
for(int j = 1; j <= i; j++) cout << ch;
cout << endl;
}
int main(){
int n;
char ch;
cin >> n >> ch;
for(int i = 1; i <= n; i++) print(i,ch);
return 0;
}
函数参数的传递方式
根据不同的应用需求，函数参数的传递方式，或者说函数参数的调用方式分为三种：
（1） 传值（调用）
（2） 传址（调用）
（3） 引用（调用）
例2、阅读程序，写出程序的运行结果，体会函数的传值(调用)。
#include
using namespace std;
void swap(int x,int y){
int temp;
temp = x;
x = y;
y = temp;
cout << x << “ “ << y << endl;
}
int main(){
int a = 10,b = 50;
swap(a,b);
cout << a << “ “ << b << endl;
return 0;
}
例3、阅读程序，写出程序的运行结果，体会函数的传址(调用)。
#include
using namespace std;
void swap(int *x,int *y){// 形式参数的类型定义为指针
int temp;
temp = *x;
*x = *y;
*y = temp;
cout << *x << “ “ << *y << endl;
}
int main(){
int a = 10,b = 50;
swap(&a,&b);// 实际参数必须是地址
cout << a << “ “ << b << endl;
return 0 ;
}
例4、阅读程序，写出程序的运行结果，体会变量及其引用的操作。
#include
using namespace std;
int main(){
int k = 32;
int& k_adr = k;
cout << “ k= ” << k << “ k_adr= ” << k_adr << endl;
k++;
cout << “ k= ” << k << “ k_adr= ” << k_adr <k_adr = -5;
cout << “ k= ” << k << “ k_adr= ” << k_adr << endl;
int i = 100;
k_adr += i;
cout << “ k= ” << k << “ k_adr= ” << k_adr << endl;
return 0;
}
例5、阅读程序，写出程序的运行结果，体会函数的引用调用。
#include
using namespace std;
void swap(int &a,int &b){
int temp;
temp = a;
a = b;
b = temp;
cout << a << “ “ << b << endl;
}
int main(){
int a = 10,b = 50;
swap(a,b);
cout << a << “ “ << b << endl;
return 0;
}(共10张PPT)
第
十二
课
循环嵌套------强化练习
i<=9
输出i*j
假(0)
真(非0)
i=1
j++
j=1
j<=i
真(非0)
假(0)
i++
外循环
内循环
实训
1、运行程序：例15.1编写程序求12+22+32+…+n2,直到累加和大于或等于10000为止。
实训
#include
void main()
{int i，sum;
i=0;sum=0;
while (sum<=10000)
{ sum=sum+i*i;
i++;
}
cout<}
*
***
*****
*******
*********
***********
*************
***************
*****************
循环嵌套，输出等腰三角形
提示:
行的控制 i:1～9
‘*’的个数j与当前行的关系:
j=2*i-1
‘*’前面的空格k与行的关系:
开始时,第一行有8个空格
每多一行,少一个空格k=9-i
一个炊事员上街采购，用500元钱买了90只鸡，其中母鸡一只15元,公鸡一只10元，小鸡一只5元，正好把钱买完。问母鸡，公鸡，小鸡各买了多少只？
【分析】设母鸡i只,公鸡j只,则小鸡为90-i-j只,则15*i+ 10* j+(90-i-j)*5=500,显然一个方程求两个未知数是不能直接求解。必须组合出所有可能的i,j值，看是否满足条件。这里i的值可以是0到33，j的值可以0到50。
9
课堂练习
百钱买百鸡:
鸡翁1,钱值5; 鸡母1,钱值3;鸡 雏3,钱值1;何以百钱买百鸡
有30个男人女人和小孩同在一家饭馆进餐，共花了五十先令，其中男宾3先令，女宾2先令，小孩1先令。试编程求出男人女人小孩各多少人？(共9张PPT)
第
十九
课
变量的作用域
学习目标
1. 理解变量的作用域。
2. 熟练规范使用局部变量和全局变量。
变量按其在程序中的作用范围，分为全局变量和局部变量。
全局变量是指定义在任何函数之外的变量，也就是不被任何“｛函数体｝”所包含，可以被源文件中其他函数所共用，用静态数据区存储，作用域（有效范围）是从定义变量的位置开始到源文件（整个程序）结束。
局部变量是指在一个函数（包括 main 函数）内部定义的变量，它只在本函数内部有效，其他函数不能使用这些变量，用动态数据区存储，函数的参数也是局部变量。
变量的作用域
例题
例1、以下程序中，哪些是全局变量，哪些是局部变量，并指出它们的作用域。
int x,y;
float a,b;
float find(int c,d){
float e,f;
int i,j;
}
int z;
void doit(){
}
int main(){
int g,h;
…
}
例题
找出程序中的错误。如果去掉错误，程序输出什么。
#include
using namespace std;
int f(){
int b = 0,c = 1;
b = b + 1;
c = c + 1;
return (b+c);
}
int main(){
for(int i = 1; i < 4; i++)
cout << i << “ .sum= ” << f() << endl;
cout << “ b= ” << b << “ c= ” << c << endl;
return 0;
}
例题解析
C++允许在更多地方定义变量，例如for的第一个子句，if、for或者while语句块的{ }内。这些变量只在当前语句块内有效。一个语句块内只能定义一个同名变量。不同的函数内部可以使用相同名称的变量，它们代表不同的对象，相互独立，互不干扰。访问同名变量时、只能访问到当前有效、且最近定义的该变量。特别地，在变量前加“::”可以指定访问全局变量。在写复杂代码时，可以利用这些特性，调整临时变量的定义位置和作用域，以规避变量重名带来的编译错误。
当堂练习
阅读程序，写出程序的运行结果。
#include
using namespace std;
int x = 10, y = 15;
void change(int a, int b, int x){
int temp;
x++;y++;
temp = a;a = b;b = temp;
}
int main(){
int a = 3, b = 5;
cout << x << “ ” << y << “ ” << a << “ ” << b << endl;
change(a,b,x);
cout << x << “ ” << y << “ ” << a << “ ” << b << endl;
return 0;
}
当堂练习
找出程序中的错误。如果去掉错误，程序输出什么。
#include
using namespace std;
int x = 233;
int main(){
int x;
cin >> x;
for(int i = 1; i <= x; ++i){
int x,y;
cin >> x >> y;
cout << x + y << endl;
}
cout << x << endl;
cout << ::x << endl;
cout << i << “ “ << y << endl;
return 0;
}(共13张PPT)
第
十
课
FOR循环
对于计算机，如果来说顺序结构是自动运行的可行性，分支结构是解决问题逻辑判断所必需。那么真正是它走向实际应用的，应该就是循环结构。让程序以最少的指令重复最多执行大量而繁琐的功能。让计算机真正发挥其功能。
格式说明：
for（初始化；条件；步长）
｛
循环体；
｝
for语句
1.for语句的一般形式为：
for （表达式1 ；表达式2 ；表达式3）
{ 循环体 ｝
2.执行过程
for循环的执行流程如图所示。
根据for语句的执行流程，可将for语句改写如下：
表达式1；
while（表达式2）
{
语句
表达式3；
}
3、关于for语句的说明
（1） for语句的一般形式中的“表达式1”可以省略，
注意省略表达式 1时，其后的分号不能省略。
如 for（；i<=100；i＋＋） sum=sum＋i；
执行时，跳过“求解表达式1”这一步，其他不变。
（2）如果表达式2省略，（其后的分号不能省略），即不判断循环条件，循环无终止地进行下去。也就是认为表达式2始终为真。
例如：
for(i=1; ;i++)sum=sum+i;
它相当于：
i=1;
while(1)
{sum=sum+i;
i+ +;}
（3）表达式3也可以省略，但此时程序设计者应另外设法保证循环能正常结束。如：
for（i＝l；i<＝100；）
{sum=sum＋i；
i＋＋；
｝
（4）可以省略表达式1和表达式3，只有表达式2，即只给循环条件。如：
for（；i<＝100;） while（i<＝100）
｛sum＝sum＋i； 相当于 ｛sum＝sum＋i；
i＋＋；｝ i＋＋；｝
（5） for语句的一般形式中的三个表达式都是可以省略的，但分号“；”绝对不能省略。
特别地，当表达式1和表达式3同时省略时，for语句完全等同于while语句。之前给循环变量赋初值。
例如：
i＝1，sum=0；
for ( ；i＜＝100；)
{ 相当于
sum＝sum＋i；
i++；
}
i=1,sum=0;
While(i<=100)
{
sum=sum+i;
i++;
}
（6）3个表达式都可省略（但分号不能省），如：
for(; ;)语句
相当于
while（1）语句
即不设初值，不判断条件（认为表达式2为真值），
循环变量不增值。无终止地执行循环体。
（7）表达式1可以是设置循环变量初值的赋值表达式，
也可以是与循环变量无关的其他表达式。如：
for（sum=0；i<=100；i＋＋） sum=sum+ i;
表达式1和表达式3可以是一个简单的表达式，也可以
是逗号表达式，即包含一个以上的简单表达式，中间
用逗号间隔。如：
for(sum=0,i=1;i<=100;i+ +)sum=sum+i;
或 for(i=0,j=100;i<=j;i+ +,j --)k=i+j;
（6）3个表达式都可省略（但分号不能省），如：
for(; ;)语句
相当于
while（1）语句
即不设初值，不判断条件（认为表达式2为真值），
循环变量不增值。无终止地执行循环体。
（7）表达式1可以是设置循环变量初值的赋值表达式，
也可以是与循环变量无关的其他表达式。如：
for（sum=0；i<=100；i＋＋） sum=sum+ i;
表达式1和表达式3可以是一个简单的表达式，也可以
是逗号表达式，即包含一个以上的简单表达式，中间
用逗号间隔。如：
for(sum=0,i=1;i<=100;i+ +)sum=sum+i;
或 for(i=0,j=100;i<=j;i+ +,j --)k=i+j;
例: 求1+2+3 + … +99 +100的值。
#include
using namespace std;
int main()
{
int i,sum;
sum=0;
for (i=1; i<=100; i++) sum+=i;
cout<< "The sum is " << sum <return 0;
}
这是for语句最易理解也是最常用的形式
for （变量=初值；循环条件；变量增值） 语句 ；
作业：
计算1到100之间所有偶数和
求水仙花数。所谓水仙花数，是指一个三位数abc，如果满足a^3+b^3+c^3=abc，则abc是水仙花数。
课后作业：
1、求出四位数的四叶玫瑰数（所谓四叶玫瑰数，是指一个四位数abcd，如果满足a^4+b^4+c^4+d^4=abcd，则abcd是四叶玫瑰数。
2、求出五位的五角星数（所谓五角星数，是指一个五位数abcde，如果满足a^5+b^5+c^5+d^5+e^5=abcde，则abcde是五角星数。 (共10张PPT)
第
十六
课
数组运用
二维数组的定义
语法格式：
类型 数组名[常量表达式1][常量表达式2]；
如： int a[2][3]；
数组a各元素如下：
a[0][0] a[0][1] a[0][2]
a[1][0] a[1][1] a[1][2]
二维数组中每个元素都是用下列方式标识：
数组名[行下标][列下标]
对于二维数组，可以把它看成是由多个一维数组构成。如：int a[2][3]；就可以看成是由两个形如int a[3]；的一维数组构成的。
二维数组初始化
（1）分别对各元素赋值，每一行的初始值用一对花括号括起来。例如：
int a[2][3]={{1,2,3},{4,5,6}};
（2）将各初始值全部连续地写在一个花括号内，在程序编译时会按内存中排列的顺序将各初始值分别赋给数组元素。例如
int a[2][3]={1,2,3,4,5,6};
（3）只对数组的部分元素赋值。例如：
int a[2][3]={1,2,3,4};
（4）可以在分行赋初值时，只对该行中一部分元素赋初值，例如：
static int a[2][3]={{1,2},{1}};
省略第一维的大小
若在定义数组时给出了全部数组元素的初值，则数组的第一维下标可以省略，但第二维下标不能省略。
下面两种定义方式等价：
static int a[2][3]={1,2,3,4,5,6};
static int a[ ][3]={1,2,3,4,5,6};
static int a[2][ ]={1,2,3,4,5,6}; //错误写法
在分行定义时，也可以只对部分元素赋初值而省略第一维的下标。例如：
int a[ ][4]={{1,2},{},{3,4,5}}；
等价于 int a[3][4]={{1,2,0,0},{0,0,0,0},{3,4,5,0}} ；
题1：输入10个学生的成绩，
求平均成绩，并将低于平均成绩
的分数打印出来。
#include
using namespace std;
int main()
{
int i,sum=0,avg=0,a[10];
for(i=1; i<=10; i++)
{
cin>>a[i];
}
for(i=1; i<=10; ++i)
{
sum+=a[i];
}
avg=sum/10;
for(i=1; i<=10; i++)
{
if(a[i]}
return 0;
}
题2：输入N个整数，存放在
数组a[1]至a[n]中，输出最大
数所在位置
（n<=10000)
int main()
{
int n,k,i,max;
int a[10001];
cin>>n;
for(i=1; i<=n; i++)
{
cin>>a[i];
}
max=a[1];
for(i=1; i<=n; i++)
{
if(a[i]>max)
{
max=a[i];
k=i;
}
}
cout<<"最大数所在位置是："<return 0;
}
题2：输入N个整数，存放在
数组a[1]至a[n]中，输出最大
数所在位置
（n<=10000)
题2：输入N个整数，存放在
数组a[1]至a[n]中，输出最大
数所在位置
（n<=10000)(共13张PPT)
第
十七
课
函数
学习目标
1. 学会函数的定义和调用。
2. 应用函数解决一些实际问题。
学习目标：
定义：
C++ 要求函数必须先定义、后使用。定义函数，就是要说明函数的返回值类型、函数名、函数参数，以及完成特定功能的语句组合（函数体）。
函数的定义
定义函数的格式如下：
返回值类型 函数名（参数列表）{
函数体
}
其中，第一行称为函数头部。函数名是标识这个函数的合法标识符。返回值类型是指一个函数结束后返回给调用者的一个“返回值”的数据类型。有些函数的功能是执行一系列操作，而不返回任何值，这种情况下，返回值类型是关键字void。参数列表是当函数被调用时，调用者向函数传递的各种“参数”，此处的参数称为形式参数，参数列表包括参数的数据类型和参数名，参数是可选的，没有参数就是“无参”函数，但是括号不能省略。
函数定义：
大括号之间的部分称为“函数体”，主要包括变量说明语句、表达式语句等。如果有返回值，则函数体内至少有一条语句“return 表达式”。在执行函数体的过程中，一旦遇到return语句，执行完就立刻退出函数，不再执行后续的语句。无返回值函数不需要return语句。
函数的调用
在程序中以任何方式对函数的使用，都称为函数的调用。函数调用是通过“函数名”进行的，一般格式为：
函数名（参数列表）
此处的参数列表称为“实际参数”，是传递给调用函数的，必须严格对应函数定义时函数头部的形式参数列表，包括参数个数、参数顺序、数据类型。调用无参函数时参数列表可以没有，但括号不能省略。如果参数列表包含多个参数，则各参数间用逗号隔开。
以函数在程序中出现的位置和形式来看，函数调用方式分为三种。
（1）函数调用作为一条独立语句，完成一件事情（一系列操作），没有任何返回值。例如：print (n); doit(dep,total); input( );
（2）函数调用的结果作为表达式的一部分。例如：int t = compute(i,j) + i*j;
（3）以实参形式出现在其他函数调用中。例如：number = min(sum(-5,100),n); num = max(max(a,b), c);
函数调用方式
例1、阅读程序，写出程序的运行结果，体会“代码重用”和“有返回值函数”的调用
#include
using namespace std;
int fac(int n){
int z = 1;
for(int i = 1; i <= n; i++) z = z * i;
return z;
}
int main(){
int x = fac(5) + fac(4);// 函数调用出现在表达式中
cout << x << endl;
return 0;
}
例题
例2、阅读程序，写出程序的运行结果，体会“无返回值函数”的调用。
#include
using namespace std;
void maxnum(int x,int y){
int w = x > y x : y;
cout << w << endl;
}
int main(){
int a = 5,b = 22;
maxnum(a,b);// 函数调用作为一条独立语句
return 0;
}
例3、阅读程序，写出程序的运行结果，体会函数的“提前声明”。
#include
using namespace std;
int big(int x,int y);// 函数的提前声明
int main(){
int x,y,z;
cin >> x >> y >> z;
cout << big(big(x,y),z) << endl;
// 函数调用的返回值又作为其他函数调用的实际参数
return 0;
}
int big(int x,int y){// 函数定义
if(x > y) return x;
else return y;
}
例4、统计闰年
【问题描述】
输入两个年份 x 和 y，统计并输出公元 x 年到公元 y 年之间的所有闰年数
（包括 x 年和 y 年），1≤x≤y≤3000。
【输入格式】
一行两个正整数表示 x 和 y，之间用一个空格隔开。
【输出格式】
一行一个正整数，表示公元 x 年到公元 y 年之间的所有闰年数。
【输入样例】
2000 2004
【输出样例】
2
例题
#include
using namespace std;
bool rn(int n){
if((n % 4 == 0) && (n % 100 != 0) || (n % 400 == 0)) return true;
else return false;
}
int main(){
int x,y,t = 0;
cin >> x >> y;
for(int i = x; i <= y; i++)
if(rn(i)) t++;
cout << t << endl;
return 0;
}
代码编写：(共20张PPT)
第
十三
课
数 组
本章要点
1、数组的定义格式
2、数组元素引用的格式
3、数组的赋值与初始化
4、数组与函数
5、字符数组
6、字符串
数组
数组是由一组具有相同数据类型的元素组成的集合。数组的类型就是这组元素的数据类型。构成数组的这组元素在内存中占用一组连续的存储单元。可以用一个统一的数组名标识这一组数据，而用下标来指明数组中各元素的序号。
一维数组的定义
语法格式：
类型 数组名[常量表达式]；
如：
char a[5];
int b[10];
const int size=10;
int c[size];
注意：在定义数组时，不能用变量来描述数组定义中的元素个数。例如，下面的定义方式是不合法的：
int n;
cin>>n;
int b[n];
数组名是代表数组元素首地址的符号常量
例 对于 char a[10]
a的内容是一个地址，也就是a[0]的地址；在定义a[10]之后a为一个表示地址的常量。
一维数组的存储
用数组名加下标值就可以访问数组中对应的某个元素。下标值从0开始，因此对于一个具有n个元素的一维数组来说，它的下标值是0~ n-1。
数组元素在内存中是顺序存储的。对于一维数组，就是简单地按下标顺序存储。
如：int b[5];
b[0]
b[1]
b[2]
b[3]
b[4]
一维数组的初始化
语法格式为：
类型 数组名[ 数组范围 ]={值1，值2，…，值n};
例如：
char a[5]={’a’,’b’,’c’,’d’,’e’};
或：
char a[ ]={’a’,’b’,’c’,’d’,’e’};
int c[5]={1,2};
当数组长度与初始化元素的个数不相等时，数组长度不能省去不写，如上例不能写为：
int c[ ]={1，2}；
字符数组初始化：
char d[6]={ ’h’ , ’e’ , ’l’ , ’l’ , ’o’ , ’\0’ };
char d[6]={”hello”}; 三种等价
char d[6]=”hello”;
数组元素的赋值
由于数组名是常量，数组元素是变量，所以对数组的赋值只能针对数组元素，并且必须逐一赋值。
例
int mydata[5];
mydata[0]=3; mydata[1]=78;
mydata[2]=54; mydata[3]=90; 　　
　mydata[4]=6;
mydata={3,78,54,90,6}
是错误的！
3.字符数组的初始化
只能对字符数组的元素赋值，而不能用赋值语句对整个数组赋值。
如：char c[5];
c={'C','h','i','n','a'} //错误，不能对整个数组一次赋值
如果已经定义了a和b是具有相同类型和长度的数组，且b数组已经初始化。
如：a=b; //错误，不能对数组整体赋值
a[0]=b[0];
可以用字符串常量来初始化字符数组
char str[ ]={"I am happy"};
可以省略花括号，写成
char str[ ]="I am happy";
注意：数组的长度不是10，而是11（因为字符串常量的最后由系统加上一个'\0'）
上面的初始化与下面的等价:
char str[ ]={'I',' ','a','m',' ','h','a','p','p','y','\0'};
如果有：
char str[10]="china";
数组str的前5个元素为'C','h','i','n','a',第6个元素为'\0',后4个元素为空字符。
字符数组的输入输出
1.输出的字符不包括结束符'\0'
2.输出字符串时，cout流中用字符数组名，而不是数组元素名
cout<3.如果数组长度大于字符串实际长度，输出遇'\0'结束
4.如果一个字符数组中包含一个以上‘\0',则遇到第一个‘\0'时输出就结束
若要在数组之间进行赋值，也只能逐一地赋值。
for (i=0;i<3;i++) b[i]=a[i];
字符串数组：
cin>>数组名；
或
cin>>数组名[下标]；
如：对一个大小为5的字符型数组a赋值，可以用下列两种方式：
char a[5];
cin>>a; //一般只针对字符数组
或 char a[5];
int i;
for (i=0;i<5,i++) cin>>a[i];
数组元素的赋值
数组元素的引用
引用形式为：
数组名[下标]
下标可以是整常数或整型表达式。例如a[2+1]、a[i+j]等（i和j为整型变量）。例如：
a[2]=10; //将10赋给数组中的a[2]元素。
a[5]=a[2]; //将a[2]元素的值赋给a[5]元素
cout<数组越界
在给数组元素赋值或对数组元素进行引用时，一定要注意下标的值不要超过数组的范围，否则会产生数组越界问题。因为当数组下标越界时，编译器并不认为它是一个错误，但这往往会带来非常严重的后果。
例如：定义了一个整型数组a：
int a[10];
数组a的合法下标为0~9。如果程序要求给a[10]赋值，将可能导致程序出错，甚至系统崩溃。
可以使用下式预防越界：
sizeof（a）
一维数组例
#include
using namespace std;
void showVal ( int num );
int main ( )
{
int testArr [ 5 ] = { 5, 10, 15, 20, 25 };
for ( int ct = 0; ct < 5; ct++ )
cout << testArr[ct] << " ";
return 0;
}
作业1：请大家把上面数组逆运算输出，输出结果为：25，20，15，10，5
一维数组例
#include
using namespace std;
int main( )
{
int i,a［10］;
for (i=0;i<=9;i++)
a［i］=i;
for (i=9;i>=0;i--)
cout<cout<return 0;
}
一维数组例
#include
using namespace std;
int main()
{
int age[5]; //数组声明 　　
int sum=0;
for(int i=0;i<5;i++)
{
cout<<"Enret an age:";
cin>>age[i]; //写数组元素　
sum+=age[i];
}
cout<<"The average is:"<return 0;
}
一维数组例
#include
using namespace std;
int main()
{
int age[]={18,20,17,21,19}; //数组初始化
int sum=0;
for(int i=0;i<5;i++)
sum+=age[i];
cout<<"The average is:"<return 0;
}
一维数组例
编写程序，用冒泡法对10个数排序(按由小到大顺序)。
一维数组例
#include
using namespace std;
int main( )
{
int a[11];
int i,j,t;
cout<<″input 10 numbers ：″<for (i=1;i<11;i++) //输入a［1］~a［10］
cin>>a[i];
cout<for (j=1;j<=9;j++) //共进行9趟比较
for(i=1;i<=10-j;i++) //在每趟中要进行(10-j)次两两比较
if (a[i]>a[i+1]) //如果前面的数大于后面的数
{t=a[i];a[i]=a[i+1];a[i+1]=t;}
cout<<″the sorted numbers ：″<for(i=1;i<11;i++) //输出10个数
cout<cout<return 0;
}(共5张PPT)
第
十四
课
数 组 练 习 题
一维数组例
练习题1:
一维数组例
练习题2:
编写程序，输入字符串（不包含空格），统计英文字母、数字字符
及其他字符的个数。
提示：str[i]!=0就一直循环
英文不区分大小写。
◆
【题目描述】
输出一个整数序列中与指定数字相同的数的个数。
【输入】
输入包含三行：
第一行为N,表示整数序列的长度(N≤100)；
第二行为时个整数，整数之间以一个空格分开；
第三行包含一个整数，为指定的数字m。
【输出】
输出为W个数中与m相同的数的个数。
【输入样例】
3
232
2
【输出样例】
2
【题目描述】
陶陶家的院子里有一棵苹果树，每到秋天树上就会结出10个苹果。苹果成熟的时候，陶陶就会跑去摘苹果。陶陶有个30厘米高的板箕，当她不能直接用
手摘到苹果的时候，就会睬到板其上再试试。
现在已知10个苹果到地面的高度，以及陶陶把手伸直的时候能够达到的最大高度，请帮陶陶算一下她能句够摘到的苹果的数目。假设她碰到苹果，苹果就
会掉下来。
【输入】
包括两行数据。第一行包含10个100到200之间（包括100和200）的整数（以厘米为单位）分别表示10个苹果到地面的高度，两个相邻的整数之间用一个空
格隔开。第二行只包括一个100到120之间（包含100和120）的整数（以厘米为单位），表示陶陶把手伸直的时候能够达到的最大高度。
【输出】
包括一行，这一行只包含一个整数，表示陶陶能够摘到的苹果的数目。
【输入样例】
100200150140129134167198200111
110
【输出样例】(共12张PPT)
第
十五
课
二维数组
二维数组的定义
语法格式：
类型 数组名[常量表达式1][常量表达式2]；
如： int a[2][3]；
数组a各元素如下：
a[0][0] a[0][1] a[0][2]
a[1][0] a[1][1] a[1][2]
二维数组中每个元素都是用下列方式标识：
数组名[行下标][列下标]
对于二维数组，可以把它看成是由多个一维数组构成。如：int a[2][3]；就可以看成是由两个形如int a[3]；的一维数组构成的。
二维数组初始化
（1）分别对各元素赋值，每一行的初始值用一对花括号括起来。例如：
int a[2][3]={{1,2,3},{4,5,6}};
（2）将各初始值全部连续地写在一个花括号内，在程序编译时会按内存中排列的顺序将各初始值分别赋给数组元素。例如
int a[2][3]={1,2,3,4,5,6};
（3）只对数组的部分元素赋值。例如：
int a[2][3]={1,2,3,4};
（4）可以在分行赋初值时，只对该行中一部分元素赋初值，例如：
static int a[2][3]={{1,2},{1}};
省略第一维的大小
若在定义数组时给出了全部数组元素的初值，则数组的第一维下标可以省略，但第二维下标不能省略。
下面两种定义方式等价：
static int a[2][3]={1,2,3,4,5,6};
static int a[ ][3]={1,2,3,4,5,6};
static int a[2][ ]={1,2,3,4,5,6}; //错误写法
在分行定义时，也可以只对部分元素赋初值而省略第一维的下标。例如：
int a[ ][4]={{1,2},{},{3,4,5}}；
等价于 int a[3][4]={{1,2,0,0},{0,0,0,0},{3,4,5,0}} ；
二维数组例
#include
using namespace std;
int main()
{
float disks[2][4];
int row, col;
disks[0][0] = 2.39; // Row 1, column 1
disks[0][1] = 2.75; // Row 1, column 2
disks[0][2] = 3.29; // Row 1, column 3
disks[0][3] = 3.59; // Row 1, column 4
disks[1][0] = 1.75; // Row 2, column 1
二维数组例
disks[1][1] = 2.19; // Row 2, column 2
disks[1][2] = 2.69; // Row 2, column 3
disks[1][3] = 2.95; // Row 2, column 4
// Print
for (row=0; row<2; row++)
{
for (col=0; col<4; col++)
{
cout << “$” <}
}
return 0;
}
二维数组例
#include // 二维矩阵的转置
using namespace std;
int main( )
{
int a[2][3]={{1,2,3},{4,5,6}};
int b[3][2],i,j;
cout<<″array a：″<for (i=0;i<=1;i++)
for (j=0;j<=2;j++)
b[j][i]=a[i][j];
cout<<″array b：″<for (i=0;i<=2;i++)
{
for(j=0;j<=1;j++)
cout<cout<}
return 0;
}
二维数组例
现有一个3行4列的矩阵，要求编程找出其中魔法力最强的党员及行号和列号
#include
using namespace std;
int main( )
{
int i,j,row=0,colum=0,max;
int a[3][4]={{5,12,23,56},{19,28,37,46},{-12,-34,6,8}};
max=a[0][0]; //使max开始时取a[0][0]的值
for (i=0;i<=2;i++) //从第0行~第2行
for (j=0;j<=3;j++) //从第0列~第3列
if (a[i][j]>max) //如果某元素大于max
{ max=a[i][j]; //max将取该元素的值
row=i; //记下该元素的行号i
colum=j; //记下该元素的列号j
} cout<<″max=″<return 0;
}
作业1：编写程序，找出m行n列的
二维数组中所有元素的最大值。
输入分m+1行：第一行为m和n的值
，以下m行代表二维数组，
其中每一行包括n个数。
样例输入：
3 3
1 2 3
4 5 6
7 8 9
样例输出：9
答案：
#include
int main()
{int a[100][100],m,n,i,j,max;
cin>>m>>n;
for(i=0;ifor(j=0;jcin>>a[i][j];
max=a[0][0];
for(i=1;ifor(j=1;j{if(a[i][j]>max)
max=a[i][j];
}
cout<return 0;
}(共19张PPT)
第
十一
课
循环嵌套
例: 求1+2+3 + … +99 +100的值。
#include
using namespace std;
int main()
{
int i,sum;
sum=0;
for (i=1; i<=100; i++) sum+=i;
cout<< "The sum is " << sum <return 0;
}
这是for语句最易理解也是最常用的形式
for （变量=初值；循环条件；变量增值） 语句 ；
循环体
非零
零
表达式
1、while 语句 常称
为“当型”循环语句
循环体
非零
零
表达式
2、do--while语句 常称
为“直到型”循环语句
表达式1
表达式2
循环体语句
表达式3
循环变量
赋初值
循环终止
条件
循环变量
控制
for (表达式1；表达式2；表达式3）
循环体
3、for 语句
语句执行过程
(1) 执行“控制变量初始化语句”，使控制变量获得一个初值。
(2) 判断控制变量是否满足“条件表达式”，若满足条件则执行一遍循环体，否则结束整个for语句，继续执行for循环下面的句子。
(3) 根据增量表达式，计算出控制变量所得到的新值
(4) 自动转到第（2）步。
break语句
一般形式: break;
功能:
跳出所在多分支switch语句
跳出所在的while、do-while、for循环语句（提前结束循环）。
break语句和continue语句
计算e1
e2
语句…
非0
0
e
非0
语句…
计算e3
0
break语句
循环体
0
计算e1
e2
语句…
非0
0
e
非0
语句…
计算e3
continue语句
continue语句
一般形式: continue;
功能:
提前结束本次循环体的执行，接着进行下一次循环条件的判别。
break语句和continue语句
例 ：求1+2+3+4+5+···+100。
#include
main()
{ int i,sum=0;
i=1;
while(i<=100)
{ sum=sum+i;
i++;
}
cout<}
循环初值
循环终值
循环变量增值
循环条件
循环体
回顾
求23＋24＋…＋210之和
For循环
输入一个数，判断是否是质数
For循环
质数定义为在大于1的自然数中，除了1和它本身以外不再有其他因数。
#include
using namespace std;
int main()
{
int i,n,m,ans;
cin>>n>>m;
i=n;
ans=0;
while(i<=m){
ans+=i;
i++;
}
cout<return 0;
}
输入：10 20
输出：_________
165
程序阅读
12
嵌套 for 循环
　如果一个for循环出现在另一个for循环中，则称它为嵌套循环
for(i = 1; i{
……
for(j = 0; j < = max2; j++)
{
… …
}
……
}
外面的循环每循环
一次，嵌套在里面
的循环都会从0到
max2完全循环一遍
13
嵌套 for 循环
　
for(i = 1; i<3; i++)
{
for(j = 0; j < =2; j++)
{
s=s+j;
}
}
cout<外面的循环每循环
一次，嵌套在里面
的循环都会从0到
2完全循环一遍
请用循环嵌套打印：
10*10的“*”
1.尝试使用循环打印一排*
2.加入循环嵌套：
内层循环控制 打印一排*
外层循环控制 打印一个换行符
把*改为j看j是如何变化的
请用循环嵌套打印：
正三角的“*”
加入循环嵌套：
内层循环控制 打印一排*
（每排*数量增加1）
外层循环控制 打印一个换行符
把*改为j看j是如何变化的
请用循环嵌套打印：
倒三角的“*”
加入循环嵌套：
内层循环控制 打印一排*
（每排*数量减少1）
外层循环控制 打印一个换行符
把*改为j看j是如何变化的
18
1
2
3
4
5
6
7
8
9
1
2
4
3
6
9
9
18
27
36
45
54
63
72
81
……………....
循环嵌套，输出九九表。
i
j
i<=9
输出i*j
假(0)
真(非0)
i=1
j++
j=1
j<=i
真(非0)
假(0)
i++
外循环
内循环(共18张PPT)
第
四
课
交 换 数 据
试编一程序，模拟交换过程。
在键盘输入a,b 两个数，程序实现交换a,b的值，并输出交换后的值。
例1:
在键盘输入a,b,c 3个数，程序实现a和b交换，b和c交换，并输出交换后a,b,c的值。
课堂练习:
数据类型
02
数据类型是指定义了一组数据以及定义在这一组数据的操作，它是程序中最基本的元素。
C++数据类型十分丰富，大体上可分为基本类型、空类型、构造类型、指针类型、类类型五种。如下图所示。

数据类型
基本类型
空类型（无值类型）void
构造类型
类类型class
指针类型
整型int
实型（浮点型）
字符型
逻辑型bool
结构类型struct
数组类型
枚举型类型enum
联合型类型union
单精度型float
双精度型double
单字符型char
宽字符型w-char
C++数据类型
2.1数据类型
2.1.1 基本类型
基本数据类型有4种：整型（int）、浮点型（float）、字符型（char）、逻辑型（bool）。
整型数在计算机内部一般采用定点表示法，用于存储整型量。（如123，-7等），存储整数的位数依机器的不同而异。
浮点数和整数不同的地方是浮点数采用的是浮点表示法，也就是说，浮点数的小数点的位置不同，给出的精度也不相同。
字符类型表示单个字符，一个字符用一个字节存储。
逻辑类型，也称布尔类型，表示表达式真和假。
2.2 常 量
常量是指在程序运行过程中其值不能改变的量。C++支持5种类型的常量：浮点型、整型、字符型、布尔型和枚举型。常量在程序中一般以自身的存在形式体现其值。常量具有类型属性，类型决定了各种常量在内存中占据存储空间的大小。
注：字符型可以和整型数据之间可以通用
在C++语言中，字符型数据和整理数据之间可以通用。一个字符数可以赋给整型变量，一个整型数据也可以赋给字符型变量，还可以对字符型数据进行算术运算。
2.2.1 整型常量
整型数据表示通常意义上的整数，整型常量可以用十进制、八进制或十六进制表示。
ASCILL码表
例题：a的ASCILL97 A的ASCILL 65
int main()
{
int i ,j;
char c1,c2;
c1='a';//a的ASCILL 97
c2=98;
i='A';
j=66;
cout<<"i="<cout<<"c1-32="<return 0;
}
练习：把密码小写ab加密为大写AB
2.2.2 浮点数常量
浮点数也称为实型数。只能以十进制形式表示。共有两种表示形式：小数表示法和指数表示法。
1. 小数表示法
使用这种表示形式时，实型常量分为整数部分和小数部分。其中的一部分可在实际使用时省略，如10.2，.2，2.等。但整数和小数部分不能同时省略。
2. 指数表示法
也称科学记数法，指数部分以E或e开始，而且必须是整数。如果浮点数采用指数表示法，则E或e的两边都至少要有一位数。如以下数是合法的：
1.2e20，-3.4e-2。
谢谢大家的聆听
END(共19张PPT)
第
五
课
控制语句——if
试编一程序，输入一个200以内的整数IQ，判断是不是天才。
if(表达式) 语句1;
等于
==
！=
不等于
“真”
非0
“假”
数值0
if(iq>140)
cout<<"天才";
课堂作业1：
从键盘输入一个成绩，如果大于90，输出优秀。
输入一个数，判断是不是偶数，如果是就输出“这是个偶数”。
if第二种形式
if(判断条件)
语句A;
else
语句B;
if（我认真学习C++）
{
我参加信息学奥赛得奖了！；
}
else
{
没有得奖；
继续努力；
}
执行哪个分支，依赖于条件“我认真学习C++”是否成立
if 语句
if(判断条件)
语句A;
else
语句B;
将 x y 中的较大值，存入 t 中
if(x>y)
t=x;
else
t=y;
条件判断（x>y）只能得出二个逻辑值
TRUE（表示成立、对的、真的、是的、1（非0）之意）
或者
FALSE（表示不成立、错的、假的、不是、0 之意）
if 语句
if(判断条件)
语句A;
else
语句B;
cin >> x;
if(x>=60)
cout << ”通过” << endl;
else
cout << ”不通过” << endl;
输入学生的某科考查成绩 x
如果 x ≥ 60
输出考查通过 通过
否则
输出考查不合格 不通过
语句中的字符串要加双引号，否则会误以为是变量或其它内容
if 语句
输入二个数 a b ，输出 a b 的加式；
接着可以输入加式的答案，
如果答案正确，输出 right
否则输出 wrong
9 25 9 25
9+25=34 9+25=36
right wrong
int a,b,c;
cin >> a >> b; 输入二个加数 9 25
cout << a << ”+” << b << ”=”; 输出加式 9+25=
cin >> c; 输入答案
if(c==a+b) 判断 c==a+b 吗？
cout << ”right” << endl; 输出 right
else 否则
cout << ”wrong” << endl; 输出 wrong
a 优秀
b 合格
C 加分
cj 成绩
当成绩超过 90 分，得一等奖 加10分
否则不满90分，得二等奖 加5分；
cin >> cj;
if(cj>=90)
cout<<”恭喜得一等奖“;
c=c+10;
else
cout<<”下次继续努力，得二等奖;
c=c+5;
错误写法，编译通不过
cin >> cj;
if(cj>=90)
{ cout<<”恭喜得一等奖“;
c=c+10;
}
else
{
cout<<”下次继续努力，得二等奖;
c=c+5;
}
正确的写法，多个语句括在一起。
if 及 else 后均只能跟一个 C++ 语句
当有多个语句时，这些语句用 { } 括起来变成一个复合语句。
关系运算符
名称 小于 小于等于 大于 大于等于 等于 不等于
数学符号 ＜ ≤ ＞ ≥ ＝ ≠
C++ 符号 < <= > >= == !=
判断条件 C++ 表示法
如果 a如果 x=0 if(x==0)
如果 c≥30 if(c>=30)
如果 s≠0 if(s!=0)
如果 a 是奇数 if(a%2!=0)
如果 t 是 3 的倍数 if(t%3==0)
== 和 = 是两个不同的操作符，
== 判断两边数据的关系，
= 是把右面的表达式的结果赋值给左边变量。
c=a+b 结果是将 a+b 的和存入变量 c 中
c==a+b 得出 c 是否和 a+b 相等的结论，
相等则为 true 或 1 值，不等则为 false 或 0 值
a+b=c 是一个错误的写法（不允许这样写，编译通不过）
a+b==c 等同于 c==a+b 的含义
if 语句的简单形式
不带 else 分支
if(判断条件）语句；
输入一个数，保存它的绝对值
cin >> x;
if(x<0) x=-x; 将 -x 存入 x 中
cout << x << endl;
在 x≥0 时，if 语句里没有执行任何操作
课后作业：
1、输入两个整数，将其中大数存入变量a，小数存入变量b。
2、输入3个数魔法师的身高a,b,c 要求模拟两实数排序的程序按由小到大的顺序输出。 (共15张PPT)
编
程
学
编程好处
C++语言
1
2
目 录
为什么学习编程？
01
为什么要学习编程
培养专注细心
增强抽象思考力
为什么要学习编程
学早不已晚
团队合作
游戏中学习
为什么要学习编程
增进解决问题能力
参加竞赛
自主招生资格
面对一道道关卡的挑战，学习会不停利用学习的资源、程序、试着达成破关的目的。在生活和学习中，也会习惯试着自己解决自己遇到的困难和问题。
高校自主招生一般要求考生在某些方面具备突出的能力和特长。例如，超常的创新和实践能力，学科竞赛获奖等。奥数竞赛竞争大出口小，信息竞赛获奖率和成功录取率高出奥赛的2倍以上。
信息学获奖人数最多？
为什么？
为什么要学竞赛、打竞赛？
为什么？
自主招生初审的前提条件是需要有竞赛的奖项，或有发明专利、学术论文等，竞赛奖项主要是指五大学科竞赛。初审之后通过测试可以拿到10分—一本线的降分优惠。也就是说，如果你的成绩正好能去东北大学，但自招你拿了60分降分，就可以去上海交大了。自主招生广义还包括各大学的学科营，有部分大学高一就开始签降分的协议了。清华北大每年在全国共招收6500多名学生，其中只有1000人左右是裸分录取的，80%以上的学生都有不同程度的降分。其他高校也是类似的趋势，自主招生在高考中所占的分量越来越重。
学习编程好处
总结
为什么选择C++
02
第一个C++程序
【例1.1】第一个C++程序，输出一行字符： “Hello world!”。
1.1
程序代码解释
用main代表“主函数”的名字。每一个C++程序都必须有一个 main 函数。
再看程序的第1行“#include ”，是C++的一个预处理命令，它以“#”开头以与C++语句相区别，行的末尾没有分号。
程序的第2行“using namespace std; ” 的意思是“使用命名空间std”。C++标准库中的类和函数是在命名空间std中声明的，因此程序中如果需要用到C++标准库（此时就需要用#include命令行），就需要用“using namespace std; ”作声明，表示要用到命名空间std中的内容。
教学过程
1.2
谢谢大家的聆听
END(共16张PPT)
第
二
课
计算天安门的面积
例1:
01
试编一程序，算算天安门广场面积是多少平方米？
天安门广场南北长880米、东西宽500米
int a,b,s;
a=880;
b=500;
s=a*b;
S=a%b;
12%5=？ 12/5=？
表达式（expression）将同类型
的数据（如常量、变量、函数等），
用运算符号按一定的规则连接
起来的、有意义的式子。
a+10
a*b
880*500
在键盘输入a,b,c,d分别为：6，5，8，9 求下面运算：
a*b+c+d b*c+(c+d)
c/b+a*d a%b+(c%d )
计数器
02
尼克每天背一首古诗后，模仿古人在一根木棒上刻一条痕，若连续刻了5天，试编一程序,算算一共有多少道痕
i=0;
i=i+1;
i=i+1;
i=i+1;
i=i+1;
i=i+1;
计
数
器
i++;
++i;
i=i+1;
i=i-1;
--i;
i--;
课堂作业1：求 S和J的值？
i=1;
s=i++;
j=++i;
课堂作业2：
1、计算半径为5CM，圆的周长和面积？（PI=3.14）
2、用程序实现在键盘输入三位数，实现倒序显示（如输入123，
输出321）？
（提示：cin输入 cout输出 ）
课后作业：
1、试着编程实现直径为6CM的圆的周长和面积？
2、在键盘输入一个四位数，实现倒序（如输入1234，输出4321）？
谢谢大家的聆听
END

展开更多......

收起↑