关于c++:CC基础入门

66次阅读

共计 27544 个字符,预计需要花费 69 分钟才能阅读完成。

1 C++ 初识

1.1 第一个 C ++ 程序

编写一个 C ++ 程序总共分为 4 个步骤

  • 创立我的项目
  • 创立文件
  • 编写代码
  • 运行程序

1.1.1 创立我的项目

​ Visual Studio 是咱们用来编写 C ++ 程序的次要工具,咱们先将它关上

1.1.2 创立文件

右键源文件,抉择增加 -> 新建项

给 C ++ 文件起个名称,而后点击增加即可。

1.1.3 编写代码

#include <iostream>
using namespace std; // 此行必不可少, 如果省略则无奈间接应用 cout,cin,endl,dec,hex,oct 等等

//#include 编绎命令:将 iostream 文件的内容增加到程序中
//iostream: io 指输出和输入,应用 cin 和 cout 必须蕴含此文件

// 写完一个文件就 Ctrl+A(全选) Ctrl+K+C(正文),要用的时候 Ctrl+ A 而后 Ctrl+K+U(勾销正文)

int main()
{
    cout << "hello world" << endl;

    system("pause");

    return 0;
}

1.1.4 运行程序

1.2 正文

作用:在代码中加一些阐明和解释,不便本人或其余程序员程序员浏览代码

两种格局

  1. 单行正文// 形容信息

    • 通常放在一行代码的上方,或者一条语句的开端,== 对该行代码阐明 ==
  2. 多行正文/* 形容信息 */

    • 通常放在一段代码的上方,== 对该段代码做整体阐明 ==

提醒:编译器在编译代码时,会疏忽正文的内容

#include <iostream>
using namespace std;

//1. 单行正文

//2. 多行正文
    /*
        main 是一个程序的入口
        每个程序都必须有这么一个函数
        但有且仅有一个
    */

// 一个工作区不论几个我的项目,只能在一个时刻调试其中一个(有一个 project 是 active 的),只能有一个 main 函数在运行
// 要想同时运行多个 cpp 文件,能够将 main 更名即可
int main()
{
    // 在屏幕串输入 hello world
    cout << "hello world" << endl;

    system("pause");
    
    return 0;

}

1.3 变量

作用:给一段指定的内存空间起名,不便操作这段内存

语法 数据类型 变量名 = 初始值;

示例:

#include<iostream>
using namespace std;

int main() {

    // 变量的定义
    // 语法:数据类型  变量名 = 初始值

    int a = 10;

    cout << "a =" << a << endl;
    
    system("pause");

    return 0;
}

留神:C++ 在创立变量时,必须给变量一个初始值,否则会报错

1.4 常量

作用:用于记录程序中不可更改的数据

C++ 定义常量两种形式

  1. #define 宏常量:#define 常量名 常量值

    • == 通常在文件上方定义 ==,示意一个常量
  2. const润饰的变量 const 数据类型 常量名 = 常量值

    • == 通常在变量定义前加关键字 const==,润饰该变量为常量,不可批改

示例:

#include <iostream>
using namespace std;

// 利用宏语句进行正文:#if(0)
                    语句;
                    #endif

#if(0) 
变量的定义形式:1.#define: 宏常量
                2.const 润饰的变量
#endif

// 1. #define: 宏常量
#define Day 7

int main()
{
    //Day = 14;   // 谬误,Day 是常量,不可批改,批改就会报错
    cout << "一周有" << Day << "天" << endl;

    //2. const 润饰的变量
    const int month = 12;
    //month = 24;  // 谬误,const 润饰的变量也是常量

    cout << "一年有" << month << "月" << endl;

    system("pause");

    return 0;
}

1.5 关键字

作用:关键字是 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

提醒:在给变量或者常量起名称时候,不要用 C ++ 得关键字,否则会产生歧义。

1.6 标识符命名规定

作用:C++ 规定给标识符(变量、常量)命名时,有一套本人的规定

  • 标识符不能是关键字
  • 标识符只能由字母、数字、下划线组成
  • 第一个字符必须为字母或下划线
  • 标识符中字母辨别大小写

倡议:给标识符命名时,争取做到见名知意的成果,不便本人和别人的浏览

2 数据类型

C++ 规定在创立一个变量或者常量时,必须要指定出相应的数据类型,否则无奈给变量分配内存

2.1 整型

作用:整型变量示意的是 == 整数类型 == 的数据

C++ 中可能示意整型的类型有以下几种形式,区别在于所占内存空间不同

数据类型 占用空间 取值范畴
short(短整型) 2 字节 (-2^15 ~ 2^15-1)
int(整型) 4 字节 (-2^31 ~ 2^31-1)
long(长整形) Windows 为 4 字节,Linux 为 4 字节(32 位),8 字节(64 位) (-2^31 ~ 2^31-1)
long long(长长整形) 8 字节 (-2^63 ~ 2^63-1)

2.2 sizeof 关键字

作用:利用 sizeof 关键字能够 == 统计数据类型所占内存大小 ==

语法: sizeof(数据类型 / 变量)

示例:

int main() {cout << "short 类型所占内存空间为:" << sizeof(short) << endl;

    cout << "int 类型所占内存空间为:" << sizeof(int) << endl;

    cout << "long 类型所占内存空间为:" << sizeof(long) << endl;

    cout << "long long 类型所占内存空间为:" << sizeof(long long) << endl;

    system("pause");

    return 0;
}

整型论断:==short < int <= long <= long long==

2.3 实型(浮点型)

作用:用于 == 示意小数 ==

浮点型变量分为两种:

  1. 单精度 float
  2. 双精度 double

两者的 区别 在于示意的有效数字范畴不同。

数据类型 占用空间 有效数字范畴
float 4 字节 7 位有效数字
double 8 字节 15~16 位有效数字

示例:

int main() {

    float f1 = 3.14f;
    double d1 = 3.14;

    cout << f1 << endl;
    cout << d1<< endl;

    cout << "float  sizeof =" << sizeof(f1) << endl;
    cout << "double sizeof =" << sizeof(d1) << endl;

    // 迷信计数法
    float f2 = 3e2; // 3 * 10 ^ 2 
    cout << "f2 =" << f2 << endl;

    float f3 = 3e-2;  // 3 * 0.1 ^ 2
    cout << "f3 =" << f3 << endl;

    system("pause");

    return 0;
}

2.4 字符型

作用:字符型变量用于显示单个字符

语法:char ch = 'a';

留神 1:在显示字符型变量时,用单引号将字符括起来,不要用双引号

留神 2:单引号内只能有一个字符,不能够是字符串

  • C 和 C ++ 中字符型变量只占用 == 1 个字节 ==。
  • 字符型变量并不是把字符自身放到内存中存储,而是将对应的 ASCII 编码放入到存储单元

示例:

int main() {
    
    char ch = 'a';
    cout << ch << endl;
    cout << sizeof(char) << endl;

    //ch = "abcde"; // 谬误,不能够用双引号
    //ch = 'abcde'; // 谬误,单引号内只能援用一个字符

    cout << (int)ch << endl;  // 查看字符 a 对应的 ASCII 码
    ch = 97; // 能够间接用 ASCII 给字符型变量赋值
    cout << ch << endl;

    system("pause");

    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 码大抵由以下 两局部组 成:

  • ASCII 非打印控制字符:ASCII 表上的数字 0-31 调配给了控制字符,用于管制像打印机等一些外围设备。
  • ASCII 打印字符:数字 32-126 调配给了能在键盘上找到的字符,当查看或打印文档时就会呈现。

2.5 转义字符

作用:用于示意一些 == 不能显示进去的 ASCII 字符 ==

现阶段咱们罕用的转义字符有: \n \\ \t

转义字符 含意 ASCII码值(十进制)
a 警报 007
b 退格(BS),将以后地位移到前一列 008
f 换页(FF),将以后地位移到下页结尾 012
n 换行(LF),将以后地位移到下一行结尾 010
r 回车(CR),将以后地位移到本行结尾 013
t 程度制表(HT)(跳到下一个 TAB 地位) 009
v 垂直制表(VT) 011
\\ 代表一个反斜线字符 ”” 092
代表一个单引号(撇号)字符 039
代表一个双引号字符 034
? 代表一个问号 063
0 数字 0 000
ddd 8 进制转义字符,d 范畴 0~7 3 位 8 进制
xhh 16 进制转义字符,h 范畴 0~9,a~f,A~F 3 位 16 进制

示例:

int main() {
    
    
    cout << "\\" << endl;
    cout << "\tHello" << endl;
    cout << "\n" << endl;

    system("pause");

    return 0;
}

2.6 字符串型

作用:用于示意一串字符

两种格调

  1. C 格调字符串char 变量名[] = "字符串值"

    示例:

    int main() {char str1[] = "hello world";
        cout << str1 << endl;
        
        system("pause");
    
        return 0;
    }

留神:C 格调的字符串要用双引号括起来

  1. C++ 格调字符串string 变量名 = "字符串值"

    示例:

    int main() {
    
        string str = "hello world";
        cout << str << endl;
        
        system("pause");
    
        return 0;
    }

留神:C++ 格调字符串,须要退出头文件 #include < string >

2.7 布尔类型 bool

作用:布尔数据类型代表真或假的值

bool 类型只有两个值:

  • true — 真(实质是 1)
  • false — 假(实质是 0)

bool 类型占 == 1 个字节 == 大小

示例:

int main() {

    bool flag = true;
    cout << flag << endl; // 1

    flag = false;
    cout << flag << endl; // 0

    cout << "size of bool =" << sizeof(bool) << endl; //1
    
    system("pause");

    return 0;
}

2.8 数据的输出

作用:用于从键盘获取数据

关键字:cin

语法: cin >> 变量

示例:

int main(){

    // 整型输出
    int a = 0;
    cout << "请输出整型变量:" << endl;
    cin >> a;
    cout << a << endl;

    // 浮点型输出
    double d = 0;
    cout << "请输出浮点型变量:" << endl;
    cin >> d;
    cout << d << endl;

    // 字符型输出
    char ch = 0;
    cout << "请输出字符型变量:" << endl;
    cin >> ch;
    cout << ch << endl;

    // 字符串型输出
    string str;
    cout << "请输出字符串型变量:" << endl;
    cin >> str;
    cout << str << endl;

    // 布尔类型输出
    bool flag = true;
    cout << "请输出布尔型变量:" << endl;
    cin >> flag;
    cout << flag << endl;
    system("pause");
    return EXIT_SUCCESS;
}

3 运算符

作用:用于执行代码的运算

本章咱们次要解说以下几类运算符:

运算符类型 作用
算术运算符 用于解决四则运算
赋值运算符 用于将表达式的值赋给变量
比拟运算符 用于表达式的比拟,并返回一个真值或假值
逻辑运算符 用于依据表达式的值返回真值或假值

3.1 算术运算符

作用:用于解决四则运算

算术运算符包含以下符号:

运算符 术语 示例 后果
+ 正号 +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;

示例 1:

// 加减乘除
int main() {

    int a1 = 10;
    int b1 = 3;

    cout << a1 + b1 << endl;
    cout << a1 - b1 << endl;
    cout << a1 * b1 << endl;
    cout << a1 / b1 << endl;  // 两个整数相除后果仍然是整数

    int a2 = 10;
    int b2 = 20;
    cout << a2 / b2 << endl; 

    int a3 = 10;
    int b3 = 0;
    //cout << a3 / b3 << endl; // 报错,除数不能够为 0


    // 两个小数能够相除
    double d1 = 0.5;
    double d2 = 0.25;
    cout << d1 / d2 << endl;

    system("pause");

    return 0;
}

总结:在除法运算中,除数不能为 0

示例 2:

// 取模
int main() {

    int a1 = 10;
    int b1 = 3;

    cout << 10 % 3 << endl;

    int a2 = 10;
    int b2 = 20;

    cout << a2 % b2 << endl;

    int a3 = 10;
    int b3 = 0;

    //cout << a3 % b3 << endl; // 取模运算时,除数也不能为 0

    // 两个小数不能够取模
    double d1 = 3.14;
    double d2 = 1.1;

    //cout << d1 % d2 << endl;

    system("pause");

    return 0;
}

总结:只有整型变量能够进行取模运算

示例 3:

// 递增
int main() {

    // 后置递增
    int a = 10;
    a++; // 等价于 a = a + 1
    cout << a << endl; // 11

    // 前置递增
    int b = 10;
    ++b;
    cout << b << endl; // 11

    // 区别
    // 前置递增先对变量进行 ++,再计算表达式
    int a2 = 10;
    int b2 = ++a2 * 10;
    cout << b2 << endl;

    // 后置递增先计算表达式,后对变量进行 ++
    int a3 = 10;
    int b3 = a3++ * 10;
    cout << b3 << endl;

    system("pause");

    return 0;
}

总结:前置递增先对变量进行 ++,再计算表达式,后置递增相同

3.2 赋值运算符

作用:用于将表达式的值赋给变量

赋值运算符包含以下几个符号:

运算符 术语 示例 后果
= 赋值 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;

示例:

int main() {

    // 赋值运算符

    // =
    int a = 10;
    a = 100;
    cout << "a =" << a << endl;

    // +=
    a = 10;
    a += 2; // a = a + 2;
    cout << "a =" << a << endl;

    // -=
    a = 10;
    a -= 2; // a = a - 2
    cout << "a =" << a << endl;

    // *=
    a = 10;
    a *= 2; // a = a * 2
    cout << "a =" << a << endl;

    // /=
    a = 10;
    a /= 2;  // a = a / 2;
    cout << "a =" << a << endl;

    // %=
    a = 10;
    a %= 2;  // a = a % 2;
    cout << "a =" << a << endl;

    system("pause");

    return 0;
}

3.3 比拟运算符

作用:用于表达式的比拟,并返回一个真值或假值

比拟运算符有以下符号:

运算符 术语 示例 后果
== 相等于 4 == 3 0
!= 不等于 4 != 3 1
< 小于 4 < 3 0
> 大于 4 > 3 1
<= 小于等于 4 <= 3 0
>= 大于等于 4 >= 1 1

示例:

int main() {

    int a = 10;
    int b = 20;

    cout << (a == b) << endl; // 0 

    cout << (a != b) << endl; // 1

    cout << (a > b) << endl; // 0

    cout << (a < b) << endl; // 1

    cout << (a >= b) << endl; // 0

    cout << (a <= b) << endl; // 1
    
    system("pause");

    return 0;
}

留神:C 和 C ++ 语言的比拟运算中,==“真”用数字“1”来示意,“假”用数字“0”来示意。==

3.4 逻辑运算符

作用:用于依据表达式的值返回真值或假值

逻辑运算符有以下符号:

运算符 术语 示例 后果
! !a 如果 a 为假,则!a 为真;如果 a 为真,则!a 为假。
&& a && b 如果 a 和 b 都为真,则后果为真,否则为假。
\ \ a \ \ b 如果 a 和 b 有一个为真,则后果为真,二者都为假时,后果为假。

示例 1:逻辑非

// 逻辑运算符  --- 非
int main() {

    int a = 10;

    cout << !a << endl; // 0

    cout << !!a << endl; // 1

    system("pause");

    return 0;
}

总结:真变假,假变真

示例 2:逻辑与

// 逻辑运算符  --- 与
int main() {

    int a = 10;
    int b = 10;

    cout << (a && b) << endl;// 1

    a = 10;
    b = 0;

    cout << (a && b) << endl;// 0 

    a = 0;
    b = 0;

    cout << (a && b) << endl;// 0

    system("pause");

    return 0;
}

总结:逻辑 == 与 == 运算符总结:== 同真为真,其余为假 ==

示例 3:逻辑或

// 逻辑运算符  --- 或
int main() {

    int a = 10;
    int b = 10;

    cout << (a || b) << endl;// 1

    a = 10;
    b = 0;

    cout << (a || b) << endl;// 1 

    a = 0;
    b = 0;

    cout << (a || b) << endl;// 0

    system("pause");

    return 0;
}

逻辑 == 或 == 运算符总结:== 同假为假,其余为真 ==

4 程序流程构造

C/C++ 反对最根本的三种程序运行构造:== 程序构造、抉择构造、循环构造 ==

  • 程序构造:程序按程序执行,不产生跳转
  • 抉择构造:根据条件是否满足,有抉择的执行相应性能
  • 循环构造:根据条件是否满足,循环屡次执行某段代码

4.1 抉择构造

4.1.1 if 语句

作用:执行满足条件的语句

if 语句的三种模式

  • 单行格局 if 语句
  • 多行格局 if 语句
  • 多条件的 if 语句
  1. 单行格局 if 语句:if(条件){条件满足执行的语句}

示例:

int main() {

    // 抉择构造 - 单行 if 语句
    // 输出一个分数,如果分数大于 600 分,视为考上一本大学,并在屏幕上打印

    int score = 0;
    cout << "请输出一个分数:" << endl;
    cin >> score;

    cout << "您输出的分数为:" << score << endl;

    //if 语句
    // 注意事项,在 if 判断语句前面,不要加分号
    if (score > 600)
    {cout << "我考上了一本大学!!!" << endl;}

    system("pause");

    return 0;
}

留神:if 条件表达式后不要加分号

  1. 多行格局 if 语句:if(条件){条件满足执行的语句}else{条件不满足执行的语句};

示例:

int main() {

    int score = 0;

    cout << "请输出考试分数:" << endl;

    cin >> score;

    if (score > 600)
    {cout << "我考上了一本大学" << endl;}
    else
    {cout << "我未考上一本大学" << endl;}

    system("pause");

    return 0;
}
  1. 多条件的 if 语句:if(条件 1){条件 1 满足执行的语句}else if(条件 2){条件 2 满足执行的语句}... else{都不满足执行的语句}

示例:

    int main() {

    int score = 0;

    cout << "请输出考试分数:" << endl;

    cin >> score;

    if (score > 600)
    {cout << "我考上了一本大学" << endl;}
    else if (score > 500)
    {cout << "我考上了二本大学" << endl;}
    else if (score > 400)
    {cout << "我考上了三本大学" << endl;}
    else
    {cout << "我未考上本科" << endl;}

    system("pause");

    return 0;
}

嵌套 if 语句:在 if 语句中,能够嵌套应用 if 语句,达到更准确的条件判断

案例需要:

  • 提醒用户输出一个高考考试分数,依据分数做如下判断
  • 分数如果大于 600 分视为考上一本,大于 500 分考上二本,大于 400 考上三本,其余视为未考上本科;
  • 在一本分数中,如果大于 700 分,考入北大,大于 650 分,考入清华,大于 600 考入人大。

示例:

int main() {

    int score = 0;

    cout << "请输出考试分数:" << endl;

    cin >> score;

    if (score > 600)
    {
        cout << "我考上了一本大学" << endl;
        if (score > 700)
        {cout << "我考上了北大" << endl;}
        else if (score > 650)
        {cout << "我考上了清华" << endl;}
        else
        {cout << "我考上了人大" << endl;}
        
    }
    else if (score > 500)
    {cout << "我考上了二本大学" << endl;}
    else if (score > 400)
    {cout << "我考上了三本大学" << endl;}
    else
    {cout << "我未考上本科" << endl;}

    system("pause");

    return 0;
}

练习案例: 三只小猪称体重

有三只小猪 ABC,请别离输出三只小猪的体重,并且判断哪只小猪最重?!

#include <iostream>
using namespace std;
/*
    有三只小猪 ABC,请别离输出三只小猪的体重,并且判断哪只小猪最重?*/
int main5()
{
    int num1 = 0;
    int num2 = 0;
    int num3 = 0;
    cout << "小猪 A 的分量" << endl;
    cin >> num1;
    cout << "小猪 B 的分量" << endl;
    cin >> num2;
    cout << "小猪 C 的分量" << endl;
    cin >> num3;
    cout << "小猪 A 的分量:" << num1 << endl;
    cout << "小猪 B 的分量:" << num2 << endl;
    cout << "小猪 C 的分量:" << num3 << endl;

    if (num1 > num2)
    {if (num1 > num3)
        {cout << "小猪 A 最重" << endl;}
        else if (num1 == num3)
        {cout << "小猪 A 小猪 C 一样重" << endl;}
        else
        {cout << "小猪 B 最重" << endl;}
    }

    if (num1 == num2)
    {cout << "小猪 A 小猪 B 一样重" << endl;}

    if (num1 < num2)
    {if (num2 > num3)
        {cout << "小猪 B 最重" << endl;}
        else if (num2 == num3)
        {cout << "小猪 B 小猪 C 一样重" << endl;}
        else
        {cout << "小猪 C 最重" << endl;}

    }

        system("pause");
        return 0;

    }

4.1.2 三目运算符

作用: 通过三目运算符实现简略的判断

语法:表达式 1 ? 表达式 2:表达式 3

解释:

如果表达式 1 的值为真,执行表达式 2,并返回表达式 2 的后果;

如果表达式 1 的值为假,执行表达式 3,并返回表达式 3 的后果。

示例:

int main() {

    int a = 10;
    int b = 20;
    int c = 0;

    c = a > b ? a : b;
    cout << "c =" << c << endl;

    //C++ 中三目运算符返回的是变量, 能够持续赋值

    (a > b ? a : b) = 100;

    cout << "a =" << a << endl;
    cout << "b =" << b << endl;
    cout << "c =" << c << endl;

    system("pause");

    return 0;
}

总结:和 if 语句比拟,三目运算符长处是短小整洁,毛病是如果用嵌套,构造不清晰

4.1.3 switch 语句

作用:执行多条件分支语句

语法:

switch(表达式)

{

    case 后果 1:执行语句;break;

    case 后果 2:执行语句;break;

    ...

    default: 执行语句;break;

}

示例:

int main() {

    // 请给电影评分 
    //10 ~ 9   经典   
    // 8 ~ 7   十分好
    // 6 ~ 5   个别
    // 5 分以下 烂片

    int score = 0;
    cout << "请给电影打分" << endl;
    cin >> score;

    switch (score)
    {
    case 10:
    case 9:
        cout << "经典" << endl;
        break;
    case 8:
        cout << "十分好" << endl;
        break;
    case 7:
    case 6:
        cout << "个别" << endl;
        break;
    default:
        cout << "烂片" << endl;
        break;
    }

    system("pause");

    return 0;
}

留神 1:switch 语句中表达式类型只能是整型或者字符型

留神 2:case 里如果没有 break,那么程序会始终向下执行

总结:与 if 语句比,对于多条件判断时,switch 的构造清晰,执行效率高,毛病是 switch 不能够判断区间

4.2 循环构造

4.2.1 while 循环语句

作用:满足循环条件,执行循环语句

语法: while(循环条件){循环语句}

解释:== 只有循环条件的后果为真,就执行循环语句 ==

示例:

int main() {

    int num = 0;
    while (num < 10)
    {
        cout << "num =" << num << endl;
        num++;
    }
    
    system("pause");

    return 0;
}

留神:在执行循环语句时候,程序必须提供跳出循环的进口,否则呈现死循环

while 循环练习案例:== 猜数字 ==

案例形容:零碎随机生成一个 1 到 100 之间的数字,玩家进行猜想,如果猜错,提醒玩家数字过大或过小,如果猜对祝贺玩家胜利,并且退出游戏。

提醒:系统生成随机数

#include <ctime> // 生成随机数函数须要增加此头文件

// 增加随机数种子
// 作用:利用以后零碎工夫生成随机数,避免每次随机数都一样
srand((unsigned int)time(NULL));    // 或者写成 srand((size_t)time(NULL));

// 系统生成随机数
int num = rand() % 100 + 1;

size_t 和 int
size_t 是一些 C /C++ 规范在 stddef.h 中定义的。这个类型足以用来示意对象的大小。size_t 的实在类型与操作系统无关。

在 32 位架构中被广泛定义为:typedef unsigned int size_t;

而在 64 位架构中被定义为:typedef unsigned long size_t;

size_t 在 32 位架构上是 4 字节,在 64 位架构上是 8 字节,在不同架构上进行编译时须要留神这个问题。而 int 在不同架构下都是 4 字节,与 size_t 不同;且 int 为带符号数,size_t 为无符号数。

为什么有时候不必 int,而是用 size_type 或者 size_t:

​ 与 int 固定四个字节不同有所不同,size_t 的取值 range 是指标平台下最大可能的数组尺寸, 一些平台下 size_t 的范畴小于 int 的负数范畴, 又或者大于 unsigned int. 应用 Int 既有可能节约,又有可能范畴不够大。

4.2.2 do…while 循环语句

作用: 满足循环条件,执行循环语句

语法: do{循环语句} while(循环条件);

留神:与 while 的区别在于 ==do…while 会先执行一次循环语句 ==,再判断循环条件

示例:

int main() {

    int num = 0;

    do
    {
        cout << num << endl;
        num++;

    } while (num < 10);
    
    
    system("pause");

    return 0;
}

总结:与 while 循环区别在于,do…while 先执行一次循环语句,再判断循环条件

练习案例:水仙花数

案例形容:水仙花数是指一个 3 位数,它的每个位上的数字的 3 次幂之和等于它自身

例如:1^3 + 5^3+ 3^3 = 153

请利用 do…while 语句,求出所有 3 位数中的水仙花数

4.2.3 for 循环语句

作用: 满足循环条件,执行循环语句

语法: for(起始表达式; 条件表达式; 开端循环体) {循环语句;}

示例:

int main() {for (int i = 0; i < 10; i++)
    {cout << i << endl;}
    
    system("pause");

    return 0;
}

详解:

留神:for 循环中的表达式,要用分号进行分隔

总结:while , do…while, for 都是开发中罕用的循环语句,for 循环构造比拟清晰,比拟罕用

练习案例:敲桌子

案例形容:从 1 开始数到数字 100,如果数字个位含有 7,或者数字十位含有 7,或者该数字是 7 的倍数,咱们打印敲桌子,其余数字间接打印输出。

4.2.4 嵌套循环

作用: 在循环体中再嵌套一层循环,解决一些理论问题

例如咱们想在屏幕中打印如下图片,就须要利用嵌套循环

示例:

int main()
{
    // 外层执行一次,内层执行一周
    for (int i = 0; i < 10; i++)
    {//for (int i = 0; i < 10; i++) 循环嵌套尽量不必反复的变量
        for (int j = 0; j < 10; j++)
        {cout << "*";}
        cout << endl;
    }
    
    system("pause");
    return 0;
 }

练习案例:乘法口诀表

案例形容:利用嵌套循环,实现九九乘法表

4.3 跳转语句

4.3.1 break 语句

作用: 用于跳出 == 抉择构造 == 或者 == 循环构造 ==

break 应用的机会:

  • 呈现在 switch 条件语句中,作用是终止 case 并跳出 switch
  • 呈现在循环语句中,作用是跳出以后的循环语句
  • 呈现在嵌套循环中,跳出最近的内层循环语句

示例 1:

int main() {
    //1、在 switch 语句中应用 break
    cout << "请抉择您挑战正本的难度:" << endl;
    cout << "1、一般" << endl;
    cout << "2、中等" << endl;
    cout << "3、艰难" << endl;

    int num = 0;

    cin >> num;

    switch (num)
    {
    case 1:
        cout << "您抉择的是一般难度" << endl;
            break;
    case 2:
        cout << "您抉择的是中等难度" << endl;
        break;
    case 3:
        cout << "您抉择的是艰难难度" << endl;
        break;
    }

    system("pause");

    return 0;
}

示例 2:

int main() {
    //2、在循环语句中用 break
    for (int i = 0; i < 10; i++)
    {if (i == 5)
        {break; // 跳出循环语句}
        cout << i << endl;
    }

    system("pause");

    return 0;
}

示例 3:

int main() {
    // 在嵌套循环语句中应用 break,退出内层循环
    for (int i = 0; i < 10; i++)
    {for (int j = 0; j < 10; j++)
        {if (j == 5)
            {break;}
            cout << "*" << " ";
        }
        cout << endl;
    }
    
    system("pause");

    return 0;
}

4.3.2 continue 语句

作用:在 == 循环语句 == 中,跳过本次循环中余下尚未执行的语句,继续执行下一次循环

示例:

int main() {for (int i = 0; i < 100; i++)
    {if (i % 2 == 0)
        {continue;}
        cout << i << endl;
    }
    
    system("pause");

    return 0;
}

留神:continue 并没有使整个循环终止,而 break 会跳出循环

4.3.3 goto 语句

作用:能够无条件跳转语句

语法: goto 标记;

解释:如果标记的名称存在,执行到 goto 语句时,会跳转到标记的地位

示例:

int main() {

    cout << "1" << endl;

    goto FLAG;

    cout << "2" << endl;
    cout << "3" << endl;
    cout << "4" << endl;

    FLAG:

    cout << "5" << endl;
    
    system("pause");

    return 0;
}

留神:在程序中不倡议应用 goto 语句,免得造成程序流程凌乱

5 数组

5.1 概述

所谓数组,就是一个汇合,外面寄存了雷同类型的数据元素

特点 1:数组中的每个 == 数据元素都是雷同的数据类型 ==

特点 2:数组是由 == 间断的内存 == 地位组成的

5.2 一维数组

5.2.1 一维数组定义形式

一维数组定义的三种形式:

  1. 数据类型 数组名[数组长度];
  2. 数据类型 数组名[数组长度] = {值 1,值 2 ...};
  3. 数据类型 数组名[] = { 值 1,值 2 ...};

示例

int main() {

    // 定义形式 1
    // 数据类型 数组名[元素个数];
    int score[10];

    // 利用下标赋值
    score[0] = 100;
    score[1] = 99;
    score[2] = 85;

    // 利用下标输入
    cout << score[0] << endl;
    cout << score[1] << endl;
    cout << score[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] << 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] << endl;
    }

    system("pause");

    return 0;
}

总结 1:数组名的命名标准与变量名命名标准统一,不要和变量重名

总结 2:数组中下标是从 0 开始索引

5.2.2 一维数组数组名

一维数组名称的 用处

  1. 能够统计整个数组在内存中的长度
  2. 能够获取数组在内存中的首地址

示例:

int main() {

    // 数组名用处
    //1、能够获取整个数组占用内存空间大小
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};

    cout << "整个数组所占内存空间为:" << sizeof(arr) << endl;
    cout << "每个元素所占内存空间为:" << sizeof(arr[0]) << endl;
    cout << "数组的元素个数为:" << sizeof(arr) / sizeof(arr[0]) << endl;

    //2、能够通过数组名获取到数组首地址
    cout << "数组首地址为:" << (int)arr << endl;
    cout << "数组中第一个元素地址为:" << (int)&arr[0] << endl;
    cout << "数组中第二个元素地址为:" << (int)&arr[1] << endl;

    //arr = 100; 谬误,数组名是常量,因而不能够赋值


    system("pause");

    return 0;
}

留神:数组名是常量,不能够赋值

总结 1:间接打印数组名,能够查看数组所占内存的首地址

总结 2:对数组名进行 sizeof,能够获取整个数组占内存空间的大小

练习案例 1 :五只小猪称体重

案例形容:

在一个数组中记录了五只小猪的体重,如:int arr[5] = {300,350,200,400,250};

找出并打印最重的小猪体重。

int main()
{int arr[5] = {300, 350, 200, 400, 250};
    int i = 0;
    int max = arr[0];
    int min = 0;
    
    for (i = 1; i < 5; i++)
    {if (max < arr[i])
        {max = arr[i];
        }
    }
    for (i = 1; i < 5; i++)
    {if (arr[min] > arr[i])
        {min = i;}
    }
    cout << "最重体重的是:" << max << endl;
    cout << "最轻体重的是:" << arr[min] << endl;

    system("pause");
    return 0;
}

练习案例 2:数组元素逆置

案例形容:请申明一个 5 个元素的数组,并且将元素逆置.

(如原数组元素为:1,3,2,5,4; 逆置后输入后果为:4,5,2,3,1);

int main()
{int arr[5] = {1, 2, 3, 4, 5};
    int start = 0;  // 起始下标
    int end = sizeof(arr) / sizeof(arr[0]) - 1; // 尾下标
    int temp = 0;

    cout << "逆置前:" << endl;
    for (int i = 0; i < 5; i++)
    {cout << arr[i];
        cout << " " << endl;
    }

    // 外围语句
    while (start < end)
    {temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;
        // 下标更新
        start++;
        end--;
    }

    cout << "逆置后:"<< endl;
    for (int i = 0; i < 5; i++)
    {cout << arr[i];
        cout << " " << endl;
    }

    system("pause");
    return 0;
}

5.2.3 冒泡排序

作用: 最罕用的排序算法,对数组内元素进行排序

  1. 比拟相邻的元素。如果第一个比第二个大,就替换他们两个。
  2. 对每一对相邻元素做同样的工作,执行结束后,找到第一个最大值。
  3. 反复以上的步骤,每次比拟次数 -1,直到不须要比拟

示例: 将数组 {4,2,8,0,5,7,1,3,9} 进行升序排序

// 第一种
int main() {int arr[9] = {4,2,8,0,5,7,1,3,9};

    for (int i = 0; i < 9 - 1; i++)
    {for (int j = 0; j < 9 - 1 - i; j++)
        {if (arr[j] > arr[j + 1])
            {int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }

    for (int i = 0; i < 9; i++)
    {cout << arr[i] << endl;
    }
    
    system("pause");

    return 0;
}
// 第二种
int main()
{int arr[9] = {4,2,8,0,5,7,1,3,9};
    int i = 0;
    int j = 0;

    // 冒泡求最小值
    for (i = 0; i < 9; i++)
    {for (j = i + 1; j < 9; j++)
        {if (arr[i] > arr[j])
            {int temp = arr[j];
                arr[j] = arr[i];
                arr[i] = temp;
            }
        }
    }

    for (i = 0; i<9; i++)
    {cout << arr[i] << endl;
    }
    system("pause");
    return 0;
}

5.3 二维数组

二维数组就是在一维数组上,多加一个维度。

5.3.1 二维数组定义形式

二维数组定义的四种形式:

  1. 数据类型 数组名[行数][列数];
  2. 数据类型 数组名[行数][列数] = {{数据 1,数据 2},{数据 3,数据 4} };
  3. 数据类型 数组名[行数][列数] = {数据 1,数据 2,数据 3,数据 4};
  4. 数据类型 数组名[][ 列数] = {数据 1,数据 2,数据 3,数据 4};

倡议:以上 4 种定义形式,利用 == 第二种更加直观,进步代码的可读性 ==

示例:

int main() {

    // 形式 1  
    // 数组类型 数组名 [行数][列数]
    int arr[2][3];
    arr[0][0] = 1;
    arr[0][1] = 2;
    arr[0][2] = 3;
    arr[1][0] = 4;
    arr[1][1] = 5;
    arr[1][2] = 6;

    for (int i = 0; i < 2; i++)
    {for (int j = 0; j < 3; j++)
        {cout << arr[i][j] << " ";
        }
        cout << endl;
    }

    // 形式 2 
    // 数据类型 数组名[行数][列数] = {{数据 1,数据 2},{数据 3,数据 4} };
    int arr2[2][3] =
    {{1,2,3},
        {4,5,6}
    };

    // 形式 3
    // 数据类型 数组名[行数][列数] = {数据 1,数据 2 , 数据 3,数据 4};
    int arr3[2][3] = {1,2,3,4,5,6}; 

    // 形式 4 
    // 数据类型 数组名[][列数] = {数据 1,数据 2 , 数据 3,数据 4};
    int arr4[][3] = {1,2,3,4,5,6};
    
    system("pause");

    return 0;
}

总结:在定义二维数组时,如果初始化了数据,能够省略行数

5.3.2 二维数组数组名

  • 查看二维数组所占内存空间
  • 获取二维数组首地址

示例:

int main() {

    // 二维数组数组名
    int arr[2][3] =
    {{1,2,3},
        {4,5,6}
    };

    cout << "二维数组大小:" << sizeof(arr) << endl;
    cout << "二维数组一行大小:" << sizeof(arr[0]) << endl;
    cout << "二维数组元素大小:" << sizeof(arr[0][0]) << endl;

    cout << "二维数组行数:" << sizeof(arr) / sizeof(arr[0]) << endl;
    cout << "二维数组列数:" << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;

    // 地址
    cout << "二维数组首地址:" << arr << endl;
    cout << "二维数组第一行地址:" << arr[0] << endl;
    cout << "二维数组第二行地址:" << arr[1] << endl;

    cout << "二维数组第一个元素地址:" << &arr[0][0] << endl;
    cout << "二维数组第二个元素地址:" << &arr[0][1] << endl;

    system("pause");

    return 0;
}

总结 1:二维数组名就是这个数组的首地址

总结 2:对二维数组名进行 sizeof 时,能够获取整个二维数组占用的内存空间大小

5.3.3 二维数组利用案例

考试成绩统计:

案例形容:有三名同学(张三,李四,王五),在一次考试中的问题别离如下表,请别离输入三名同学的总成绩

语文 数学 英语
张三 100 100 100
李四 90 50 100
王五 60 70 80

参考答案:

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;
    }

    system("pause");

    return 0;
}

6 函数

6.1 概述

作用:将一段常常应用的代码封装起来,缩小反复代码

一个较大的程序,个别分为若干个程序块,每个模块实现特定的性能。

6.2 函数的定义

函数的定义个别次要有 5 个步骤:

1、返回值类型

2、函数名

3、参数表列

4、函数体语句

5、return 表达式

语法:

返回值类型 函数名(参数列表){

       函数体语句

       return 表达式

}
  • 返回值类型:一个函数能够返回一个值。在函数定义中
  • 函数名:给函数起个名称
  • 参数列表:应用该函数时,传入的数据
  • 函数体语句:花括号内的代码,函数内须要执行的语句
  • return 表达式:和返回值类型挂钩,函数执行完后,返回相应的数据

示例:定义一个加法函数,实现两个数相加

// 函数定义
int add(int num1, int num2)
{
    int sum = num1 + num2;
    return sum;
}

6.3 函数的调用

性能:应用定义好的函数

语法: 函数名(参数)

示例:

// 函数定义
int add(int num1, int num2) // 定义中的 num1,num2 称为形式参数,简称形参
{
    int sum = num1 + num2;
    return sum;
}

int main() {

    int a = 10;
    int b = 10;
    // 调用 add 函数
    int sum = add(a, b);// 调用时的 a,b 称为理论参数,简称实参
    cout << "sum =" << sum << endl;

    a = 100;
    b = 100;

    sum = add(a, b);
    cout << "sum =" << sum << endl;

    system("pause");

    return 0;
}

总结:函数定义里小括号内称为形参,函数调用时传入的参数称为实参

6.4 值传递

  • 所谓值传递,就是函数调用时实参将数值传入给形参
  • 值传递时,== 如果形参产生,并不会影响实参 ==

示例:

void swap(int num1, int num2)
{
    cout << "替换前:" << endl;
    cout << "num1 =" << num1 << endl;
    cout << "num2 =" << num2 << endl;

    int temp = num1;
    num1 = num2;
    num2 = temp;

    cout << "替换后:" << endl;
    cout << "num1 =" << num1 << endl;
    cout << "num2 =" << num2 << endl;

    //return ; 当函数申明时候,不须要返回值,能够不写 return
}

int main() {

    int a = 10;
    int b = 20;

    swap(a, b);

    cout << "main 中的 a =" << a << endl;
    cout << "main 中的 b =" << b << endl;

    system("pause");

    return 0;
}

总结:值传递时,形参是润饰不了实参的

6.5 函数的常见款式

常见的函数款式有 4 种

  1. 无参无返
  2. 有参无返
  3. 无参有返
  4. 有参有返

示例:

// 函数常见款式
//1、无参无返
void test01()
{
    //void a = 10; // 无类型不能够创立变量, 起因无奈分配内存
    cout << "this is test01" << endl;
    //test01(); 函数调用}

//2、有参无返
void test02(int a)
{
    cout << "this is test02" << endl;
    cout << "a =" << a << endl;
}

//3、无参有返
int test03()
{
    cout << "this is test03" << endl;
    return 10;
}

//4、有参有返
int test04(int a, int b)
{
    cout << "this is test04" << endl;
    int sum = a + b;
    return sum;
}

6.6 函数的申明

作用: 通知编译器函数名称及如何调用函数。函数的理论主体能够独自定义。

  • 函数的 申明能够屡次 ,然而函数的 定义只能有一次

示例:

// 申明能够屡次,定义只能一次
// 申明
int max(int a, int b);
int max(int a, int b);
// 定义
int max(int a, int b)
{return a > b ? a : b;}

int main() {

    int a = 100;
    int b = 200;

    cout << max(a, b) << endl;

    system("pause");

    return 0;
}

6.7 函数的分文件编写

作用:让代码构造更加清晰

函数分文件编写个别有 4 个步骤

  1. 创立后缀名为.h 的头文件
  2. 创立后缀名为.cpp 的源文件
  3. 在头文件中写函数的申明
  4. 在源文件中写函数的定义

示例:

//swap.h 文件
#include<iostream>
using namespace std;

// 实现两个数字替换的函数申明
void swap(int a, int b);
//swap.cpp 文件
#include "swap.h"

void swap(int a, int b)
{
    int temp = a;
    a = b;
    b = temp;

    cout << "a =" << a << endl;
    cout << "b =" << b << endl;
}
//main 函数文件
#include "swap.h"
int main() {

    int a = 100;
    int b = 200;
    swap(a, b);

    system("pause");

    return 0;
}

7 指针

7.1 指针的基本概念

指针的作用: 能够通过指针间接拜访内存

  • 内存编号是从 0 开始记录的,个别用十六进制数字示意
  • 能够利用指针变量保留地址

7.2 指针变量的定义和应用

指针变量定义语法:数据类型 * 变量名;

示例:

int main() {

    //1、指针的定义
    int a = 10; // 定义整型变量 a
    
    // 指针定义语法:数据类型 * 变量名 ;
    int * p;

    // 指针变量赋值
    p = &a; // 指针指向变量 a 的地址
    cout << &a << endl; // 打印数据 a 的地址
    cout << p << endl;  // 打印指针变量 p

    //2、指针的应用
    // 通过 * 操作指针变量指向的内存
    cout << "*p =" << *p << endl;

    system("pause");

    return 0;
}

指针变量和一般变量的区别

  • 一般变量寄存的是数据, 指针变量寄存的是地址
  • 指针变量能够通过 ” * “ 操作符,操作指针变量指向的内存空间,这个过程称为解援用

总结 1:咱们能够通过 & 符号 获取变量的地址

总结 2:利用指针能够记录地址

总结 3:对指针变量解援用,能够操作指针指向的内存中的数据

7.3 指针所占内存空间

发问:指针也是种数据类型,那么这种数据类型占用多少内存空间?

示例:

int main() {

    int a = 10;

    int * p;
    p = &a; // 指针指向数据 a 的地址

    cout << *p << endl; //* 解援用
    cout << sizeof(p) << endl;
    cout << sizeof(char *) << endl;
    cout << sizeof(float *) << endl;
    cout << sizeof(double *) << endl;

    system("pause");

    return 0;
}

总结:

所有指针类型在 32 位操作系统下是 4 个字节

所有指针类型在 64 位操作系统下是 8 个字节

7.4 空指针和野指针

空指针:指针变量指向内存中编号为 0 的空间

用处:初始化指针变量

留神:空指针指向的内存是不能够拜访的

示例 1:空指针

int main() {

    // 指针变量 p 指向内存地址编号为 0 的空间
    int * p = NULL;

    // 拜访空指针报错 
    // 内存编号 0 ~255 为零碎占用内存,不容许用户拜访
    cout << *p << endl;

    system("pause");

    return 0;
}

野指针:指针变量指向非法的内存空间

示例 2:野指针

int main() {

    // 指针变量 p 指向内存地址编号为 0x1100 的空间
    int * p = (int *)0x1100;

    // 拜访野指针报错 
    cout << *p << endl;

    system("pause");

    return 0;
}

总结:空指针和野指针都不是咱们申请的空间,因而不要拜访。

7.5 const 润饰指针

const 润饰指针有三种状况

  1. const 润饰指针 — 常量指针
  2. const 润饰常量 — 指针常量
  3. const 即润饰指针,又润饰常量

示例:

int main() {

    int a = 10;
    int b = 10;

    //const 润饰的是指针,指针指向能够改,指针指向的值不能够更改
    const int * p1 = &a; 
    p1 = &b; // 正确
    //*p1 = 100;  报错
    

    //const 润饰的是常量,指针指向不能够改,指针指向的值能够更改
    int * const p2 = &a;
    //p2 = &b; // 谬误
    *p2 = 100; // 正确

    //const 既润饰指针又润饰常量
    const int * const p3 = &a;
    //p3 = &b; // 谬误
    //*p3 = 100; // 谬误

    system("pause");

    return 0;
}

技巧:

  1. const : 翻译成中文就是常量,* 就是指针
  2. 看 const 右侧紧跟着的是指针还是常量, 是指针就是常量指针,是常量就是指针常量
  3. 常量指针:指针不能够更改
    指针常量:常量不能够更改
    const 既润饰指针又润饰常量: 指针指向的值和指针指向都不能够更改

7.6 指针和数组

作用:利用指针拜访数组中元素

示例:

int main()
{int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    // 指向数组的指针
    int * q = arr; // 等价于 int * q = &arr[0]
    
    cout << "第一个元素为" << arr[0] << endl;
    cout <<"利用指针拜访第一个元素为" << *q << endl;

    // 利用指针遍历数组
    cout << "利用指针拜访数组中的所有元素为:" << endl;
    for (int i = 0; i < 10; i++)
    {cout << (*q)++ << endl; //*(q)++ 等价于 *q++
    }

    system("pause");

    return 0;
}

7.7 指针和函数

作用:利用指针作函数参数,能够批改实参的值

示例:

// 值传递
void swap1(int a ,int b)
{
    int temp = a;
    a = b; 
    b = temp;
}
// 地址传递
void swap2(int * p1, int *p2)
{
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}

int main() {

    int a = 10;
    int b = 20;
    swap1(a, b); // 值传递不会扭转实参

    swap2(&a, &b); // 地址传递会扭转实参

    cout << "a =" << a << endl;

    cout << "b =" << b << endl;

    system("pause");

    return 0;
}

总结:

​ 如果不想批改实参,就用值传递,如果想批改实参,就用地址传递

  1. 值传递:

    在 swap2 函数执行实现后会开释函数中变量的内存空间,
    main 函数和 swap2 函数中不是同一变量,因而值传递不会扭转主函数中的值

  2. 地址传递:
    在 swap1 函数执行实现后会开释函数中变量的内存空间,然而在解援用的时候就曾经更改 main 函数中 a、b 的值

7.8 指针、数组、函数

案例形容:封装一个函数,利用冒泡排序,实现对整型数组的升序排序

例如数组:int arr[10] = {4,3,6,9,1,2,10,8,7,5};

示例:

// 冒泡排序函数
void bubbleSort(int * arr, int len)  //int * arr 也能够写为 int arr[]
{for (int i = 0; i < len - 1; i++)
    {for (int j = 0; j < len - 1 - i; j++)
        {if (arr[j] > arr[j + 1])
            {int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

// 打印数组函数
void printArray(int arr[], int len)
{for (int i = 0; i < len; i++)
    {cout << arr[i] << endl;
    }
}

int main() {int arr[10] = {4,3,6,9,1,2,10,8,7,5};
    int len = sizeof(arr) / sizeof(int);

    bubbleSort(arr, len);

    printArray(arr, len);

    system("pause");

    return 0;
}

总结:当数组名传入到函数作为参数时,被进化为指向首元素的指针

8 构造体

8.1 构造体基本概念

构造体属于用户 == 自定义的数据类型 ==,容许用户存储不同的数据类型

8.2 构造体定义和应用

语法:struct 构造体名 {构造体成员列表};

通过构造体创立变量的形式有三种:

  • struct 构造体名 变量名
  • struct 构造体名 变量名 = {成员 1 值,成员 2 值 …}
  • 定义构造体时顺便创立变量

示例:

// 构造体定义
struct student
{
    // 成员列表
    string name;  // 姓名
    int age;      // 年龄
    int score;    // 分数
}stu3; // 构造体变量创立形式 3 


int main() {

    // 构造体变量创立形式 1
    struct student stu1; //struct 关键字能够省略

    stu1.name = "张三";
    stu1.age = 18;
    stu1.score = 100;
    
    cout << "姓名:" << stu1.name << "年龄:" << stu1.age  << "分数:" << stu1.score << endl;

    // 构造体变量创立形式 2
    struct student stu2 = {"李四",19,60};

    cout << "姓名:" << stu2.name << "年龄:" << stu2.age  << "分数:" << stu2.score << endl;


    stu3.name = "王五";
    stu3.age = 18;
    stu3.score = 80;
    

    cout << "姓名:" << stu3.name << "年龄:" << stu3.age  << "分数:" << stu3.score << endl;

    system("pause");

    return 0;
}

总结 1:定义构造体时的关键字是 struct,不可省略

总结 2:创立构造体变量时,关键字 struct 能够省略

总结 3:构造体变量利用操作符 ”.” 拜访成员

8.3 构造体数组

作用:将自定义的构造体放入到数组中不便保护

语法: struct 构造体名 数组名[元素个数] = {{} , {} , ... {} }

示例:

// 构造体定义
struct student
{
    // 成员列表
    string name;  // 姓名
    int age;      // 年龄
    int score;    // 分数
}

int main() {
    
    // 构造体数组
    struct student arr[3]=
    {{"张三",18,80},
        {"李四",19,60},
        {"王五",20,70}
    };

    for (int i = 0; i < 3; i++)
    {cout << "姓名:" << arr[i].name << "年龄:" << arr[i].age << "分数:" << arr[i].score << endl;
    }

    system("pause");

    return 0;
}

8.4 构造体指针

作用:通过指针拜访构造体中的成员

  • 利用操作符 -> 能够通过构造体指针拜访构造体属性

示例:

// 构造体定义
struct student
{
    // 成员列表
    string name;  // 姓名
    int age;      // 年龄
    int score;    // 分数
};


int main() {struct student stu = { "张三",18,100,};
    
    struct student * p = &stu;
    
    p->score = 80; // 指针通过 -> 操作符能够拜访成员

    cout << "姓名:" << p->name << "年龄:" << p->age << "分数:" << p->score << endl;
    
    system("pause");

    return 0;
}

总结:构造体指针能够通过 -> 操作符 来拜访构造体中的成员

8.5 构造体嵌套构造体

作用: 构造体中的成员能够是另一个构造体

例如:每个老师辅导一个学员,一个老师的构造体中,记录一个学生的构造体

示例:

// 学生构造体定义
struct student
{
    // 成员列表
    string name;  // 姓名
    int age;      // 年龄
    int score;    // 分数
};

// 老师构造体定义
struct teacher
{
    // 成员列表
    int id; // 职工编号
    string name;  // 老师姓名
    int age;   // 老师年龄
    struct student stu; // 子结构体 学生
};


int main() {

    struct teacher t1;
    t1.id = 10000;
    t1.name = "老王";
    t1.age = 40;

    t1.stu.name = "张三";
    t1.stu.age = 18;
    t1.stu.score = 100;

    cout << "老师 职工编号:" << t1.id << "姓名:" << t1.name << "年龄:" << t1.age << endl;
    
    cout << "辅导学员 姓名:" << t1.stu.name << "年龄:" << t1.stu.age << "考试分数:" << t1.stu.score << endl;

    system("pause");

    return 0;
}

总结:在构造体中能够定义另一个构造体作为成员,用来解决理论问题

8.6 构造体做函数参数

作用:将构造体作为参数向函数中传递

传递形式有两种:

  • 值传递
  • 地址传递

示例:

// 学生构造体定义
struct student
{
    // 成员列表
    string name;  // 姓名
    int age;      // 年龄
    int score;    // 分数
};

// 值传递
void printStudent(student stu)
{
    stu.age = 28;
    cout << "子函数中 姓名:" << stu.name << "年龄:" << stu.age  << "分数:" << stu.score << endl;
}

// 地址传递
void printStudent2(student *stu)
{
    stu->age = 28;
    cout << "子函数中 姓名:" << stu->name << "年龄:" << stu->age  << "分数:" << stu->score << endl;
}

int main() {student stu = { "张三",18,100};
    // 值传递
    printStudent(stu);
    cout << "主函数中 姓名:" << stu.name << "年龄:" << stu.age << "分数:" << stu.score << endl;

    cout << endl;

    // 地址传递
    printStudent2(&stu);
    cout << "主函数中 姓名:" << stu.name << "年龄:" << stu.age  << "分数:" << stu.score << endl;

    system("pause");

    return 0;
}

总结:如果不想批改主函数中的数据,用值传递,反之用地址传递

8.7 构造体中 const 应用场景

作用:用 const 来避免误操作

示例:

// 学生构造体定义
struct student
{
    // 成员列表
    string name;  // 姓名
    int age;      // 年龄
    int score;    // 分数
};

// const 应用场景
void printStudent(const student *stu) // 加 const 避免函数体中的误操作
{
    //stu->age = 100; // 操作失败,因为加了 const 润饰
    cout << "姓名:" << stu->name << "年龄:" << stu->age << "分数:" << stu->score << endl;

}

int main() {student stu = { "张三",18,100};

    printStudent(&stu);

    system("pause");

    return 0;
}

8.8 构造体案例

8.8.1 案例 1

案例形容:

学校正在做毕设我的项目,每名老师率领 5 个学生,总共有 3 名老师,需要如下

设计学生和老师的构造体,其中在老师的构造体中,有老师姓名和一个寄存 5 名学生的数组作为成员

学生的成员有姓名、考试分数,创立数组寄存 3 名老师,通过函数给每个老师及所带的学生赋值

最终打印出老师数据以及老师所带的学生数据。

示例:

#include <iostream>
using namespace std;
#include <string>
#include <ctime> // 随机数种子头文件,随机数随零碎工夫变动
/*
案例形容:学校正在做毕设我的项目,每名老师率领 5 个学生,总共有 3 名老师,需要如下
设计学生和老师的构造体,其中在老师的构造体中,有老师姓名和一个寄存 5 名学生的数组作为成员
学生的成员有姓名、考试分数,创立数组寄存 3 名老师,通过函数给每个老师及所带的学生赋值
最终打印出老师数据以及老师所带的学生数据。*/
struct Student
{
    string Sname;
    int score;
};

struct Teacher
{
    string Tname;
    struct Student Sarr[5];
};

void allocteSpace(struct Teacher Tarr[], int len); // 创立给老师和学生赋值的函数,allocteSpace:调配的的空间
void printfTeacher(struct Teacher Tarr[], int len);

int main7()
{
    //4. 增加随机数种子
    srand((unsigned int)time(NULL));

    //1. 创立三名老师的数组
    struct Teacher Tarr[3];

    //2. 通过函数给三名老师的信息赋值, 并给老师所率领的学生赋值
    int len = sizeof(Tarr) / sizeof(Tarr[0]); // 易于批改
    allocteSpace(Tarr, len);

    //3. 打印所有老师及所带学生的信息
    printfTeacher(Tarr, len);

    system("pause");

    return 0;
}

void allocteSpace(struct Teacher Tarr[], int len)
{
    string nameSeed = "ABCDE";

    for (int i = 0; i < len; i++)
    {Tarr[i].Tname = "Teacher_";
        Tarr[i].Tname += nameSeed[i];

        for (int j = 0; j < 5; j++)
        {Tarr[i].Sarr[j].Sname = "Student_";
            Tarr[i].Sarr[j].Sname += nameSeed[j];

            int Rand = rand() % 61 + 40; // 随机生成 40~100 之间的数字
            Tarr[i].Sarr[j].score =Rand;
        }
    }

    return;
}

void printfTeacher(struct Teacher Tarr[], int len)
{for (int i = 0; i < len; i++)
    {cout << "老师:" << Tarr[i].Tname << endl;
        for (int j = 0; j < 5; j++)
        {cout <<"\t 学生:" << Tarr[i].Sarr[j].Sname 
                    << "分数:" << Tarr[i].Sarr[j].score << endl;
        }
    }

    return;
}

8.8.2 案例 2

案例形容:

设计一个英雄的构造体,包含成员姓名,年龄,性别; 创立构造体数组,数组中寄存 5 名英雄。

通过冒泡排序的算法,将数组中的英雄依照年龄进行升序排序,最终打印排序后的后果。

五名英雄信息如下:

        {"刘备",23,"男"},
        {"关羽",22,"男"},
        {"张飞",20,"男"},
        {"赵云",21,"男"},
        {"貂蝉",19,"女"},

示例:

// 英雄构造体
struct hero
{
    string name;
    int age;
    string sex;
};
// 冒泡排序
void bubbleSort(hero arr[] , int len)
{for (int i = 0; i < len - 1; i++)
    {for (int j = 0; j < len - 1 - i; j++)
        {if (arr[j].age > arr[j + 1].age)
            {hero temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}
// 打印数组
void printHeros(hero arr[], int len)
{for (int i = 0; i < len; i++)
    {cout << "姓名:" << arr[i].name << "性别:" << arr[i].sex << "年龄:" << arr[i].age << endl;
    }
}

int main() {struct hero arr[5] =
    {{"刘备",23,"男"},
        {"关羽",22,"男"},
        {"张飞",20,"男"},
        {"赵云",21,"男"},
        {"貂蝉",19,"女"},
    };

    int len = sizeof(arr) / sizeof(hero); // 获取数组元素个数

    bubbleSort(arr, len); // 排序

    printHeros(arr, len); // 打印

    system("pause");

    return 0;
}

正文完
 0