C程序:
#include <stdio.h>
int main(){
printf("Hello,world!");
return 0;
}
C++程序:
#include <iostream>
using namespace std;
int main(){
cout << "Hello,world!" ;
return 0;
}
关于 #include
#include
其实是一个预处理命令,意思为将一个文件“放”在这条语句处,被“放”的文件被称为头文件。C
语言的头文件 <stdio.h>
里包含了对 printf()
函数的定义,使得在添加头文件 #inclued <stdio.h>
后,可以直接使用 printf()
函数。C
语言必须添加的 #include <stdio.h>
和 C++
必须添加的 #include <iostream>
头文件之外,还有许多其他的头文件,这些文件里包含不同的函数原型和模板,在使用相关函数时必须将这些函数对应的头文件添加。#include
也可以添加用户自定义的头文件,需要注意的是,自定义的头文件需要使用引号而非尖括号。关于 using namespace std;
std
是 C++
标准库所使用的命名空间。C++
的 命名空间机制可以用来解决复杂项目中名字冲突的问题。C++
标准库的所有内容均定义在 std
命名空间中,如果你定义了一个叫 cout
的变量,则可以通过 cout
来访问你定义的 cout
变量,通过 std::cout
访问标准库的 cout
对象,而不用担心产生冲突using namespace std;
会将 std
中的所有名字引入,我们就可以用 cout
代替 std::cout
#include <iostream>
int main(){
std::cout << "Hello,world!" ;
return 0;
}
关于 main()
main()
称为主函数,程序运行时就会先执行 main()
中的代码。main
函数是由系统或外部程序调用的。如,你在命令行中调用了你的程序,也就是调用了你程序中的 main
函数。关于 return 0;
作用:
两种格式:
// 描述信息
/* 描述信息 */
提示:编译器在编译代码时,会忽略注释的内容,注释对程序运行没有影响,C/C++通用该规则
示例:
#include <stdio.h> //这是C语言的头文件
int main(){ //main()函数
printf("Hello,world!"); //输出Hello,world!
/* 这是多行注释,从本行开始
printf("Hello,world!"); //输出输出Hello,world!
截止至该行,以上的所有内容不会执行 */
return 0;
}
输入:
scanf()
cin >>
输出:
printf()
cout <<
C语言代码示例:
#include <stdio.h>
int main(){
int a; //定义一个变量a
scanf("%d", &a); //输入a的值
printf("%d", a); //输出a的值
return 0;
}
C++语言代码示例:
#include <iostream>
using namespace std;
int main(){
int a; //定义一个变量a
cin >> a; //输入a的值
cout << a; //输出a的值
return 0;
}
关于变量:
int
,双精度浮点型 double
等。关于scanf("%d", &a);
scanf()
是C
语言的输入函数,""
内为读入的内容。%d
表示读入的变量是一个有符号整型 (int
型)的变量。&a
表示将输入的数据存入到变量 a
所在的内存地址,可以简单理解为将输入的数据与对应变量名照应起来。关于printf("%d", a);
printf()
是C
语言的输出函数,""
内为输出的内容。%d
表示输出的变量是一个有符号整型 (int
型)的变量。a
表示输出变量 a
的值。关于cin >> a;
cin >>
是 C++
语言的输入函数,>>
后面为输入的内容。cin
在输入变量时会自动识别变量类型。关于cout << a;
cout <<
是 C++
语言的输出函数,<<
后面为输入的内容。cout
在输出变量时会自动识别变量类型。作用:
语法:
数据类型 变量名;
数据类型 变量名 = 初始值;
C语言代码示例:
#include <stdio.h>
int main(){
float a; //定义一个float型的变量a
double b; //定义一个double型的变量b
scanf("%f %lf", &a, &b); //读入a和b的值
printf("%f %lf\n", a, b); //输出a的值后输出一个空格,再输出b的值再输出回车
printf("%.2f %.3lf\n", a, b); //输出a的值保留2位小数后输出一个空格,再输出b的值保留3位小数再输出回车
return 0;
}
C++语言代码示例:
#include <iostream>
using namespace std;
int main(){
int a; //定义一个int型的变量a
int b = 10; //定义一个int型的变量b,初始值为10
cin >> a;
cout << a << " " << b; //输出a的值后输出一个空格,再输出b的值
return 0;
}
作用:
对照表:
数据类型 | 占用空间 | 取值范围 |
---|---|---|
short | 2字节 | $(-2^{15} \sim 2^{15}-1)$ |
int | 4字节 | $(-2^{31} \sim 2^{31}-1)$ |
long | Windows为4字节,Linux为4字节(32位),8字节(64位) | $(-2^{31} \sim 2^{31}-1)$ |
long long | 8字节 | $(-2^{63} \sim 2^{63}-1)$ |
unsigned long long | 8字节 | $(0\sim 2^{64}-1)$ |
常用的整形输入和输出:
int
:对应 scanf()
读入和 printf()
输出应为 %d
。long long
:对应 scanf()
读入和 printf()
输出应为 %lld
。C语言代码示例:
#include <stdio.h>
int main(){
int a; //定义一个int型的变量a
long long b; //定义一个long long型的变量b
scanf("%d %lld", &a, &b); //读入a和b的值
printf("%d %lld", a, b); //输出a的值后输出一个空格,再输出b的值
return 0;
}
C++语言代码示例:
#include <iostream>
using namespace std;
int main(){
int a; //定义一个int型的变量a
long long b; //定义一个long long型的变量b
cin >> a >> b; //读入a和b的值
cout << a << " " << b; //输出a的值后输出一个空格,再输出b的值
return 0;
}
作用:
对照表:
数据类型 | 占用空间 | 有效数字范围 |
---|---|---|
float | 4字节 | $(-3.4\times 10^{-38}\sim 3.4\times 10^{38})$ |
double | 8字节 | $(-1.7\times10^{-308}\sim 1.7\times10^{308})$ |
常用的浮点型输入和输出:
float
:对应 scanf()
读入和 printf()
输出应为 %f
。double
:对应 scanf()
读入和 printf()
输出应为 %lf
。printf()
在输出浮点数时,保留x
位小数可以使用 %.xf
,%.xlf
。cout <<
在输出浮点数时,保留 x
位小数,需要加上头文件 #include <iomanip>
,然后 cout << setprecision(x)
。C语言代码示例:
#include <stdio.h>
int main(){
int a; //定义一个int型的变量a
long long b; //定义一个long long型的变量b
scanf("%d %lld", &a, &b); //读入a和b的值
printf("%d %lld", a, b); //输出a的值后输出一个空格,再输出b的值
return 0;
}
C++语言代码示例:
#include <iostream>
#include <iomanip>
using namespace std;
int main(){
float a; //定义一个float型的变量a
double b; //定义一个double型的变量b
cin >> a >> b; //读入a和b的值
cout << a << " " << b << endl; //输出a的值后输出一个空格,再输出b的值再输出回车
cout << setprecision(2) << a << " " << setprecision(3) << b << endl; //输出a的值保留2位小数后输出一个空格,再输出b的值保留3位小数再输出回车
return 0;
}
作用:
语法:
char 变量名;
char 变量名 = 'a';
注意:
b
,c
等,可以是空格符 ,但不可以是字符串如"abcd"
。字符型输入和输出:
char
:对应 scanf()
读入和 printf()
输出应为 %c
。C语言代码示例:
#include <stdio.h>
int main(){
char a; //定义一个char型的变量a
scanf("%c", &a); //读入a值
printf("%c\n", a); //输出a的值后输出一个回车
return 0;
}
C++语言代码示例:
#include <iostream>
using namespace std;
int main(){
char a; //定义一个char型的变量a
cin >> a; //读入a值
cout << a << endl; //输出a的值后输出一个回车
return 0;
}
ASCII码表格:
ASCII值 | 控制字符 | ASCII值 | 字符 | ASCII值 | 字符 | ASCII值 | 字符 |
---|---|---|---|---|---|---|---|
0 | NUT | 32 | (space) | 64 | @ | 96 | 、 |
1 | SOH | 33 | ! | 65 | A | 97 | a |
2 | STX | 34 | " | 66 | B | 98 | b |
3 | ETX | 35 | # | 67 | C | 99 | c |
4 | EOT | 36 | $ | 68 | D | 100 | d |
5 | ENQ | 37 | % | 69 | E | 101 | e |
6 | ACK | 38 | & | 70 | F | 102 | f |
7 | BEL | 39 | , | 71 | G | 103 | g |
8 | BS | 40 | ( | 72 | H | 104 | h |
9 | HT | 41 | ) | 73 | I | 105 | i |
10 | LF | 42 | * | 74 | J | 106 | j |
11 | VT | 43 | + | 75 | K | 107 | k |
12 | FF | 44 | , | 76 | L | 108 | l |
13 | CR | 45 | - | 77 | M | 109 | m |
14 | SO | 46 | . | 78 | N | 110 | n |
15 | SI | 47 | / | 79 | O | 111 | o |
16 | DLE | 48 | 0 | 80 | P | 112 | p |
17 | DCI | 49 | 1 | 81 | Q | 113 | q |
18 | DC2 | 50 | 2 | 82 | R | 114 | r |
19 | DC3 | 51 | 3 | 83 | S | 115 | s |
20 | DC4 | 52 | 4 | 84 | T | 116 | t |
21 | NAK | 53 | 5 | 85 | U | 117 | u |
22 | SYN | 54 | 6 | 86 | V | 118 | v |
23 | TB | 55 | 7 | 87 | W | 119 | w |
24 | CAN | 56 | 8 | 88 | X | 120 | x |
25 | EM | 57 | 9 | 89 | Y | 121 | y |
26 | SUB | 58 | : | 90 | Z | 122 | z |
27 | ESC | 59 | ; | 91 | [ | 123 | { |
28 | FS | 60 | < | 92 | / | 124 | | |
29 | GS | 61 | = | 93 | ] | 125 | } |
30 | RS | 62 | > | 94 | ^ | 126 | ` |
31 | US | 63 | ? | 95 | _ | 127 | DEL |
ASCII 码大致由以下两部分组成:
转义字符
作用:
\n \\ \t
。转义字符 | 含义 | ASCII码值(十进制) |
---|---|---|
\n | 换行(LF) ,将当前位置移到下一行开头 | 010 |
\t | 水平制表(HT) (跳到下一个TAB位置) | 009 |
\\ | 代表一个反斜线字符\ | 092 |
\' | 代表一个单引号(撇号)字符 | 039 |
作用:
C
语言的字符数组。语法:
string 变量名;
string = "abcd";
注意:
C++
中支持,使用须添加头文件 #include <string>
。string
类型大小与其所含的的字符长度有关。字符串的输入和输出
string
:cin >>
或 cout <<
直接输出即可。C++语言代码示例:
#include <iostream>
#include <string>
using namespace std;
int main(){
string s1 = "a"; //定义一个string型的变量s1,初始化值为"a"
string s2; //定义一个string型的变量s2
cin >> s2; //读入s2的值
cout << s1 << endl << s2; //输出s1的值后输出一个回车,再输出s2
return 0;
}
更多支持操作参见string 容器。
C与C++表达字符串的对比:
C语言代码示例:
#include <stdio.h>
int main(){
char a[100] = "lys is a doge"; //C语言可以借助字符数组来达到同样效果
printf("%s\n",a);
return 0;
}
C++语言代码示例:
#include <iostream>
#include <string>
using namespace std;
int main(){
string a = "lys is a doge";
cout << a << endl;
return 0;
}
作用:
true
(真) 或 false
(假) 的值 。语法:
bool 变量名;
bool 变量名 = true;
bool 变量名 = 1;
注意
C++
中支持。bool
类型只有两个值,true
或 false
。字符串的输入和输出
bool
:cin >>
或 cout <<
直接输出即可。C++语言代码示例:
#include <iostream>
using namespace std;
int main(){
bool a = false, b = 1; //定义一个bool型的变量a,b,初始化值为true和1
bool n; //定义一个bool型的变量n
cin >> n; //读入n的值,只能是0或1
cout << a << " " << b << endl; //输出a的值后输出一个空格,再输出b的值和一个回车
cout << n << endl; //输出n的值和一个回车
return 0;
}
作用:
语法:
const 数据类型 常量名 = 初始化值
#define 常量名 常量值
注意:
C语言代码示例:
#include <stdio.h>
#define b 20 //宏定义的方式定义常量
int main(){
const int a = 10; //const 方式定义常量
/*
a = 20; //a是常量不可修改,否则报错
b = 10; //b是常量不可修改,否则报错
*/
printf("%d %d", a, b);
return 0;
}
关键字:
C/C++
中预先保留的单词(标识符)。C/C++关键字:
asm | do | if | return | typedef |
---|---|---|---|---|
auto | double | inline | short | typeid |
bool | dynamic_cast | int | signed | typename |
break | else | long | sizeof | union |
case | enum | mutable | static | unsigned |
catch | explicit | namespace | static_cast | using |
char | export | new | struct | virtual |
class | extern | operator | switch | void |
const | false | private | template | volatile |
const_cast | float | protected | this | wchar_t |
continue | for | public | throw | while |
default | friend | register | true | |
delete | goto | reinterpret_cast | try |
命名规则:
作用:
规则:
在一些时候(比如某个函数接受 int
类型的参数,但传入了 double
类型的变量),我们需要将某种类型,转换成另外一种类型。
C++
中类型的转换机制较为复杂,这里主要介绍对于基础数据类型的两种转换:数值提升和数值转换。
数值提升:
数值提升过程中,值本身保持不变。
char
类型和 short
类型在进行算术运算时会自动提升为 int
类型。类似地,unsigned short
类型在进行算术运算时会自动提升为 unsigned int
类型。long long
类型参数的函数中传入 int
类型的变量),可以将位宽较小的整型变量提升为位宽较大的整型变量(注意符号性需保持不变,若符号性改变,则发生数值转换)。一个常见情况是:位宽较小的变量与位宽较大的变量进行算术运算时,会先将位宽较小的变量提升为位宽较大的变量。float
类型的变量和 double
类型的变量进行算术运算时,会将 float
类型变量提升为 double
类型变量),其值不变。数值转换:
数值转换过程中,值可能会发生改变。
bool
类型时,零值转换为 false
,非零值转换为 true
。作用:
算术运算符包括以下符号:
运算符 | 术语 | 示例 | 结果 |
---|---|---|---|
+ | 正号 | +3 | 3 |
- | 负号 | -3 | -3 |
+ | 加 | 10 + 5 | 15 |
- | 减 | 10 - 5 | 5 |
* | 乘 | 10 * 5 | 50 |
/ | 除 | 10 / 5 | 2 |
% | 取模(取余数) | 10 % 3 | 1 |
++ | 前置递增 | a = 2; b = ++a; | a = 3; b = 3; |
++ | 后置递增 | a = 2; b = a++; | a = 3; b = 2; |
-- | 前置递减 | a = 2; b = --a; | a = 1; b = 1; |
-- | 后置递减 | a = 2; b = a--; | a = 1; b = 2; |
注意:
++
,再计算表达式,后置递增相反。算术运算符中的类型转换
作用:
转换规则:
char
, bool
, short
等类型提升至 int
(或 unsigned int
,取决于原类型的符号性)类型;long double
,会将另一变量转换为 long double
类型;double
,会将另一变量转换为 double
类型;float
,会将另一变量转换为 float
类型;示例:
对于一个整型( int
)变量 和另一个双精度浮点型( double
)类型变量 :
x / 3
的结果将会是整型;x / 3.0
的结果将会是双精度浮点型;x / y
的结果将会是双精度浮点型;x * 1 / 3
的结果将会是整型;x * 1.0 / 3
的结果将会是双精度浮点型;作用:
赋值运算符包括以下几个符号:
运算符 | 术语 | 示例 | 结果 |
---|---|---|---|
= | 赋值 | a = 2; b = 3; | a = 2; b = 3; |
+= | 加等于 | a = 0; a += 2; | a = 2; |
-= | 减等于 | a = 5; a -= 3; | a = 2; |
*= | 乘等于 | a = 2; a *= 2; | a = 4; |
/= | 除等于 | a = 4; a /= 2; | a = 2; |
%= | 模等于 | a = 3; a %= 2; | a = 1; |
对于复合赋值运算符
+=
:例如a = 0; a += 2;
, 等价为a = 0; a = a + 2
,结果a = 2
,其余复合赋值运算符的运算同理。
作用:
比较运算符有以下符号:
运算符 | 术语 | 示例 | 结果 |
---|---|---|---|
== | 相等于 | 4 == 3 | 0 |
!= | 不等于 | 4 != 3 | 1 |
< | 小于 | 4 < 3 | 0 |
\> | 大于 | 4 > 3 | 1 |
<= | 小于等于 | 4 <= 3 | 0 |
\>= | 大于等于 | 4 >= 1 | 1 |
注意:
==
和赋值运算符 =
区分开来,这在判断语句中尤为重要。if (op=1)
与 if (op==1)
看起来类似,但实际功能却相差甚远。第一条语句是在对 op 进行赋值,若赋值为非 0 时为真值,表达式的条件始终是满足的,无法达到判断的作用;而第二条语句才是对 op
的值进行判断。作用:
逻辑运算符有以下符号:
运算符 | 术语 | 示例 | 结果 |
---|---|---|---|
! | 非 | !a | 如果a为假,则!a为真; 如果a为真,则!a为假。 |
&& | 与 | a && b | 如果a和b都为真,则结果为真,否则为假。 |
|| | 或 | a || b | 如果a和b有一个为真,则结果为真,二者都为假时,结果为假。 |
C++代码示例:
#include <iostream>
using namespace std;
int main(){
bool res;
bool a, b;
cin >> a >> b;
res = a && b; // 当 a 与 b 都为真时则 res 为真
cout << res << endl;
res = a || b; // 当 a 或 b 其中一个为真时则 res 为真
cout << res << endl;
res = !a; // 当 a 为假时则 res 为真
cout << res << endl;
return 0;
}
作用
运算符及运算规则:
& //与运算
0 & 0 = 0 ;
0 & 1 = 0 ;
1 & 0 = 0 ;
1 & 1 = 1 ;
| //或运算
0 | 0 = 0 ;
0 | 1 = 1 ;
1 | 0 = 1 ;
1 | 1 = 1 ;
~ //取反运算
~ 0 = 1 ;
~ 1 = 0 ;
^ //异或运算
0 ^ 0 = 0 ;
0 ^ 1 = 1 ;
1 ^ 0 = 1 ;
1 ^ 1 = 0 ;
>> //右移运算
n >> k //表示 n / 2^k
<< //左移运算
n << k //表示 n * 2*k
常用模板
//求x的第k位数字
x >> k & 1 ;
//求x的最后一位1
x & -x ;
取反及补码
~
。它的作用是把 num 的二进制补码中的 0和 1全部取反( 0 变为 1, 1 变为 0 )。有符号整数的符号位在 ~
运算中同样会取反。异或运算的逆运算
注意:
作用:
,
可将多个表达式分隔开来,被分隔开的表达式按从左至右的顺序依次计算,整个表达式的值是最后的表达式的值。注意:
C++代码示例:
#include <iostream>
using namespace std;
int main(){
int res;
res = 1 + 2, 3 + 4, 5 + 6;
//得到 res 的值为 3 而不是 11,因为赋值运算符 "=" 的优先级比逗号运算符高,先进行了赋值运算才进行逗号运算。
cout << res << endl;
res = (1 + 2, 3 + 4, 5 + 6);
// 若要让 res 的值得到逗号运算的结果则应将整个表达式用括号提高优先级,此时res 的值才为 11。
cout << res << endl;
return 0;
}
作用:
注意:
优先级对照:
C/C++支持最基本的三种程序运行结构:
作用:
语法:
基本 if 语句:
if(条件表达式){
//语句
}
C语言代码示例:
#include <stdio.h>
int main(){
int a; //定义一个int型变量a
scanf("%d", &a); //读入a的值
if(a != 0){ //如果a的值不为0
printf("%d\n", a); //输出a的值并输出一个回车
}
//若a的值为0,则不会执行任何内容,程序正常退出
return 0;
}
if...else 语句
if(条件表达式){
//语句1
}
else{
//语句2
}
C语言代码示例:
#include <stdio.h>
int main(){
int a; //定义一个int型变量a
scanf("%d", &a); //读入a的值
if(a != 0){ //如果a的值不为0
printf("%d\n", a); //输出a的值并输出一个回车
}
else{
printf("a的值为0!\n"); //若a的值为0,输出"a的值为0!"并输出一个回车
}
return 0;
}
else if 语句
if(条件表达式1){
//语句1
}
else if(条件表达式2){
//语句2
}
else{
//语句3
}
C语言代码示例:
#include <stdio.h>
int main(){
int a; //定义一个int型变量a
scanf("%d", &a); //读入a的值
if(a > 100){ //如果a的值大于100
printf("%d\n", a - 100); //输出a - 100的值并输出一个回车
}
else if(a > 0 && a <= 100){ //如果a的值大于0且a的值小于等于100
printf("%d\n", a + 100); //输出a + 100的值并输出一个回车
}
else if(a == 0){ //若a的值为0
printf("a的值为0!\n"); //输出"a的值为0!"并输出一个回车
}
else{
printf("a的值为小于0!\n"); //若a的值不满足以上所有条件,输出"a的值小于0!"并输出一个回车
}
return 0;
}
嵌套 if 语句:
C语言代码示例:
#include <stdio.h>
int main(){
int a; //定义一个int型变量a
scanf("%d", &a); //读入a的值
if(a > 0){
if(a > 100){ //如果a的值大于100
printf("%d\n", a - 100); //输出a - 100的值并输出一个回车
}
else{
printf("%d\n", a + 100); //输出a + 100的值并输出一个回车
}
}
else if(a == 0){ //若a的值为0
printf("a的值为0!\n"); //输出"a的值为0!"并输出一个回车
}
else{
printf("a的值为小于0!\n"); //若a的值不满足以上所有条件,输出"a的值小于0!"并输出一个回车
}
return 0;
}
作用:
语法:表达式1 ? 表达式2 :表达式3
解释:
C语言代码示例:
#include <stdio.h>
int main(){
int a; //定义一个int型变量a
scanf("%d", &a); //读入a的值
int c = a > 0 ? a : -a; //若a的值大于0则c = a,否则c = -a
printf("%d\n", c);
return 0;
}
作用:
语法:
switch(条件表达式){
case 结果1:执行语句1; break;
case 结果2:执行语句2; break;
...
default: 执行语句n; break;
}
注意:
switch
语句执行时,先求出选择句的值,然后根据选择句的值选择相应的标签,从标签处开始执行。switch
语句中还要根据需求加入 break
语句进行中断,否则在对应的 case
被选择之后接下来的所有 case
里的语句和 default
里的语句都会被运行。case
条件时,会统一执行 default
的语句。C语言代码示例:
#include <stdio.h>
int main() {
//请给电影评分
//10 ~ 9 经典
// 8 ~ 7 非常好
// 6 ~ 5 一般
// 5分以下 烂片
int score;
scanf("%d", &score); //输入分数
switch(score){
case 10:
case 9:
printf("经典\n");
break;
case 8:
printf("非常好\n");
break;
case 7:
case 6:
printf("一般\n");
break;
default:
printf("烂片\n");
break;
}
return 0;
}
作用:
语法:
while(条件表达式){
//语句
}
解释:
注意:
C语言代码示例:
#include <stdio.h>
int main() {
int n;
scanf("%d", &n);
int sum = 1;
while(sum <= n){ //当sum小于等于n时执行
printf("%d\n", sum); //输出sum的值和回车
sum ++; //执行完一次循环,sum的值加1
}
return 0;
}
作用:
语法:
do{
//语句
}while(条件表达式);
解释:
注意:与 while
的区别在于 do...while
会先执行一次循环语句,再判断循环条件
C语言代码示例:
#include <stdio.h>
int main() {
int n;
scanf("%d", &n);
int sum = 10;
do{
printf("%d\n", sum); //输出sum的值和回车
sum --; //执行完一次循环,sum的值减1
}while(sum >= n); //当sum大于等于n时执行
//若输入的n值大于10,则仍会先执行一次语句,再判断循环条件
return 0;
}
作用:
语法:
for(初始化条件; 判断条件; 更新){
//语句
}
注意:
for
循环中的表达式,要用分号进行分隔。解释:
C语言代码示例:
#include <stdio.h>
int main() {
int n;
scanf("%d", &n);
for(int i = 1; i <= n; i ++){ //当i小于等于n时,执行循环体内的语句,执行之后,i的值加1
printf("%d\n", i); //输出i的值和一个回车
}
return 0;
}
作用:
C语言代码示例:
#include <stdio.h>
int main() {
int n;
scanf("%d", &n);
for(int i = 1; i <= n; i ++){ //当i小于等于n时,执行循环体内的语句,执行之后,i的值加1
for(int j = 1; j <= i; j ++){//当j小于等于i时,执行循环体内的语句,执行之后,j的值加1
printf("%d ", j); //输出j的值
}
printf("\n"); //执行完内层的循环之后,输出一次回车
}
return 0;
}
作用:
switch
条件语句中,作用是终止case
并跳出switch
。C语言代码示例1:
#include <stdio.h>
int main() {
int n;
scanf("%d", &n);
for(int i = 1; i <= n; i ++){ //当i小于等于n时,执行循环体内的语句,执行后i的值加1
printf("%d ", i); //输出i的值和一个空格
if(i == 10){ //若i的值为10,则终止循环
break;
}
}
//当n小于等于10,会输出1 2 3 ... n
//当n大于10时,会输出1 2 3 ... 10
return 0;
}
C语言代码示例2:
#include <stdio.h>
int main() {
int n;
scanf("%d", &n);
for(int i = 1; i <= n; i ++){ //当i小于等于n时,执行循环体内的语句,执行后i的值加1
for(int j = 1; j <= i; j ++){ //当j小于等于i时,执行循环体内的语句,执行之后,j的值加1
printf("%d ", j); //输出j的值
if(j == 5){ //j的值为5时,退出该层循环
break;
}
}
printf("\n"); //执行完内层的循环之后,输出一次回车
}
return 0;
}
作用:
注意:
continue
并没有使整个循环终止,而 break
会跳出循环。C语言代码示例:
#include <stdio.h>
int main() {
int n;
scanf("%d", &n);
for(int i = 1; i <= n; i ++){ //当i小于等于n时,执行循环体内的语句,执行后i的值加1
if(i % 2 == 0){ //当i为偶数时,跳过本次循环,不再执行下面的语句
continue;
}
printf("%d ", i); //输出i的值和一个空格
}
//执行后会输出所有不大于n的所有奇数
return 0;
}
程序 = 逻辑 + 数据
,数组是存储数据的强而有力的手段。 ——闫学灿
语法:
数据类型 数组名[ 数组长度 ];
数据类型 数组名[ 数组长度 ] = { 值1,值2 ...};
数据类型 数组名[ ] = { 值1,值2 ...};
解释:
int a[d]
,其中,int
说明该数组是int
类型的数组,里面存放的所有元素均为int
类型,a
是数组的名字,d
是数组中元素的个数。C99
之前:元素数量必须是编译时确定的字面量,C99
开始我们已经可以用变量来定义数组的大小。int a[100];
int d1 = 100;
const int d2 = 100;
int a1[d1]; // 正确:C99支持该定义方式
int a2[d2]; // 正确:a2 是一个长度为 100 的数组
关于C99
C99
标准是 ISO/IEC 9899:1999 - Programming languages -- C 的简称,是C
语言的官方标准第二版。注意:
int a1[3];
int a2[3] = a1[3]; // 错误
int a3[3];
a3 = a1; // 错误
main()
函数外的全局区。因为局部变量会被创建在栈区中,过大(大于栈的大小)的数组会爆栈,进而导致 RE。如果将数组声明在全局作用域中,就会在静态区中创建数组。 #include <stdio.h>
int main(){
int a[100000000]; //数组过大,导致爆栈,运行错误,使得程序异常退出
printf("数组定义成功");
return 0;
}
#include <stdio.h>
int a[100000000]; //数组建立在全局区,程序正常运行
int main(){
printf("数组定义成功");
return 0;
}
语法:
数组名[下标];
注意:
C语言代码示例:
#include <stdio.h>
int main() {
//定义方式1
//数据类型 数组名[元素个数];
int score1[10];
//利用下标赋值
score1[0] = 100;
score1[1] = 99;
score1[2] = 85;
//利用下标输出
printf("%d\n", score1[0]);
printf("%d\n", score1[1]);
printf("%d\n", score1[2]);
//第二种定义方式
//数据类型 数组名[元素个数] = {值1,值2 ,值3 ...};
//如果{}内不足10个数据,剩余数据用0补全
int score2[10] = { 100, 90,80,70,60,50,40,30,20,10 };
//逐个输出
// printf("%d ",score2[0]);
// printf("%d ",score2[1]);
// ...
// printf("%d ",score2[9]);
//一个一个输出太麻烦,因此可以利用循环进行输出
for (int i = 0; i < 10; i++){
printf("%d ",score2[i]);
}
printf("\n");
//定义方式3
//数据类型 数组名[] = {值1,值2 ,值3 ...};
int score3[] = { 100,90,80,70,60,50,40,30,20,10 };
for (int i = 0; i < 10; i++){
printf("%d ",score3[i]);
}
printf("\n");
return 0;
}
C++语言代码示例:
#include <iostream>
using namespace std;
int main() {
//定义方式1
//数据类型 数组名[元素个数];
int score1[10];
//利用下标赋值
score1[0] = 100;
score1[1] = 99;
score1[2] = 85;
//利用下标输出
cout << score1[0] << endl;
cout << score1[1] << endl;
cout << score1[2] << endl;
//第二种定义方式
//数据类型 数组名[元素个数] = {值1,值2 ,值3 ...};
//如果{}内不足10个数据,剩余数据用0补全
int score2[10] = { 100, 90,80,70,60,50,40,30,20,10 };
//逐个输出
//cout << score2[0] << " " << endl;
//...
//cout << score2[1] << " " << endl;
//一个一个输出太麻烦,因此可以利用循环进行输出
for (int i = 0; i < 10; i++){
cout << score2[i] << " ";
}
cout << endl;
//定义方式3
//数据类型 数组名[] = {值1,值2 ,值3 ...};
int score3[] = { 100,90,80,70,60,50,40,30,20,10 };
for (int i = 0; i < 10; i ++){
cout << score3[i] << " ";
}
cout << endl;
return 0;
}
作用:
注意
示例:
#include <iostream>
using namespace std;
int main(){
//数组名用途
//1、可以获取整个数组占用内存空间大小
int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
cout << "整个数组所占内存空间为: " << sizeof(a) << endl; //sizeof() 关键字可以返对应参数的大小
cout << "每个元素所占内存空间为: " << sizeof(a[0]) << endl;
cout << "数组的元素个数为: " << sizeof(a) / sizeof(a[0]) << endl;
// //2、可以通过数组名获取到数组首地址
cout << "数组的首元素值为:" << *a << endl; //*a 表示解引用,具体参见指针相关内容
cout << "数组首地址为: " << &a << endl; //&a 表示取数组a的首元素的地址,默认输出为16进制
cout << "数组中第一个元素地址为: " << &a[0] << endl;
cout << "数组中第二个元素地址为: " << (long long)&a[1] << endl; //输出地址为10进制
//arr = 100; 错误,数组名是常量,因此不可以赋值
return 0;
}
总结:
sizeof
,可以获取整个数组占内存空间的大小。语法:
数据类型 数组名[ 行数 ][ 列数 ];
数据类型 数组名[ 行数 ][ 列数 ] = { {数据1,数据2 } ,{数据3,数据4 } };
数据类型 数组名[ 行数 ][ 列数 ] = { 数据1,数据2,数据3,数据4};
数据类型 数组名[ ][ 列数 ] = { 数据1,数据2,数据3,数据4};
TIPS:以上4种定义方式,第二种更加直观,提高代码的可读性。
解释:
int Arry[3][4]
,那就指的是定义了一个三行四列的矩阵形状的二维数组,如下图所示。语法:
数组名[下标1][下标2]
注意:
C++代码示例
#include <iostream>
using namespace std;
int main() {
//方式1
//数组类型 数组名 [行数][列数]
int a[2][3];
a[0][0] = 1;
a[0][1] = 2;
a[0][2] = 3;
a[1][0] = 4;
a[1][1] = 5;
a[1][2] = 6;
for (int i = 0; i < 2; i ++){
for (int j = 0; j < 3; j ++){
cout << a[i][j] << " ";
}
cout << endl;
}
//方式2
//数据类型 数组名[行数][列数] = { {数据1,数据2 } ,{数据3,数据4 } };
int a2[2][3] =
{
{1,2,3},
{4,5,6}
};
//方式3
//数据类型 数组名[行数][列数] = { 数据1,数据2 ,数据3,数据4 };
int a3[2][3] = { 1,2,3,4,5,6 };
//方式4
//数据类型 数组名[][列数] = { 数据1,数据2 ,数据3,数据4 };
int a4[][3] = { 1,2,3,4,5,6 };
return 0;
}
作用:
注意:
sizeof
时,可以获取整个二维数组占用的内存空间大小。C++代码示例
#include <iostream>
using namespace std;
int main() {
//二维数组数组名
int a[2][3] =
{
{1,2,3},
{4,5,6}
};
cout << "二维数组大小: " << sizeof(a) << endl;
cout << "二维数组一行大小: " << sizeof(a[0]) << endl;
cout << "二维数组元素大小: " << sizeof(a[0][0]) << endl;
cout << "二维数组行数: " << sizeof(a) / sizeof(a[0]) << endl;
cout << "二维数组列数: " << sizeof(a[0]) / sizeof(a[0][0]) << endl;
//地址
cout << "二维数组首地址:" << a << endl; //默认输出十六进制地址
cout << "二维数组第一行地址:" << a[0] << endl;
cout << "二维数组第二行地址:" << (long long)a[1] << endl; //输出10进制地址
cout << "二维数组第一个元素地址:" << &a[0][0] << endl;
cout << "二维数组第二个元素地址:" << &a[0][1] << endl;
return 0;
}
考试成绩统计:
案例描述:有三名同学(张三,李四,王五),在一次考试中的成绩分别如下表,请分别输出三名同学的总成绩。
语文 | 数学 | 英语 | |
---|---|---|---|
张三 | 100 | 100 | 100 |
李四 | 90 | 50 | 100 |
王五 | 60 | 70 | 80 |
C++代码示例
#include <iostream>
#include <string>
using namespace std;
int main(){
int scores[3][3] =
{
{100,100,100},
{90,50,100},
{60,70,80},
};
string names[3] = { "张三","李四","王五" };
for (int i = 0; i < 3; i ++){
int sum = 0;
for (int j = 0; j < 3; j ++){
sum += scores[i][j];
}
cout << names[i] << "同学总成绩为: " << sum << endl;
}
return 0;
}
函数声明:
函数定义:
return
表达式。语法:
返回值类型 函数名(参数列表){
函数体语句
return 表达式;
}
关于声明和定义:
return
表达式: 和返回值类型挂钩,函数执行完后,返回相应的数据。void
,无返回值的函数执行到 return ;
语句也会结束执行。语法示例:
int
,函数名为 add
的函数,并定义为求两个 int
类型的数之和。 //函数
int add(int num1, int num2){ //返回值类型为int,传入两个int型参数num1和num2
int sum = num1 + num2; //函数内执行语句
return sum; //将执行语句后的值返回,该值的数据类型为int
}
作用:
语法:
函数名 (参数);
C语言代码示例:
#include <stdio.h>
//函数
int add(int num1, int num2){ //返回值类型为int,传入两个int型参数num1和num2
int sum = num1 + num2; //函数内执行语句
return sum; //将执行语句后的值返回,该值的数据类型为int
}
int main(){
int a, b;
scanf("%d %d", &a, &b);
int c = add(a, b); //定义一个与add函数返回值相同的int类型的变量c来接收返回值
printf("%d\n", c); //输出该值
printf("%d", add(a, b)); //直接输出返回值
return 0;
}
作用:
C语言代码示例:
#include <stdio.h>
//函数
int age(int n){
if(n == 1){ //当编号为1时,返回编号为1的学生年龄
return 8;
}
else{
return age(n - 1) + 2; //否则编号n - 1,递归到下一层age(n - 1),且年龄 + 2
}
}
int main(){
int n;
scanf("%d", &n); //输入学生编号
printf("%d", age(n));
return 0;
}
实参与形参:
函数的值传递:
C语言代码示例:
#include <stdio.h>
//函数
int add(int num1, int num2){ //实参a将值传递给形参num1,实参b将值传递给num2
num1 += num2; //形参num1的值变为num1 + num2
return num1; //将改变值的形参num1的值返回
}
int main(){
int a, b;
scanf("%d %d", &a, &b);
int c = add(a, b); //定义一个与add函数返回值相同的int类型的变量c来接收返回值
printf("%d\n", c); //输出该值
printf("%d %d\n", a, b); //输出实参a b 的值,发现a和b并未改变
return 0;
}
作用:
语法
C++
语言中支持通过引用 &
传递,语法较为简单。C/C++
语言均支持指针传递,详情参见指针相关内容。关于&:
&
表示“取地址”。C++
语言中,作为函数的参数传递时,代表“引用”传递。作用:
语法:
数据类型 &别名 = 原名;
注意:
C++
语言支持,C
语言可以利用指针达到同样效果,但实际上,引用的内部实现是一个指针常量。C++语言代码示例:
#include <iostream>
using namespace std;
int main(){
int a = 10;
int &b = a; //创建a的别名为b 必须初始化
cout << "a = " << a <<endl;
cout << "b = " << b << endl; //b的值同a
//修改a的值
a = 20;
cout << "a = " << a <<endl; //a的值改变
cout << "b = " << b <<endl; //b的值也发生改变
//修改b的值
b = 100;
cout << "a = " << a <<endl; //a的值也发生改变
cout << "b = " << b <<endl; //b的值改变
return 0;
}
注意事项:
C++语言代码示例:
#include <iostream>
using namespace std;
int main(){
int a = 10;
int b = 20;
//int &c; //错误,引用必须初始化
int &c = a;
//&c = b; //一旦初始化后,就不可以更改
c = b; //这是赋值操作,不是更改引用
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
return 0;
}
作用:
C++代码示例
#include <iostream>
using namespace std;
int add(int &num1, int &num2){ //a通过引用的方式传递给num1, b也通过引用的方式传递给num2
num1 += num2; //num1的值改变,则函数体外的实参a也将改变
return num1;
}
int main(){
int a, b;
cin >> a >> b;
int c = add(a, b);
cout << c << endl;
cout << a << endl;
return 0;
}
作用:
语法:
// 尽管形式不同,但这三个call函数是等价的
void call(int *a){
语句;
}
void call(int a[]){
语句;
}
void call(int a[10]){
语句;
}
C语言代码示例:
#include <stdio.h>
void call_1(int a[], int n){
printf("调用call_1输出数组:\n");
for(int i = 0; i < n; i ++){
printf("%d ",a[i]);
}
printf("\n");
}
void call_2(int a[], int n){
printf("调用call_2输出数组:\n");
for(int i = 0; i < n; i ++){
printf("%d ",a[i]);
a[i] = 0; //改变a[i],nums[i]也同时改变
}
printf("\n");
}
int main(){
int n = 10;
int nums[n] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
call_1(nums, n);
printf("调用call_1之后的数组值:\n");
for(int i = 0; i < n; i ++){
printf("%d ",nums[i]);
}
printf("\n");
call_2(nums, n);
printf("调用call_1之后的数组值:\n");
for(int i = 0; i < n; i ++){
printf("%d ",nums[i]);
}
printf("\n");
return 0;
}
语法:
// 多维数组中,除了第一维之外,其余维度的大小必须指定
void call(int (*a)[10]){
语句;
}
void call(int a[][10]){
语句;
}
C语言代码示例:
#include <stdio.h>
void call(int a[][3], int n, int m){
printf("调用call输出二维数组:\n");
for(int i = 0; i < n; i ++){
for(int j = 0; j < m; j ++){
printf("%d ", a[i][j]);
a[i][j] = 0; //改变a[i][j]的值,nums[i][j]的值也同时改变
}
printf("\n");
}
printf("\n");
}
int main(){
int n = 2, m = 3;
int nums[2][3] = {{1, 2, 3}, {4, 5, 6}};
call(nums, n, m);
printf("调用call后,输出二维数组:\n");
for(int i = 0; i < n; i ++){
for(int j = 0; j < m; j ++){
printf("%d ", nums[i][j]);
nums[i][j] = 0;
}
printf("\n");
}
return 0;
}
作用:
语法:
数据类型 * 变量名;
解释:
&
符号 获取变量的地址,利用指针可以接收这个地址,对指针变量解引用,可以操作指针指向的内存。指针变量和普通变量的区别
*
操作符,操作指针变量指向的内存空间,这个过程称为解引用。C语言代码示例:
#include <stdio.h>
int main(){
//1、指针的定义
int a = 10; //定义整型变量a
//指针定义语法: 数据类型 * 变量名 ;
int * p;
//指针变量赋值
p = &a; //指针指向变量a的地址
printf("&a = %d\n", &a); //打印数据a的地址
printf("p = %d\n", p); //打印指针变量p
//2、指针的使用
//通过*操作指针变量指向的内存
printf("*p = %d\n", *p);
return 0;
}
解释:
C语言代码示例:
#include <stdio.h>
int main(){
int a = 10;
int * p;
p = &a; //指针指向数据a的地址
printf("*p = %d\n", *p); //* 解引用
printf("sizeof(*p) = %d\n",sizeof(*p));
printf("\n");
printf("sizeof(int *) = %d\n",sizeof(int *));
printf("sizeof(char *) = %d\n",sizeof(char *));
printf("sizeof(float *) = %d\n",sizeof(float *));
printf("sizeof(double *) = %d\n",sizeof(double *));
return 0;
}
空指针:
作用:
注意:
C语言代码示例:
#include <stdio.h>
int main(){
//指针变量p指向内存地址编号为0的空间
int * p = NULL;
//访问空指针报错
//内存编号0 ~255为系统占用内存,不允许用户访问
printf("*p = %d\n", *p);
return 0;
}
野指针:
注意:
C语言代码示例:
#include <stdio.h>
int main(){
//指针变量p指向内存地址编号为0x1100的空间
int * p = (int *)0x1100;
//访问野指针运行错误
printf("*p = %d\n", *p);
return 0;
}
分类:
const
修饰指针——常量指针。const
修饰常量——指针常量。const
即修饰指针,又修饰常量。技巧:
const
右侧紧跟着的是指针还是常量, 是指针就是常量指针,是常量就是指针常量。C语言代码示例:
#include <stdio.h>
int main() {
int a = 10;
int b = 10;
const int * p1 = &a;
p1 = &b; //正确
//*p1 = 100; 报错
printf("const修饰的是指针时,指针指向可以改,指针指向的值不可以更改\n");
int * const p2 = &a;
//p2 = &b; //错误
*p2 = 100; //正确
printf("const修饰的是常量时,指针指向不可以改,指针指向的值可以更改\n");
//const既修饰指针又修饰常量
const int * const p3 = &a;
//p3 = &b; //错误
//*p3 = 100; //错误
printf("const既修饰指针又修饰常量时,指针指向和指针指向的值都不可以更改\n");
return 0;
}
作用:
注意:
C语言代码示例:
#include <stdio.h>
int main(){
int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int * p = a; //指向数组的指针
printf("下标访问数组首元素: %d\n", a[0]);
printf("指针访问数组首元素: %d\n", *p);
for (int i = 0; i < 10; i++){
//利用指针遍历数组
printf("%d ", *p);
p ++;
}
return 0;
}
作用:
注意:
C语言代码示例:
#include <stdio.h>
//值传递,不改变实参
void swap_1(int a, int b){
int t = a;
a = b;
b = t;
printf("调用swap_1: a = %d b = %d\n", a, b);
}
//地址传递,修改实参
void swap_2(int *a, int *b){
int t = *a;
*a = *b;
*b = t;
printf("调用swap_2: a = %d b = %d\n", *a, *b);
}
int main(){
int a, b;
a = 10, b = 20;
swap_1(a, b);
printf("调用swap_1后,a = %d b = %d\n", a, b);
swap_2(&a, &b);
printf("调用swap_2后,a = %d b = %d\n", a, b);
return 0;
}
案例描述:
注意:
C语言代码示例:
#include <stdio.h>
//冒泡排序函数
void bubbleSort(int * num, int len){ //int * num 也可以写为int num[]
for (int i = 0; i < len - 1; i ++){
for (int j = 0; j < len - 1 - i; j ++){
if (num[j] > num[j + 1]){
int temp = num[j];
num[j] = num[j + 1];
num[j + 1] = temp;
}
}
}
}
//打印数组函数
void printArray(int num[], int len){
for (int i = 0; i < len; i ++){
printf("%d ", num[i]);
}
printf("\n");
}
int main() {
int a[10] = {4, 3, 6, 9, 1, 2, 10 ,8 ,7 ,5};
int len = sizeof(a) / sizeof(int);
bubbleSort(a, len);
printArray(a, len);
printf("调用以上函数后,原数组的值:\n");
for(int i = 0; i < 10; i ++) printf("%d ", a[i]);
return 0;
}
作用:
C
语言中的 struct
可以看做是一系列称为成员元素的组合体,而在 C++
语言中 struct
被扩展为类似 class
的类说明符。语法:
//定义结构体类型
struct 结构体名{
数据类型 变量名1;
数据类型 变量名2;
...
};
//创建变量方式
//方式1
struct 结构体名{
数据类型 变量名1;
数据类型 变量名2;
...
}变量名;
//方式2
struct 结构体名 变量名;
//方式3
struct 结构体名 变量名 = {值1, 值2, ...};
解释:
//定义结构体类型
struct point{
int x;
int y;
};
//创建变量方式
//方式1
struct point{
int x;
int y;
}a;
//方式2
struct point b;
//方式3
struct point c = {1,2};
point
的结构体,两个成员元素 x, y
,类型都为 int
。struct point c = {1,2};
创建了一个 point
类型的变量 c
,其数据成员 x = 1, y = 2
。注意:
struct
,不可省略。struct
可以省略,例如上述例子中的创建变量方式 3,使用语句 point c = {1,2};
亦合法。.
访问成员。C语言代码示例:
#include <stdio.h>
//结构体定义
struct student{
//成员列表
char name[100]; //姓名
int age; //年龄
int score; //分数
}stu3; //结构体变量创建方式3
int main(){
//结构体变量创建方式1
student stu1; //struct 关键字可以省略
//结构体变量创建方式2
struct student stu2 = {"lys", 14, 100};
printf("姓名:%s 年龄:%d 分数:%d\n",stu2.name, stu2.age, stu2.score);
return 0;
}
作用:
语法:
//定义结构体类型
struct 结构体名{
数据类型 变量名1;
数据类型 变量名2;
...
}数组名[数组长度];
C语言代码示例:
#include <stdio.h>
//结构体定义
struct student{
//成员列表
char name[100]; //姓名
int age; //年龄
int score; //分数
};
int main() {
//结构体数组
student stu[3]=
{
{"lys", 14, 99 },
{"ccf", 14, 99 },
{"hfcj", 99, 0}
};
for (int i = 0; i < 3; i++){
printf("姓名:%s 年龄:%d 成绩:%d\n", stu[i].name, stu[i].age, stu[i].score);
}
return 0;
}
作用:
语法:
->
可以通过结构体指针访问结构体属性。-> 与 . 的区别:
->
是指向结构体成员运算符,.
是断点符号,不属于运算符。->
所指向的是结构体或对象的首地址,.
所指向的是结构体或对象。p -> name
等价于 (*p).name
,两种表示等价。C语言代码示例:
#include <stdio.h>
//结构体定义
struct student{
//成员列表
char name[100]; //姓名
int age; //年龄
int score; //分数
};
int main(){
student stu = {"lys", 14, 0};
student * p = &stu;
p -> score = 100; //指针通过 -> 操作符可以访问成员
printf("姓名:%s 年龄:%d 成绩:%d\n", p -> name, p -> age, p -> score);
return 0;
}
作用:
C语言代码示例:
#include <stdio.h>
//学生结构体定义
struct student{
//成员列表
char name[100]; //姓名
int age; //年龄
int score; //分数
};
//教师结构体定义
struct teacher{
//成员列表
int id; //职工编号
char name[100]; //教师姓名
int age; //教师年龄
student stu; //子结构体 学生
};
int main(){
struct teacher t1 = {114514, "野兽仙贝", 24, {"lys", 14, 100}};
t1.stu.age = 19;
t1.stu.score = 19;
printf("教师职工编号: %d 教师姓名:%s 教师年龄:%d\n",t1.id, t1.name, t1.age);
printf("该教师的学生姓名:%s 学生年龄:%d 学生分数:%d\n",t1.stu.name, t1.stu.age, t1.stu.score);
return 0;
}
作用:
传递方式:
示例:
#include <stdio.h>
//学生结构体定义
struct student{
//成员列表
char name[100]; //姓名
int age; //年龄
int score; //分数
};
//值传递
void call_1(student stu){
stu.age = 24;
printf("调用call_1时stu的值:\n");
printf("姓名:%s 年龄:%d 分数:%d\n", stu.name, stu.age, stu.score);
printf("\n");
}
//地址传递
void call_2(student *stu){
stu -> age = 24;
printf("调用call_2时stu的值:\n");
printf("姓名:%s 年龄:%d 分数:%d\n", stu -> name, stu -> age, stu -> score);
printf("\n");
}
int main(){
student stu = {"lys",14,100};
//值传递
call_1(stu);
printf("调用call_1后stu的值:\n");
printf("姓名:%s 年龄:%d 分数:%d\n", stu.name, stu.age, stu.score);
printf("\n");
//地址传递
call_2(&stu);
printf("调用call_2后stu的值:\n");
printf("姓名:%s 年龄:%d 分数:%d\n", stu.name, stu.age, stu.score);
printf("\n");
return 0;
}
案例描述:
给出五名学生的学号、姓名、总成绩,按照成绩从大到小排序,若成绩相同则学号小的优先。
注意:
C++
语言中的 sqrt()
函数需要添加头文件 #include <algorithm>
。C++语言代码示例:
#include <iostream>
#include <algorithm>
using namespace std;
struct student{
int num;
string name;
int sum;
};
bool cmp(student &s1, student &s2){
if(s1.sum == s2.sum) return s1.num < s2.num;
return s1.sum > s2.sum;
}
int main(){
student stu[5] = {
{202111, "Aa", 88},
{202112, "Bb", 92},
{202113, "Cc", 73},
{202114, "Dd", 92},
{202115, "Ee", 89},
};
sort(stu, stu + 5, cmp);
for(int i = 0; i < 5; i ++){
cout << stu[i].num << " " << stu[i].name << " " << stu[i].sum << endl;
}
return 0;
}