黑马C++笔记----基础篇

已于 2023-12-14 21:17:49 修改
阅读量778 收藏 19
点赞数 24
分类专栏： 全科笔记 文章标签： c++ 笔记 开发语言
于 2023-12-14 21:17:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LX200384/article/details/135003779
版权

在黑马笔记主体的基础上,会加上我自己学习的心得,和相关的概念的注释,并参考<<C++PRIMER>>进行扩充.后续还会发布笔记,以黑马的笔记为主体,还会有C++核心编程,C++提高编程.

课程安排

  • 明确C++课程学习阶段以及课程内容

阶段内容目标案例
第一阶段C++基础语法入门对C++有初步了解，能够有基础编程能力通讯录管理系统
第二阶段C++核心编程介绍C++面向对象编程，为大型项目做铺垫职工管理系统
第三阶段C++提高编程介绍C++泛型编程思想，以及STL的基本应用演讲比赛系统

  • 综合大案例：机房预约系统

    • 包括之前内容

STL，英文全称 standard template library，中文可译为标准模板库或者泛型库，其包含有大量的模板类和模板函数，是 C++ 提供的一个基础模板的集合，用于完成诸如输入/输出、数学计算等功能。

STL 最初由惠普实验室开发，于 1998 年被定为国际标准，正式成为 C++ 程序库的重要组成部分。值得一提的是，如今 STL 已完全被内置到支持 C++ 的编译器中，无需额外安装，这可能也是 STL 被广泛使用的原因之一。

STL 就位于各个 C++ 的头文件中，即它并非以二进制代码的形式提供，而是以源代码的形式提供。

从根本上说，STL 是一些容器、算法和其他一些组件的集合，所有容器和算法都是总结了几十年来算法和数据结构的研究成果，汇集了许多计算机专家学者经验的基础上实现的，因此可以说，STL 基本上达到了各种存储方法和相关算法的高度优化。

注意，这里提到的容器，本质上就是封装有数据结构的模板类，例如 list、vector、set、map 等，有关这些容器的具体用法，后续章节会做详细介绍。

C++基础入门

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;
 ​
 int main() {
 ​
     cout << "Hello world" << endl;
 ​
     system("pause");
 ​
     return 0;
 }
1.1.4 运行程序

1.2 注释

作用：在代码中加一些说明和解释，方便自己或其他程序员程序员阅读代码

两种格式

  1. 单行注释：// 描述信息

    • 通常放在一行代码的上方，或者一条语句的末尾，对该行代码说明

  2. 多行注释： /* 描述信息 */

    • 通常放在一段代码的上方，对该段代码做整体说明

提示：编译器在编译代码时，会忽略注释的内容

1.3 变量

作用：给一段指定的内存空间起名，方便操作这段内存

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

示例：

注意：C++在创建变量时，必须给变量一个初始值，否则会报错

1.4 常量

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

C++定义常量两种方式

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

    • 通常在文件上方定义，表示一个常量

  1. const修饰的变量 const 数据类型 常量名 = 常量值

    • 通常在变量定义前加关键字const，修饰该变量为常量，不可修改

示例：

 //1、宏常量
 #define day 7
 ​
 int main() {
 ​
     cout << "一周里总共有 " << day << " 天" << endl;
     //day = 8;  //报错，宏常量不可以修改
 ​
     //2、const修饰变量
     const int month = 12;
     cout << "一年里总共有 " << month << " 个月份" << endl;
     //month = 24; //报错，常量是不可以修改的
     
     
     system("pause");
 ​
     return 0;
 }

1.5 关键字

作用：关键字是C++中预先保留的单词（标识符）

  • 在定义变量或者常量时候，不要用关键字

C++关键字如下：

asmdoifreturntypedef
autodoubleinlineshorttypeid
booldynamic_castintsignedtypename
breakelselongsizeofunion
caseenummutablestaticunsigned
catchexplicitnamespacestatic_castusing
charexportnewstructvirtual
classexternoperatorswitchvoid
constfalseprivatetemplatevolatile
const_castfloatprotectedthiswchar_t
continueforpublicthrowwhile
defaultfriendregistertrue
deletegotoreinterpret_casttry

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

1.6 标识符命名规则

作用：C++规定给标识符（变量、常量）命名时，有一套自己的规则

  • 标识符不能是关键字

  • 标识符只能由字母、数字、下划线组成

  • 第一个字符必须为字母或下划线

  • 标识符中字母区分大小写

建议：给标识符命名时，争取做到见名知意的效果，方便自己和他人的阅读

 #include<studio.h>
 int main()
 {
     printf("hello world");
     return 0;
 }

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

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

数据类型占用空间有效数字范围
float4字节7位有效数字
double8字节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值字符
0NUT32(space)64@96、
1SOH33!65A97a
2STX34"66B98b
3ETX35#67C99c
4EOT36$68D100d
5ENQ37%69E101e
6ACK38&70F102f
7BEL39,71G103g
8BS40(72H104h
9HT41)73I105i
10LF42*74J106j
11VT43+75K107k
12FF44,76L108l
13CR45-77M109m
14SO46.78N110n
15SI47/79O111o
16DLE48080P112p
17DCI49181Q113q
18DC250282R114r
19DC351383S115s
20DC452484T116t
21NAK53585U117u
22SYN54686V118v
23TB55787W119w
24CAN56888X120x
25EM57989Y121y
26SUB58:90Z122z
27ESC59;91[123{
28FS60<92/124|
29GS61=93]125}
30RS62>94^126`
31US63?95_127DEL

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数字0000
\ddd8进制转义字符，d范围0~73位8进制
\xhh16进制转义字符，h范围09，af，A~F3位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>

 #include<iostream>
 using namespace std;
 int main() {
     char str1[] = "hello world";
     cout << str1 << endl;
     int str2[] = { 23,23,1234,345,4576 };
     for (int i = 0; i < 5; i++)
     {
         cout << str2[i] << endl;
     }
     system("pause");
     return 0;
 字符串和数组辨析
 数组输出必须是每个输出,不然打印的是地址

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

以下是使用bool变量的示例：


#include <iostream>

int main() {
    bool isTrue = true;
    bool isFalse = false;

    if (isTrue) {
        std::cout << "The value of isTrue is true" << std::endl;
    } else {
        std::cout << "The value of isTrue is false" << std::endl;
    }

    if (isFalse) {
        std::cout << "The value of isFalse is true" << std::endl;
    } else {
        std::cout << "The value of isFalse is false" << std::endl;
    }

    return 0;
}

在上面的示例中，我们定义了两个bool变量isTrue和isFalse，并分别初始化为true和false。然后我们使用if语句来检查这些变量的值，并打印相应的消息。

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 算术运算符

作用：用于处理四则运算

算术运算符包括以下符号：

运算符术语示例结果
+正号+33
-负号-3-3
+加10 + 515
-减10 - 55
*乘10 * 550
/除10 / 52
%取模(取余)10 % 31
++前置递增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;
 }
 ​

总结：只有整型变量可以进行取模运算

在C++中，小数不能直接进行取模运算，因为取模运算是针对整数的。取模运算是指计算一个数除以另一个数后的余数。对于整数，取模运算是可行的，例如：

 int a = 10;
 int b = 3;
 int result = a % b; // result的值为1，即10除以3的余数

然而，对于小数，取模运算没有定义，因为小数没有余数的概念。如果你想对小数进行取模运算，你可以先将小数转换为整数，然后再进行取模运算。例如：

 double a = 10.5;
 int b = 3;
 int result = static_cast<int>(a) % b; // result的值为1，即10除以3的余数

在这个例子中，我们使用static_cast<int>(a)将小数a转换为整数，然后再进行取模运算。请注意，这种转换会将小数的小数部分截断，只保留整数部分。

示例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 == 30
!=不等于4 != 31
<小于4 < 30
>大于4 > 31
<=小于等于4 <= 30
>=大于等于4 >= 11

示例：

 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(条件){ 条件满足执行的语句 }

  2. 示例：

     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>

int main() {
    int weightA, weightB, weightC;

    std::cout << "请输入小猪A的体重：";
    std::cin >> weightA;

    std::cout << "请输入小猪B的体重：";
    std::cin >> weightB;

    std::cout << "请输入小猪C的体重：";
    std::cin >> weightC;

    if (weightA > weightB && weightA > weightC) {
        std::cout << "小猪A最重" << std::endl;
    } else if (weightB > weightA && weightB > weightC) {
        std::cout << "小猪B最重" << std::endl;
    } else if (weightC > weightA && weightC > weightB) {
        std::cout << "小猪C最重" << std::endl;
    } else {
        std::cout << "有两只或三只小猪体重相同" << std::endl;
    }

    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不可以判断区间

在C++中，switch语句中的break语句的作用是用来退出switch语句的，防止程序继续执行下一个case中的代码。如果没有break语句，程序会继续执行下一个case中的代码，直到遇到break或者switch语句结束。

以下是几个使用break语句的switch语句的例子：

1. 处理菜单选择：

#include <iostream>

int main() {
    int choice;
    std::cout << "请选择操作：1. 新建文件 2. 打开文件 3. 保存文件 4. 退出" << std::endl;
    std::cin >> choice;

    switch (choice) {
        case 1:
            std::cout << "新建文件" << std::endl;
            break;
        case 2:
            std::cout << "打开文件" << std::endl;
            break;
        case 3:
            std::cout << "保存文件" << std::endl;
            break;
        case 4:
            std::cout << "退出" << std::endl;
            break;
        default:
            std::cout << "无效的选择" << std::endl;
            break;
    }

    return 0;
}
 

2. 处理枚举类型：

#include <iostream>

enum Day { Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday };

int main() {
    Day today = Wednesday;

    switch (today) {
        case Monday:
            std::cout << "今天是星期一" << std::endl;
            break;
        case Tuesday:
            std::cout << "今天是星期二" << std::endl;
            break;
        case Wednesday:
            std::cout << "今天是星期三" << std::endl;
            break;
        // ... 其他case
        default:
            std::cout << "今天不是工作日" << std::endl;
            break;
    }

    return 0;
}
```

在这两个例子中，break语句用于退出switch语句，防止程序继续执行下一个case中的代码。

假如2和3中间的break删去,输入数字1,执行的结果是什么?

如果在上述的C++代码中删除了case 1: 和 case 2: 的break语句，那么当输入数字1时，程序会继续执行下一个case中的代码，直到遇到break或者switch语句结束。

具体来说，假设输入数字1，程序会执行"新建文件"的打印语句，然后继续执行"打开文件"的打印语句，直到遇到break或者switch语句结束。因此，输出结果会是"新建文件"和"打开文件"都会被打印出来。

这也说明了使用break语句的重要性，它可以确保在找到匹配的case后立即退出switch语句，避免继续执行其他case中的代码。

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之间的数字，玩家进行猜测，如果猜错，提示玩家数字过大或过小，如果猜对恭喜玩家胜利，并且退出游戏。

以下是用C++解决猜数字游戏的代码：
#include <iostream>
#include <cstdlib> // 包含rand和srand函数
#include <ctime> // 包含time函数

int main() {
    srand(time(nullptr)); // 设置随机数种子为当前时间

    int secretNum = rand() % 100 + 1; // 生成1到100之间的随机数
    int guess;

    std::cout << "欢迎来到猜数字游戏！" << std::endl;

    while (true) {
        std::cout << "请输入你猜测的数字（1-100）：" << std::endl;
        std::cin >> guess;

        if (guess == secretNum) {
            std::cout << "恭喜你猜对了！" << std::endl;
            break; // 猜对了，退出游戏
        } else if (guess < secretNum) {
            std::cout << "你猜的数字太小了，请再试一次。" << std::endl;
        } else {
            std::cout << "你猜的数字太大了，请再试一次。" << std::endl;
        }
    }

    std::cout << "游戏结束。" << std::endl;

    return 0;
}
```

这个程序中使用了一个while循环，在每次循环中让玩家输入猜测的数字，并根据猜测的结果给出相应的提示。如果猜对了，就打印出恭喜信息并退出循环，否则继续循环直到猜对为止。

注意，在程序开始时，需要使用srand函数设置随机数种子为当前时间，以确保每次运行程序时生成的随机数不同。同时，使用rand函数生成1到100之间的随机数。

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() {
 ​
     //外层循环执行1次，内层循环执行1轮
     for (int i = 0; i < 10; i++)
     {
         for (int j = 0; j < 10; j++)
         {
             cout << "*" << " ";
         }
         cout << endl;
     }
 ​
     system("pause");
 ​
     return 0;
 }

练习案例：乘法口诀表

案例描述：利用嵌套循环，实现九九乘法表

以下是用C++实现九九乘法表的代码：
#include <iostream>

int main() {
    for (int i = 1; i <= 9; i++) {
        for (int j = 1; j <= i; j++) {
            std::cout << j << " * " << i << " = " << (i * j);
            if (i * j < 10) {
                std::cout << "   "; // 为了对齐
            } else {
                std::cout << "  "; // 为了对齐
            }
        }
        std::cout << std::endl;
    }

    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语句，以免造成程序流程混乱

 //乘法口诀
 ​
 #include<iostream>
 using namespace std;
 int main()
 {
     
     //打印行数
     
     system("pause");
     return 0;
 }
 ​

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

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

#include <iostream>

int main() {
    int arr[5] = {300, 350, 200, 400, 250};
    int maxWeight = arr[0];

    for (int i = 1; i < 5; i++) {
        if (arr[i] > maxWeight) {
            maxWeight = arr[i];
        }
    }

    std::cout << "最重的小猪体重是：" << maxWeight << " 公斤" << std::endl;

    return 0;
}
 

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

案例描述：请声明一个5个元素的数组，并且将元素逆置.

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

#include <iostream>

int main() {
    int arr[5] = {1, 3, 2, 5, 4};

    // 逆置数组
    for (int i = 0; i < 5 / 2; i++) {
        int temp = arr[i];
        arr[i] = arr[4 - i];
        arr[4 - i] = temp;
    }

    // 输出逆置后的数组
    std::cout << "逆置后的数组元素为：";
    for (int i = 0; i < 5; i++) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

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

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 二维数组应用案例

考试成绩统计：

案例描述：有三名同学（张三，李四，王五），在一次考试中的成绩分别如下表，请分别输出三名同学的总成绩

语文数学英语
张三100100100
李四9050100
王五607080

参考答案：

 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 函数

2023/11/25

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

在C++中，函数的返回类型如果是非void类型，必须使用return语句来返回函数的结果。如果在函数中没有写return语句，或者return语句没有返回值，编译器会发出警告或错误。

在你提供的函数定义中，返回类型是int，因此必须使用return语句来返回结果。如果不写return语句或者return语句没有返回值，编译器会发出警告或错误。

以下是修改后的函数定义示例：

 int add(int num1, int num2)
 {
     int sum = num1 + num2;
     return sum;
 }

请注意，如果你希望在函数执行完毕后不返回任何值，可以将函数的返回类型设置为void，这样就不需要使用return语句。

以下是返回类型设置为void的函数定义示例：

 void printHello()
 {
     cout << "Hello, World!" << endl;
     // 不需要返回值
 }

请注意，在调用返回类型为void的函数时，也不需要接收返回值。例如：

 printHello(); // 不需要接收返回值

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

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

在C++中，实参（actual argument）是指在函数调用时传递给函数的具体数值或变量。实参可以是常量、变量、表达式或函数的返回值。实参的值会被传递给函数的形参。

形参（formal parameter）是指函数定义中声明的变量，用于接收函数调用时传递的实参。形参在函数定义中起到占位的作用，用来表示函数在执行时所需的参数。

在函数调用时，实参的值会被复制到对应的形参中，函数在执行时会使用形参的值进行计算或处理。通过使用实参和形参的组合，可以将数据从调用函数传递到被调用函数，并在被调用函数中进行处理。

以下是一个示例，展示了函数调用时的实参和函数定义中的形参：

 // 函数定义
 void printSum(int a, int b)
 {
  int sum = a + b;
  cout << "Sum: " << sum << endl;
 }
 ​
 int main()
 {
  int num1 = 5;
  int num2 = 3;
 ​
  // 函数调用，传递实参给形参
  printSum(num1, num2);
 ​
  return 0;
 }

在上述示例中，printSum函数的形参是int a和int b，在函数调用时，实参num1和num2的值会被传递给形参a和b，然后在函数内部进行计算。

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 << "mian中的 a = " << a << endl;
     cout << "mian中的 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;
 }
 ​
 ​
 0x61fe14
 0x61fe14
 *p = 10

指针变量和普通变量的区别

  • 普通变量存放的是数据,指针变量存放的是地址

  • 指针变量可以通过" * "操作符，操作指针变量指向的内存空间，这个过程称为解引用

总结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个字节

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

技巧：看const右侧紧跟着的是指针还是常量, 是指针就是常量指针，是常量就是指针常量

7.6 指针和数组

作用：利用指针访问数组中元素

示例：

 int main() {
 ​
     int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
 ​
     int * p = arr;  //指向数组的指针
 ​
     cout << "第一个元素： " << arr[0] << endl;
     cout << "指针访问第一个元素： " << *p << endl;
 ​
     for (int i = 0; i < 10; i++)
     {
         //利用指针遍历数组
         cout << *p << endl;
         p++;
     }
 ​
     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;
 }

总结：如果不想修改实参，就用值传递，如果想修改实参，就用地址传递

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

总结：当数组名传入到函数作为参数时，被退化为指向首元素的指针

在C++中，函数参数可以声明为指针类型或者数组类型，两者在函数定义和使用时有一些细微的差别。

当函数参数声明为指针类型时，例如int * arr，实际上是声明了一个指针变量arr，该指针指向一个整型数组。在函数内部，可以通过指针访问数组元素，使用指针算术运算来遍历数组，以及通过指针修改数组元素的值。此时，函数调用时可以传递一个指向数组首元素的指针，也可以传递一个指向数组中任意元素的指针。

当函数参数声明为数组类型时，例如int arr[]，实际上是声明了一个数组，该数组的长度由实际传递给函数的数组决定。在函数内部，使用数组下标来访问数组元素，不能使用指针算术运算来遍历数组，也不能通过数组名修改数组元素的值。此时，函数调用时必须传递一个完整的数组作为参数。

综上所述，int * arr和int arr[]在函数声明中表示的含义是一样的，都表示一个指向整型数组的指针。但在函数定义和使用时，int * arr更加灵活，可以处理不同长度的数组，而int arr[]必须传递一个完整的数组。

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

总结：如果不想修改主函数中的数据，用值传递，反之用地址传递

C++中值传递和地址传递有什么区别

在C++中，函数参数传递方式主要有值传递和地址传递两种方式。

值传递（Pass by Value）是指将实际参数的值复制给形式参数，函数内部对形式参数的修改不会影响到实际参数。在值传递中，函数对形式参数的修改只会在函数内部生效，函数外部的实际参数保持不变。这是因为在函数调用时，实际参数的值会被复制到一个新的内存空间中，函数内部对形式参数的操作只会修改这个新的内存空间中的值。

地址传递（Pass by Address）是指将实际参数的地址传递给形式参数，函数内部可以通过形式参数的地址来修改实际参数的值。在地址传递中，函数内部对形式参数的修改会直接影响到实际参数。这是因为在函数调用时，实际参数的地址会被传递给形式参数，函数内部对形式参数的操作实际上是在修改实际参数所在内存地址中的值。

区别：

  1. 值传递会复制实际参数的值到一个新的内存空间中，而地址传递只是传递实际参数的地址。

  2. 值传递对实际参数是只读的，函数内部无法修改实际参数的值，而地址传递可以修改实际参数的值。

  3. 值传递在函数调用结束后，形式参数的修改不会影响到实际参数，而地址传递会直接影响到实际参数。

选择使用值传递还是地址传递取决于需求。如果希望在函数内部修改实际参数的值，应该使用地址传递；如果不希望修改实际参数的值，或者希望保留实际参数的原始值，应该使用值传递。

地址传递会更改私有变量吗地址传递可以更改私有变量，但是需要通过类的成员函数来实现。

在C++中，私有变量是类的成员变量，只能通过类的成员函数来访问和修改。如果将私有变量的地址传递给函数，并在函数内部通过指针来修改私有变量的值，是可以实现对私有变量的更改的。

例如，考虑以下示例代码：

 class MyClass {
 private:
     int privateVar;
 ​
 public:
     void setPrivateVar(int* ptr) {
         privateVar = *ptr;
     }
 ​
     int getPrivateVar() {
         return privateVar;
     }
 };
 ​
 int main() {
     MyClass obj;
     int newValue = 10;
     obj.setPrivateVar(&newValue);
     cout << obj.getPrivateVar();  // 输出10
 ​
     return 0;
 }

在上述代码中，私有变量privateVar通过setPrivateVar函数的地址传递方式来更改。函数内部使用指针来获取传递进来的值，并将其赋值给私有变量privateVar。最终，通过getPrivateVar函数可以获取到私有变量的新值。

需要注意的是，私有变量的访问和修改应该通过类的公有成员函数来进行，以保证封装性和数据的安全性。

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名老师，通过函数给每个老师及所带的学生赋值

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

示例：

 struct Student
 {
     string name;
     int score;
 };
 struct Teacher
 {
     string name;
     Student sArray[5];
 };
 ​
 void allocateSpace(Teacher tArray[] , int len)
 {
     string tName = "教师";
     string sName = "学生";
     string nameSeed = "ABCDE";
     for (int i = 0; i < len; i++)
     {
         tArray[i].name = tName + nameSeed[i];
         
         for (int j = 0; j < 5; j++)
         {
             tArray[i].sArray[j].name = sName + nameSeed[j];
             tArray[i].sArray[j].score = rand() % 61 + 40;
         }
     }
 }
 ​
 void printTeachers(Teacher tArray[], int len)
 {
     for (int i = 0; i < len; i++)
     {
         cout << tArray[i].name << endl;
         for (int j = 0; j < 5; j++)
         {
             cout << "\t姓名：" << tArray[i].sArray[j].name << " 分数：" << tArray[i].sArray[j].score << endl;
         }
     }
 }
 ​
 int main() {
 ​
     srand((unsigned int)time(NULL)); //随机数种子 头文件 #include <ctime>
 ​
     Teacher tArray[3]; //老师数组
 ​
     int len = sizeof(tArray) / sizeof(Teacher);
 ​
     allocateSpace(tArray, len); //创建数据
 ​
     printTeachers(tArray, len); //打印数据
     
     system("pause");
 ​
     return 0;
 }

8.8.2 案例2

案例描述：

设计一个英雄的结构体，包括成员姓名，年龄，性别;创建结构体数组，数组中存放5名英雄。

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

五名英雄信息如下：

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

冒泡排序（Bubble Sort）是一种简单的排序算法，它重复地遍历要排序的元素列表，依次比较相邻的两个元素，如果它们的顺序不正确，就交换它们的位置。通过不断地比较和交换，将最大（或最小）的元素逐渐“冒泡”到列表的末尾，从而实现排序。

冒泡排序的基本思想是：每次比较相邻的两个元素，如果它们的顺序不正确，就交换它们的位置。这样，每一轮遍历都会将当前未排序部分的最大（或最小）元素“冒泡”到最后，直到所有元素都有序。

下面是冒泡排序的伪代码：

 冒泡排序（Bubble Sort）：
 1. 从第一个元素开始，依次比较相邻的两个元素。
 2. 如果它们的顺序不正确（比如，第一个元素大于第二个元素），就交换它们的位置。
 3. 继续比较下一对相邻元素，重复步骤2，直到遍历到最后一个元素。
 4. 重复步骤1~3，直到所有元素都有序（没有发生交换）。
 ​

下面是使用C++实现冒泡排序的示例代码：

 #include <iostream>
 using namespace std;
 ​
 void bubbleSort(int arr[], int n) {
     for (int i = 0; i < n-1; i++) {
         for (int j = 0; j < n-i-1; j++) {
             if (arr[j] > arr[j+1]) {
                 // 交换相邻元素的位置
                 int temp = arr[j];
                 arr[j] = arr[j+1];
                 arr[j+1] = temp;
             }
         }
     }
 }
 ​
 int main() {
     int arr[] = {64, 34, 25, 12, 22, 11, 90};
     int n = sizeof(arr) / sizeof(arr[0]);
 ​
     bubbleSort(arr, n);
 ​
     cout << "排序后的数组：";
     for (int i = 0; i < n; i++) {
         cout << arr[i] << " ";
     }
 ​
     return 0;
 }

在上述代码中，bubbleSort函数实现了冒泡排序算法。通过嵌套的循环，依次比较相邻的两个元素，并根据需要交换它们的位置。最外层的循环控制遍历的轮数，内层的循环控制每一轮的比较和交换。最终，通过多次遍历，将最大的元素逐渐“冒泡”到最后，实现排序。

在示例代码中，给定的数组为{64, 34, 25, 12, 22, 11, 90}，经过冒泡排序后，输出的有序数组为11 12 22 25 34 64 90。

示例：

 //英雄结构体
 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;
 }

##

东北霸总loudlee
关注
  • 24
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
黑马程序员C++教程讲义-保真
05-07
C++全面内容介绍
SpringBoot基础篇--黑马
06-22
"SpringBoot基础篇--黑马" 本资源主要介绍了SpringBoot基础篇的课程大纲，旨在帮助学习者快速掌握SpringBoot技术。课程主要分为三个阶段：基础篇、应用篇和原理篇。 基础篇主要介绍了SpringBoot的基础知识，包括...
黑马SpringBoot --开发篇
D_boj的博客
03-13 1748
目录 笔记小结开启开发者工具添加pom.xml依赖 激活热部署：Ctrl + F9进行编译关于热部署笔记小结设置自动构建项目Settings(设置自动构建项目)1.默认不触发重启的目录列表2.自定义不参与重启排除项(也就是，自定义配置不参与热重启) 9.4关闭热部署 属性加载优先顺序参看https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-exter
【黑马程序员】C++学习笔记--入门篇（上）
2401_82949788的博客
02-14 727
C++学习笔记，基础入门知识（上篇），包括基本常识、数据类型、运算符、程序流程结构（选择、循环、跳转）的知识点及示例代码及结果图片，方便初学者进行学习。
【黑马程序员】C++学习笔记--核心篇
2401_82949788的博客
02-21 861
堆区数据由程序员管理开辟和释放堆区数据利用new关键字进行开辟内存。
【黑马程序员】C++学习笔记--入门篇（下）
2401_82949788的博客
02-16 1595
数组、函数、指针（重点）、结构体（自定义数据类型、重点）、通讯录管理系统案例实战
黑马c++学习笔记基础篇
m0_52444089的博客
11-24 532
在网页上做的个人笔记，大概是第三次重刷才进行的笔记记录，不是很详细，只是作为学习记录使用，还请批评指正
C++刷题笔记----基础入门篇
never_stop_rain的博客
07-06 1099
C++牛客基础入门题刷题记录
【黑马程序员】C++学习笔记--入门篇（上(2)，2024年最新原理+实战+视频+源码
2301_78146994的博客
04-19 460
/ 输入一个分数，如果分数大于600分，视为考上一本大学，并在屏幕上打印 ，否则输出未考上一本大学。// 输入一个分数，如果分数大于600分，视为考上一本大学，并在屏幕上打印 ，// 如果分数小于600，但大于400分，视为考上二本大学，输出考上二本大学，// 如果分数小于400，但大于300分，视为考上三本大学，输出，cout
黑马c++学习笔记核心篇
m0_52444089的博客
11-25 356
对c++基础篇的学习笔记，对自我复习还是有一定用处的，并没有里面单纯的是学习笔记并未有深入的思考记录
黑马C++学习笔记——核心编程篇
m0_49687898的博客
11-19 1527
黑马C++学习笔记——核心编程篇
前端学习笔记-黑马程序员
01-09
前端学习笔记-黑马程序员 本篇文章主要介绍了 HTML 基础知识，涵盖了标签的基本概念、HTML 基本结构、文档类型声明、字符集、标签语义、标题标签、段落和换行标签、文本格式化标签、图像标签、路径、超链接标签、...
前端学习笔记-黑马程序员Vue
01-09
前端学习笔记-黑马程序员Vue Vue.js 是一款流行的前端框架，它提供了强大的模板语法、数据绑定、MVVM 模型等特点，帮助开发者快速构建复杂的前端应用程序。下面是对 Vue.js 的一些重要知识点的总结： Vue.js ...
前端学习笔记-黑马程序员JS
01-09
"前端学习笔记-黑马程序员JS" ...这篇前端学习笔记涵盖了 JavaScript 的基础知识，包括变量、数据类型、运算符、流程控制、数组、函数、对象、内置对象和 Web APIs 等知识点，为学习 JavaScript 提供了系统的指导。
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 1005
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 143
BCSP-X 11题 C++代码详解
【c++进阶(三)】STL之vector的介绍和使用
最新发布
weixin_62196764的博客
06-15 684
1.vector表示的是可变序列大小的容器2、vector就像数组一样，也采用的连续空间来存储元素，这也意味着可以采用下标对vector的元素进行访问。3、vector与普通数组不同的是，vector的大小是可以动态改变的。4、当vector需要重新分配大小时，其做法是，分配一个新的数组，然后将全部元素移到这个数组当中，并释放原来的数组空间。---这就表明原来指向该位置的迭代器已经失效了，所以在插入和删除数据的时候要返回一个合法的迭代器的位置。
c++|unordered系列关联式容器(unordered_set、unordered_map介绍使用+哈希结构)
weixin_68201503的博客
06-09 752
1.unordered_set与set一样元素key与value是一一对应的，且是唯一的,set中的key不能在容器中修改(元素总是const)，但是可以插入和删除,且元素是去重的。2.unordered_set与set不一样的是，其底层是由数组实现，数组存储的是，且节点值的顺序没有按照特定的顺序排序，为了能在常数范围内找到可以所对应的key，unordered_set将相同哈希值的键值对放在相同的桶中(比较抽象，待后续分析)。
黑马程序员讲义-C++核心编程pdf
09-07
黑马程序员讲义-C核心编程的PDF是程序员讲义的第三阶段的讲义，它包含了关于C语言的内容。你可以通过引用来获取这个PDF的具体内容。<span class="em">1</span><span class="em">2</span><span class="em">3</span>...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

东北霸总loudlee

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值