黑马程序员C++ 第一阶段 C++基础语法入门

已于 2023-03-08 10:52:54 修改
阅读量202 收藏 2
点赞数
分类专栏： C++ 文章标签： c++ Powered by 金山文档
于 2023-03-07 10:39:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aaafdfd/article/details/129376091
版权

B站黑马C++内容，自己手动敲了一遍代码，文章之间也加入了一些我个人的理解，仅供学习和参考用，程序代码均来自黑马程序员 。

一.C++基础入门
1.1第一个c++程序 （输出一个hello world）
#include<iostream>
using namespace std;

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

这里我们要知道cout<<""<<endl; 我们只要在双引号""里输入任意的内容，就会在控制台上打印相应的内容就可以了，其它行的代码可以理解为一个默认的框架，我们每次写的时候要加上这几行代码，不然就无法正常执行程序。后面会详细介绍的。

1.2注释

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

两种格式

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

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

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

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

#include<iostream>
using namespace std;

int main()
{
    cout << "你好" << endl;
    //cout<<"hello"<<endl;
    /*cout<<"hi"<<endl;
    cout<<"haha"<<endl;*/
    system("pause");
    return 0;
}

上图控制台输出的结果是 "你好" 不会输出"hello" "hi" 以及 "haha"，是因为给它们加了注释，注释可以理解为是给程序员看的，而编译器不会执行里面的程序代码。

1.3变量

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

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

#include<iostream>
using namespace std;

int main()
{
    int a = 10;
    cout << "a = " << a << endl;
    system("pause");
    return 0;
}
1.4常量

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

C++定义常量两种方式

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

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

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

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

#include<iostream>
using namespace std;
#define Day 7
int main()
{
    //1.#define定义宏常量
    cout << "一周一共有" << Day << "天" << endl;
    //2.const修饰的变量
    const int a = 10;
    // a = 20; 此时会报错，因为a已近被const修饰了，成为了一个常量，所以不可以改变             
    cout << "a = " << a << endl;
    system("pause");
    return 0;
}
1.5关键字

作用：C++中预先保留的单词

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

int int = 10；（错误，这里的第一个是int是关键字，第二个是数据类型，不能和关键字一样）

1.6标识符的命名规则

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

1.标识符不能是关键字

2.标识符只能由字母、数字、下划线组成。

3.第一个字符必须为字母或者下划线

4.标识符中字母区分大小写

int abc=10；

int _abc=20;

int _123abc=32;

int 234abc=43;(错误，不能以数字开头)

二.数据类型

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

2.1整形

作用：整形变量表示的是整形数据类型

C++中能够表示类型的数据类型有以下几种方式，区别在于所占内存空间的不同：

数据类型

占用空间

取值范围

Short（短整型）

2字节

(-2^15~2^15-1）

Int（整型）

4字节

(-2^31~2^31-1)

Long（长整型）

Window下为4字节 linux为4字节（32位）

8字节（64位）

(-2^31~2^31-1)

Long long（长长整型）

8字节

(-2^31~2^31-1) 

#include<iostream>
using namespace std;
int main()
{
    //1.短整型short
    short num1 = 10;
    cout << "short(num1)所占内存空间的大小为：" << sizeof(short) << endl;
    cout << "short(num1)所占内存空间的大小为：" << sizeof(num1) << endl;

    //2.整型int
    int num2 = 10;
    cout << "int(num2)所占内存空间的大小为：" << sizeof(int) << endl;
    cout << "int(num2)所占内存空间的大小为：" << sizeof(num2) << endl;

    //3.长整型long
    long num3 = 10;
    cout << "long(num3)所占内存空间的大小为：" << sizeof(long) << endl;
    cout << "long(num3)所占内存空间的大小为：" << sizeof(num3) << endl;

    //4.长长整型long long
    long long num4 = 10;
    cout << "long long(num4)所占内存空间的大小为：" << sizeof(long long) << endl;
    cout << "long long(num4)所占内存空间的大小为：" << sizeof(num4) << endl;

    cout << "num1= " << num1 << endl;
    cout << "num2= " << num2 << endl;
    cout << "num3= " << num3 << endl;
    cout << "num4= " << num4 << endl;
    
    system("pause");
    return 0;
}
2.2sizeof关键字

作用：利用sizeof关键字可以统计数据类型所占内存空间的大小

语法：sizeof（数据类型/变量）

2.3实型（浮点型）

作用：用于表示小数

浮点型变量分为两种：

  1. 单精度float

  1. 双精度double

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

数据类型

占用空间

有效范围数字

Float

4字节

7位有效数字

Double

8字节

15-16位有效数字

3.14表示的是三位有效数字

#include<iostream>
using namespace std;
int main()
{
    //1、单精度 float
    float f1 = 3.1415926f;
    cout << "f1= " << f1 << endl;

    //2、双精度 double
    double f2 = 3.14;
    cout << "f2= " << f2 << endl;

    //统计float和doubel所占的内存空间
    cout << "float所占用的内从空间为" << sizeof(float) << endl;

    cout << "double所占用的内从空间为" << sizeof(double) << endl;

    //科学计数法
    //3e2表示3x10的平方，3e-3表示3x10的负2次方
    float f3 = 3e2;
    cout << "f3= " << f3 << endl;
    float f4 = 3e-2;
    cout << "f4= " << f4 << endl;
    
    system("pause");
    return 0;
}
2.4字符型 
#include<iostream>
using namespace std;
int main()
{
    //字符型变量创建方式
    char ch = 'a';
    cout << ch << endl;
    //字符型变量所占内存空间的的大小
    cout << "char所占内存空间的大小为：" << sizeof(char) << endl;

    //字符型变量常见的错误
    //char ch2 = "b";           不能用双引号
    //char ch3 = 'abcdef';      创建字符型变量单引号中智能存在一个值

    //字符型变量对应的ASCII码值
    //a-97   b-98  A-65(以此类推)
    cout << (int)ch << endl;           //结果为97
    
    system("pause");
    return 0;
}

*C和C++中字符型变量只占一个字节

*字符型变量并不是把字符本身放到内存中存储，而是将对应的ASC11码值放到存储单元。

2.5转义字符

作用：用于表示一些不能显示出来的ASC11字符

现阶段我们常用的转义字符有\n \\ \t

#include<iostream>
using namespace std;
int main()
{
    //转义字符
    //换行符   \n
    cout << "hello world\n";

    //反斜杠   \\

    cout << "\\" << endl;   //输出两个\\表示一个\

    //水平制表符  \t   有对齐效果，看起来比较整洁
    cout << "aaa\thelloworld" << endl;
    cout << "aaaaa\thelloworld" << endl;
    cout << "a\thelloworld" << endl;
    
    system("pause");
    return 0;
}
2.6字符串类型 
#include<iostream>
using namespace std;
#include<String>        //用C++风格字符串，要包含这个头文件
int main()
{
    //1.C风格字符串
    //注意事项   char 字符串名[]
    //等号后面要用双引号 包含起来字符串
    char str[] = "hello world";
    cout << str << endl;

    //2.C++风格字符串
    string str2 = "hello world";
    cout << str2 << endl;
    
    system("pause");
    return 0;
}
2.7布尔类型bool

作用：布尔类型代表真或者假的值

Bool类型只有两个值：

*true-----真（本质是1）

*false----假（本质是0）

Bool类型占一个字节大小

#include<iostream>
using namespace std;
int main()
{
    //1.创建bool数据类型
    bool flag = true;  //true代表真
    cout << flag << endl;        //1
    flag = false;
    cout << flag << endl;        //0

    //2.查看bool类型所占内存空间的大小
    cout << "布尔类型所占内存空间的大小为：" << sizeof(bool) << endl;  //1


    
    system("pause");
    return 0;
}
2.8数据的输入

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

关键字：sin

语法 cin>>变量

#include<iostream>
using namespace std;
int main()
{
    cout << "请随机输入一个数字" << endl;

    int a;
    cin >> a;

    cout << "输入的数为：" << a << endl;
    
    system("pause");
    return 0;
}
三.运算符

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

运算符类型

作用

算数运算符

用于处理四则运算

赋值运算符

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

比较运算符

用于表达式的比较，并返回一个真值或者假值

逻辑运算符

用于根据表达式的值返回真值或者假值

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

#include<iostream>
using namespace std;
int main()
{
    //加减乘除
    int a1 = 10;
    int b1 = 3;

    cout << "a + b = " << a1 + b1 << endl;   //13
    cout << "a - b = " << a1 - b1 << endl;   //7
    cout << "a * b = " << a1 * b1 << endl;   //30
    cout << "a / b = " << a1 / b1 << endl;   //3  两个整数相除，结果依然是整数，将小数部分去除
    //两个小数部分相除，除数不可以是0
    //两个小数之间可以相除，运算的结果也可以是小数
    //取余运算
    //两个小数是不可以取模运算的
    int a2 = 10;
    int b2 = 3;
    cout << "a2 % b2 = " << a2 % b2 << endl;   //1

    //前置递增
    int a = 10;
    ++a;       //让变量加一
    cout << "a = " << a << endl;       //11
    //后置递增
    int b = 10;
    b++;      //让变量加一
    cout << "b = " << b << endl;       //11

    //前置和后置的区别
    //前置递增，先让变量+1，然后进行表达式的运算
    int a4 = 5;
    int b4 = ++a4 * 10;
    cout << "a4 = " << a4 << endl;       //6
    cout << "b4 = " << b4 << endl;       //60

    int a5 = 5;
    int b5 = a5++ * 10;
    cout << "a5 = " << a5 << endl;      //6
    cout << "b5 = " << b5 << endl;      //50

    system("pause");
    return 0;
}
3.2赋值运算符

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

赋值运算符包括以下几个符号

运算符

术语

示例

结果

=

赋值

a=2;b=3

a=2;b=3;

+=

加等于

a=0;b++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

#include<iostream>
using namespace std;

int main()
{
    //赋值运算符
    // +=
    int a = 10;
    a += 2;
    cout << "a = " << a << endl;    //12

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

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

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

    system("pause");
    return 0;
}
3.3比较运算符

作用：用于表达式的比较，并返回一个真值或假值

比较运算符有以下符号：

运算符

术语

示例

结果

==

相等于

4==3

0

！=

不等于

4！=3

1

<

小于

4<3

0

>

大于

4>3

1

<=

小于等于

4<=3

0

>=

大于等于

4>=3

1

#include<iostream>
using namespace std;

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;
}
3.4逻辑运算符

作用：用于根据逻辑表达式的值返回真值或假值

逻辑运算符有以下符号：

运算符

术语

示例

结果

！

非

！a

如果a为假，则！a为真；反之

&&

与

a&&b

如果a和b都为真，则结果为真，否则为假

||

或

a||b

如果a和b有一个为真，结果为真，二者都为假，结果才为假

#include<iostream>
using namespace std;

int main()
{
    //逻辑运算符 非
    int a = 10;
    //在c++中除了0 都为真
    cout << !a << endl;        //0
    cout << !!a << endl;       //1

    //逻辑运算符  与
    //同真为真，其余为假，零零为假
    int b = 10;
    int c = 10;
    cout << (b && c) << endl;    //1

    b = 0;
    c = 10;
    cout << (b && c) << endl;   //0

    b = 0;
    c = 0;
    cout << (b && c) << endl;   //0

    //逻辑运算符  或
    //同假为假，其余为真
    int d = 10;
    int e = 10;
    cout << (d || e) << endl;   //1

    d = 0;
    e = 10;
    cout << (d || e) << endl;   //1

    d = 0;
    e = 0;
    cout << (d || e) << endl;   //0

    system("pause");
    return 0;
}
四.程序流程结构

C/C++支持最基本的三种程序运行结构：顺序结构、选择结构、循环结构。

顺序结构：程序按照顺序执行，不发生跳转。

选择结构：依据条件是否满足，有选择的执行相应的功能。

循环结构：依据条件是否满足，循环多次执行某段代码。

4.1选择结构

if语句

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

If语句的三种表现形式

单行格式if语句

多行格式if语句

多条件的if语句

  1. 单行格式if语句：if（条件）{条件满足执行的语句}

#include<iostream>
using namespace std;
int main()
{
    //选择结构 单行if语句
    //用户输入分数，如果分数大于600，视为考上一本大学，在屏幕上输出
    //1、用户输入分数
    int score = 0;
    cout << "请输入一个分数" << endl;
    cin >> score;

    //2、打印用户输入的分手
    cout << "您输入的分数为 " << score << endl;


    //3、判断分数是否大于600，如果大于，那么输出
    //注意事项，if条件后不要加分号  ；
    if (score > 600)
    {
        cout << "恭喜你考入一本大学" << endl;
    }
    system("pause");
    return 0;
}

  1. 多行格式if语句：if（条件）{条件满足执行的预计}else{条件不满足执行的语句}

  1. 多条件的if语句：if 于 else多次使用

#include<iostream>
using namespace std;
int main()
{
    //选择结构  多条件if语句
    //输入一个考试分数，如果大于600，那么考上一本大学。
    //大于500，视为考上二本大学。
    //大与400，视为考上三本大学。
    //小于等于400，则未考上大学，在屏幕上输出。
    //1、输入你所考的分数
    int score = 0;
    cout << "请输入您的高考分数" << endl;
    cin >> score;
    //2、提示用户所输入的分数
    cout << "您的高考分数为 " << score << endl;

    //3、判断分数所能上的大学，给出最终结果
    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语句，达到更清晰的条件判断。

案例需求：

提示用户输入一个高考考试分数，根据分数做出以下判断

1.分数如果大于600分视为考上一本大学，大于500分考上而二本大学，大于400考上三本大学，其余均视为未考上本科大学

2.在一本分数中，如果大于700分，考入北大，大于650分，考入清华，大于600考入人大。

if (score >= 600)
    {
        
        if (score >= 700)
        {
            cout << "您能考入北京大学" << endl;
        }
        else if (score >= 650)
        {
            cout << "您能考入清华大学" << endl;
        }
        else
        {
            cout << "您能考入中国人民大学" << endl;
        }
    }

练习案例：

有三只小猪ABC，分别输入三只小猪的体重，并且判断哪只小猪最重

#include<iostream>
using namespace std;
int main()
{
    int a, b, c;
    cout << "小猪a的重量为" << endl;
    cin >> a;
    cout << "小猪b的重量为" << endl;
    cin >> b;
    cout << "小猪c的重量为" << endl;
    cin >> c;
    if (a > b)
    {
        if (a > c)
        {
            cout << "小猪a最重" << endl;
        }
        else
        {
            cout << "小猪c最重" << endl;
        }
    }
    if (b > a)
    {
        if (b > c)
        {
            cout << "小猪b最重" << endl;
        }
        else
        {
            cout << "小猪c最重" << endl;
        }
    }
    
    
    system("pause");
    return 0;
}

三目运算符

作用：通过三目运算符实现简单的判断

语法：表达式1？表达式2：表达式3

解释：

如果表达式1的值为真，执行表达式2，并返回表达式2的结果；

如果表达式1的值为假，执行表达式3，并返回表达式3的结果；

#include<iostream>
using namespace std;
int main()
{
    //三目运算符
    //创建三个变量a,b,c
    //将a和b做比较，将变量大的值赋给变量c
    int a = 10;
    int b = 20;
    int c = 0;
    c = (a > b ? a : b);
    cout << "c= " << c << endl;  //c=20
    //在C++中三目运算符返回的是变量，可以继续赋值。
    (a > b ? a : b) = 100;
    cout << "a= " << a << endl;  //a=10
    cout << "b= " << b << endl;  //b=100

    system("pause");
    return 0;
}

switch语句

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

语法：

switch(表达式)

{

case 结果1：执行语句；break；

case 结果2：执行语句；break；

.........

default:执行语句；break；

}

#include<iostream>
using namespace std;
int main()
{
    //switch 语句
    //给电影进行打分
    //10~9    经典
    //8~7     非常好
    //6~5     一般
    //5以下   烂片


    //1、提示用户给电影评分
    cout << "请您给这部电影打分" << endl;
    //2、用户开始进行打分
    int score = 0;
    cin >> score;
    cout << "您给这部电影打的分数为" << score << endl;
    //3、根据用户所给的分数提示用户最后的结果
    switch (score)
    {
    case 10:
        cout << "您认为是经典电影" << endl;
        break;  //退出当前的分支
    case 9:
        cout << "您认为是经典电影" << endl;
        break;
    case 8:
        cout << "您认为是电影非常好" << endl;
        break;
    case 7:
        cout << "您认为是电影非常好" << endl;
        break;
    case 6:
        cout << "您认为是电影一般" << endl;
        break;
    case 5:
        cout << "您认为是电影一般" << endl;
        break;
    default:
        cout << "您认为是烂片" << endl;
    }


    system("pause");
    return 0;
}
4.2循环结构

while循环语句

作用：满足循环条件，执行循环语句

语法：while（循环条件）{循环语句}

解释：只有循环条件的结果为真，就执行循环语句

#include<iostream>
using namespace std;
int main()
{
    //while循环
    //在屏幕中打印0~9这十个数字
    //在循环中，避免死循环的出现
    int num1 = 0;
    while (num1 < 10)//如果括号里为1，那么程序将永远执行下去
    {
        cout << num1 << endl;
        num1++;
    }
    system("pause");
    return 0;

While循环案例练习：

案例描述：系统随机生成1到100之间的数字，玩家进行猜测，如果猜错，提示玩家数字过大或者过小，如果猜对恭喜玩家胜利，并且推出游戏。

#include<iostream>
using namespace std;
//time系统时间头文件包含
#include<ctime>
int main()
{
    //添加随机数种子  作用利用当前系统时间生成随机数，防止每次随机数都一样
    srand((unsigned int)time(NULL));

    //这是一个伪随机数的生成
    //1、系统生成随机数
    int num = rand() % 100 + 1;   //rand()%100+1 生成一个0+1~99+1的随机数
    //cout << num << endl;   
    //2、玩家进行猜测
    int val = 0;     //玩家输入的随机数
    while (1)
    {
        cin >> val;
        //3、判断玩家的猜想
        if (val > num)
        {
            cout << "猜测过大" << endl;
        }
        else if (val < num)
        {
            cout << "猜测过小" << endl;
        }
        else
        {
            cout << "恭喜你猜对了" << endl;
            break;//可以利用这个关键字退出当前循环
        }

    }
    //猜对    退出游戏
    //猜错    提示猜的结果  过大或者过小  重新返回第二步
    system("pause");
    return 0;
}

do.......while循环语句

作用：do{循环语句}while{循环语句}

注意：与while的区别在于do....while会先执行一次循环语句，在判断循环条件

#include<iostream>
using namespace std;
int main()
{
    //do.....while循环语句
    //在屏幕中输出0-9这十个数字
    int num1 = 0;
    do
    {
        cout << num1 << endl;
        num1++;
    } while (num1 < 10);
    //do...while与while循环的区别在于do....while会先执行一次循环语句
    system("pause");
    return 0;
}

案例练习：水仙花数

案例描述：水仙花数是一个三位数，他的每个位上的三次幂之和等于他本身

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

请利用do.....while语句，求出所有三位数中的水仙花数

#include<iostream>
using namespace std;
int main()
{
    int a = 100;
    while (a < 1000)
    {
        
        int ge = a % 10;
        int shi = a / 10 % 10;
        int bai = a / 100;
        if (ge* ge* ge + shi * shi * shi + bai * bai * bai == a)
        {
            cout << a << endl;
        }
        a++;
    }
    system("pause");
    return 0;
}

for循环语句

作用：满足循环条件，执行循环语句

语法：for(起始表达式;条件表达式;末尾循环体;}{循环语句}

#include<iostream>
using namespace std;
int main()
{
    //for循环，从数字0打印到数字9
    for (int i = 0; i < 10; i++)
    {
        cout << i << endl;
    }
    system("pause");
    return 0;
}

练习案例：敲桌子

案例描述：从1开始数到数字100，如果个位数字含有7，或者十位数字含有7，或者该数字是7的倍数，我们打印敲桌子，其余数字直接打印输出

#include<iostream>
using namespace std;
int main()
{
    for (int i = 1; i <= 100; i++)
    {
        if (i % 10 == 0)
        {
            cout << "敲桌子" << endl;
        }
        if (i / 10 == 7)
        {
            cout << "敲桌子" << endl;
        }
        if (i % 7 == 0)
        {
            cout << "敲桌子" << endl;
        }
        else
        {
            cout << i << endl;
        }
    }
    system("pause");
    return 0;
}

嵌套循环

作用：在循环体中再嵌套一层循环，解决一些实际问题

例如我们想在屏幕中打印图片，就是要利用嵌套循环

#include<iostream>
using namespace std;
int main()
{
    //利用嵌套循环实现星图
    //打印一行星图

    //外层循环一次，内层循环一周
    //外层循环
    for (int j = 0; j < 10; j++)
    {
        //内层循环
        for (int i = 0; i < 10; i++)
        {
            cout << "* ";
        }
        cout << endl;
    }
    system("pause");
    return 0;
}

案例练习：乘法口诀表

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

#include<iostream>
using namespace std;
int main()
{
    //乘法口诀表
    //打印行数
    for (int i = 1; i <= 9; i++)
    {
        //cout << i << endl;
        for (int j = 1; j<=i; j++)
        {
            cout << j << " * " << i << " = " << j * i<<"   " ;
        }
        cout << endl;
    }

    system("pause");
    return 0;
}
4.3跳跃语句

break语句

作用：用于跳出选择结构或者循环结构

Break使用的动机：

出现在switch条件语句中，作用是终止case并跳出switch

出现在循环语句中，作用是跳出当前循环

出现在嵌套语句中，跳出最近的内层循环语句

#include<iostream>
using namespace std;
int main()
{
    //break的使用时机
    //1、出现在switch语句中
    //cout << "请选择副本的难度" << endl;
    //cout << "1、普通" << endl;
    //cout << "2、中等" << endl;
    //cout << "3、困难" << endl;
    //int select = 0;     // 创建选择结果的变量
    //cin >> select;
    //switch (select)
    //{
    //case 1:
    //    cout << "您选择的是普通难度" << endl;
    //    break;//退出switch语句
    //case 2:
    //    cout << "您选择的是中等难度" << endl;
    //    break;
    //case 3:
    //    cout << "您选择的是困难难度" << endl;
    //    break;
    //default:
    //    break;
    //}
    //2、出现在循环语句中
    /*for (int i = 0; i < 10; i++)
    {
        if (i > 5)
        {
            break;
        }
        cout << i << endl;
    }*/
    //3、出现在嵌套循环语句中
    for (int j = 0; j < 10; j++)
    {
        for (int i = 0; i < 10; i++)
        {
            if (i == 5)
            {
                break;
            }
            cout << "* ";
        }
        cout << endl;
    }
    system("pause");
    return 0;
}

continue语句

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

#include<iostream>
using namespace std;
int main()
{
    for (int i = 0; i <= 100; i++)
    {
        //如果是奇数输出，偶数不输出
        if (i % 2 == 0)
        {
            continue;//break会退出循环，continue不会，他会执行下一次循环
        }
        cout << i << endl;
    }
    system("pause");
    return 0;
}

goto 语句

作用：可以无条件的跳转语句

语法：goto标记

解释：如果标记的名称存在，执行到goto语句值，会跳转的标记的位置

#include<iostream>
using namespace std;
int main()
{
    //goto过于强大，不推荐使用  知道就行
    //goto 语句
    cout << "1、xxxx" << endl;
    cout << "2、xxxx" << endl;

    goto FLAG;
    cout << "3、xxxx" << endl;
    cout << "4、xxxx" << endl;

    FLAG:
    cout << "5、xxxx" << endl;

    system("pause");
    return 0;
}
五.数组
5.1概述

所谓数组，就是一个集合，里面存放了相同类型的数据元素

特点1：数组中的每个数组元素都是相同的数据类型

特点2：数组是由连续的内存位置组成的

5.2一维数组

一维数组的定义方式

一维数组定义的三种方式

  1. 数据类型 数组名[数组长度]

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

  1. 数据类型 数组名[ ]={值1.值2..........}

#include<iostream>
using namespace std;
int main()
{
    int arr[5];
    arr[0] = 10;
    arr[1] = 20;
    arr[2] = 30;
    arr[3] = 40;
    arr[4] = 50;
    //访问数据元素
    cout << arr[0] << endl;

    //如果在初始化数据时候，没有全部填写完，会用0来填补剩余的数据
    int arr1[5] = { 10,20,30,40,50 };
    cout << arr1[0] << endl;
    for (int i = 0; i <= 4; i++)
    {
        cout << arr1[i] << endl;
    }

    int arr2[] = { 34,53,535,53 };
    cout << arr2[1] << endl;
    system("pause");
    return 0;
}

一维数组数组名

一维数组名称的用途：

  1. 可以统计整个数组在内存中所占的长度

  1. 可以获取数组在内存中的首地址

#include<iostream>
using namespace std;
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;
    //不加int所展示的是一个十六进制数的首地址，加int强转为10进制的首地址
    cout << "数组中第一个元素的首地址为" << (int)&arr[0] << endl;
    cout << "数组中第二个元素的首地址为" << (int)&arr[1] << endl;
    //第一个元素的首地址（在十进制的情况下）+4=第二个元素的首地址
    //数组名是常量，不可以进行赋值操作
    //arr = 100;
    system("pause");
    return 0;
}

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

案例描述：

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

找出并打印最重的小猪。

#include<iostream>
using namespace std;
int main()
{
    //在一个数组中记录了五只小猪的体重如：int arr[5] = { 300,350,200,400,250 }
    //找出并打印最重的小猪。

    int arr[5] = { 300,350,200,400,250 };

    int max = arr[0];

    for (int i = 1; i <= 4; i++)
    {
        if (arr[i] > max)
        {
            max = arr[i];
        }
    }
    cout << "最重小猪的体重为：" << max << endl;


    system("pause");
    return 0;
}

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

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

（如预原数组元素为：1,3,2,5,4；逆置后输出的结果为4,5,2,3,1）；

#include<iostream>
using namespace std;
int main()
{
    //实现元素的逆置
    //1、创建数组
    int arr[5] = { 1,3,2,5,4 };
    cout << "数组逆置前： " << endl;
    for (int i = 0; i <= 4; i++)
    {
        cout << arr[i];
    }
    cout << endl;
    //2、实现逆置
    //2.1记录起始下标的位置
    //2.2记录结束下标的位置
    //2.3起始下标与原始下标的元素互换
    //2.4起始位置++，结束位置——
    //2.5循环2.1操作，直到起始位置>=结束位置
    int start = 0;
    int end = sizeof(arr) / sizeof(arr[0]) - 1;//结束下标
    //实现元素互换
    while (start < end)
    {
        int temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;
        //下标更新
        start++;
        end--;
    }
    //3、打印逆置后的数组
    cout << "数组逆置后： " << endl;
    for (int i = 0; i <= 4; i++)
    {
        cout << arr[i];
    }
    cout << endl;
    system("pause");
    return 0;
}

冒泡排序

作用：最常用的排序算法，对数组内元素进行排序

1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2.对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值。

3.重复以上的步骤，每次比较次数-1，直到不需要比较。

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

#include<iostream>
using namespace std;
int main()
{
    //利用冒泡排序实现升序序列
    int arr[9] = {4,2,8,0,5,7,1,3,9};

    cout << "排序前： " << endl;
    for (int i = 0; i < 9; i++)
    {
        cout << arr[i] << "  ";
    }
    cout << endl;
    //开始冒泡排序
    //排序的总轮数=元素个数-1
    for (int i = 0; i < 9 - 1; i++)
    {
        //内层循环对比 次数=元素个数-当前轮数-1
        for (int j = 0; j < 9 - i - 1; j++)
        {
            //如果第一个数字比第二数字大，实现交换这两个数字
            if (arr[j] > arr[j + 1])
            {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j + 1] = temp;

            }
        }
    }
    //排序后的结果
    cout << "排序后  " << endl;
    for (int i = 0; i < 9; i++)
    {
        cout << arr[i] << "  ";
    }
    cout << endl;
    system("pause");
    return 0;
}
5.3二维数组

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

二维数组的定义方式

二维数组定义的四种方式：

  1. 数据类型 数组名[行数] [列数];

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

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

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

#include<iostream>
using namespace std;
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;
    cout << arr[0][0] << endl;
    cout << arr[0][1] << endl;
    cout << arr[0][2] << endl;
    cout << arr[1][0] << endl;
    cout << arr[1][1] << endl;
    cout << arr[1][2] << endl;
    //外层循环打印行数，内层循环打印列数
    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            cout << arr[i][j] << endl;
        }
    }
    //2.数据类型 数组名[行数][列数] = { {数据1，数据2} }, { {数据3，数据4}};
    int arr2[2][3] = { {1,2,3},{4,5,6} };
    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            cout << arr2[i][j] << "  ";
        }
        cout << endl;
    }
    //3.数据类型 数组名[行数][列数] = { 数据1，数据2，数据3，数据4 };
    int arr3[2][3] = { 1,2,3,4,5,6 };
    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            cout << arr3[i][j] << "  ";
        }
        cout << endl;

    }
    //4.数据类型 数组名[][列数] = { 数据1，数据2，数据3，数据4 };
    //可以不写行数，但是不能不写列数
    int arr4[][3] = { 1,2,3,4,5,6 };
    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            cout << arr4[i][j] << "  ";
        }
        cout << endl;

    }
    system("pause");
    return 0;
}

二维数组数组名

查看二维数组所占内存空间

获取二维数组的首地址

#include<iostream>
using namespace std;
int main()
{
    //二维数组名称用途
    //1、可以查看占用内存空间的大小
    int arr[2][3] = { 1,2,3,4,5,6 };
    cout << "二维数组arr所占内存空间的大小为： " << 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;
    //2、可以查看二维数组的首地址
    cout << "二维数组的首地址为 " << arr << endl;
    //转为十进制加int
    cout << "二维数组的首地址为 " << (int)arr << endl;
    cout << "二维数组第一行的首地址为 " << (int)arr[0] << endl;
    cout << "二维数组第二行的首地址为 " << (int)arr[1] << endl;
    cout << "二维数组第一个元素的的首地址为 " << (int)&arr[0][0] << endl;
    cout << "二维数组第二个元素的的首地址为 " << (int)&arr[0][1] << endl;
    system("pause");
    return 0;
}

维数组应用的案例

考试成绩统计：

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

语文

数学

英语

张三

100

100

100

李四

90

50

100

王五

60

70

80

#include<iostream>
using namespace std;
#include<string>
int main()
{
    //1、创建二维数组
    int score[3][3] = { {100,100,100},{90,50,100},{60,70,80} };
    string names [3] = { "张三","李四","王五" };
    //2、统计每个人的总和分数
    for (int i = 0; i < 3; i++)
    {
        int sum = 0;//统计分数总和的变量
        for (int j = 0; j < 3; j++)
        {
            sum += score[i][j];
            //cout << score[i][j] << "  ";
        }
        //cout << endl;
        cout << names[i]<<"的总分为  " << sum << endl;
    }
    system("pause");
    return 0;
}
六.函数
6.1概述

作用：将一段经常使用的代码封装起来，减少重复代码

一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能

6.2函数的定义

函数的定义有5个步骤：

  1. 返回值类型

  1. 函数名

  1. 参数列表

  1. 函数体语句

  1. return表达式

语法：

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

{

函数体语句

return表达式

}

返回值类型：一个函数可以返回一个值，在函数定义中

函数名：给函数起个名称

参数列表：使用该函数时，传入数据

函数体语句：花括号内的代码，函数需要执行的语句

return表达式：和返回值类型挂钩，函数执行完后，返回相应的数据

#include<iostream>
using namespace std;

//函数的定义
//语法：
//返回值类型  函数名（参数列表）{函数体语句  return表达式}
//加法函数，实现两个整型相加，并且将相加的结果进行返回
int add(int num1, int num2)
{
    int sum = num1 + num2;
    return sum;
}
int main()
{
    system("pause");
    return 0;
}
6.3函数的调用

功能：使用定义好的函数

语法：函数名（参数）

#include<iostream>
using namespace std;
//定义一个加法的函数
//函数定义的时候，num1和num2并没有真实数据，他只是形式上的参数，简称形参
int add(int num1, int num2)
{
    int sum = num1 + num2;
    return sum;
}
int main()
{
    //main函数中调用add函数
    int a = 10;
    int b = 20;
    //函数调用的语法：函数名称（参数）
    //a和b称为实际的参数
    //当调用这个函数的时候实参的值会传递给形参
    int c = add(a, b);
    cout << "c= " << c << endl;
    a = 100;
    b = 200;
    c = add(a, b);
    cout << "c= " << c << endl;
    system("pause");
    return 0;
}

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

6.4值传递

所谓值传递，就是函数调用时实参将数值传入给形参。

值传递时，如果形参发生改变，并不会影响实参。

#include<iostream>
using namespace std;
//值传递
//定义函数，实现两个数字进行交换
//如果一个函数不需要返回值，声明的时候可以写void
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;
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    swap(a, b);
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;

    //我们做值传递的时候，函数的形参发生改变，并不会影响实参。
    system("pause");
    return 0;
}
6.5函数的常见样式

常见的函数样式有4种

  1. 无参无返

  1. 有参无返

  1. 无参有返

  1. 有参有返 

#include<iostream>
using namespace std;
//常见的函数样式有4种
//1.无参无返
void test01()
{
    cout << "this is test 01" << endl;
}
//2.有参无返
void test02(int a)
{
    cout << "this is test 02" << endl;
}
//3.无参有返
int test03()
{
    cout << "this is test 03" << endl;
    return 1000;
}
//4.有参有返
int test04(int a)
{
    cout << "this is test04 a = " << a << endl;
    return a;
}
int main()
{
    //1.无参无返调用
    test01();
    //2.有参无返调用
    test02(100);
    //3.无参有返
    int num1 = test03();
    cout << "num1 = " << num1 << endl;
    //4.有参有返的函数调用
    int num2 = test04(10000);
    cout << "num2 = " << num2 << endl;
    system("pause");
    return 0;
}
6.6函数的声明

作用：告诉编译器函数名称及如何调用函数，函数的实际主体可以单独定义

函数的声明可以多次，但是函数的定义只有一次。

#include<iostream>
using namespace std;
//函数的声明
//比较函数，实现两个整形数字进行比较，返回较大的值
//提前告诉编译器函数的存在，可以利用函数的声明
//函数的声明
//声明可以写一次，但是定义只能写一次
int max(int a, int b);
int main()
{
    int a = 10;
    int b = 20;
    cout << max(a, b) << endl;
    system("pause");
    return 0;
}
int max(int a, int b)
{
    return a > b ? a : b;
}
6.7函数的分文件编写

作用：让代码结构更加清晰

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

  1. 创建后缀名为.h的头文件

  1. 创建后缀名为.cpp的源文件

  1. 在头文件中写函数的声明

  1. 在源文件中写函数的定义

这个需要自己看视频。来加强自己的认知。

七.指针
7.1指针的基本概念

指针的作用：可以通过指针直接访问内存

内存编号是从0开始记录的，一般用十六进制数字表示

可以利用指针变量保存地址

7.2指针变量的定义与使用

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

#include<iostream>
using namespace std;
int main()
{
    int a = 10;
    //1.定义指针的语法：数据类型*指针变量名；
    int* p;
    //让指针记录变量a的地址
    p = &a;
    cout << "a的地址为：" << &a << endl;
    cout << "指针p的地址为： " << p << endl;
    //2.使用指针
    //可以通过解引用的方式来找到指针指向的内存
    //指针前加 * 代表解引用，找到指针指向的内存中的数据
    *p = 1000;
    cout << "a = " << a << endl;
    cout << " *p " << *p << endl;
    system("pause");
    return 0;
}
7.3指针所占的内存空间

提问：指针也是种数据类型，那么这种数据类型占多少内存空间？

#include<iostream>
using namespace std;
int main()
{
    int a = 10;
    //int* p;
    //p = &a;
    int* p = &a;
    //在32位操作系统下，指针占用4个字节空间大小，不管是什么数据类型
    //在64位操作系统下，指针是占8个字节空间大小，不管在什么数据类型
    cout << "sizeof(int *) = " << sizeof(int*) << endl;//p和int*可以互换
    cout << "sizeof(float *) = " << sizeof(float*) << endl;
    cout << "sizeof(double *) = " << sizeof(double*) << endl;
    cout << "sizeof(char *) = " << sizeof(char*) << endl;    
    system("pause");
    return 0;
}
7.4空指针和野指针

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

用途：初始化指针变量

注意：空指针指向的内存是不可以访问的

#include<iostream>
using namespace std;
int main()
{
    //空指针
    //1.空指针用于给指针变量进行初始化
    int* p = NULL;
    //2.空指针是不可以进行访问的
    //0~255之间的内存编号是系统占用的，因此不可访问
    //*p = 100;
    system("pause");
    return 0;
}

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

#include<iostream>
using namespace std;
int main()
{
    //野指针
    //在程序中，尽量避免出现野指针
    int* p = (int *)0x1100;
    cout << *p << endl;
    system("pause");
    return 0;
}

总结：空指针和野指针都不是我们申请的空间，因此不要访问。

7.5const修饰指针

const修饰指针有三种情况：

  1. const修饰指针 ......常量指针

  1. Const修饰常量 ......指针常量

  1. Const既修饰指针，又修饰常量

#include<iostream>
using namespace std;
int main()
{
    //1、const修饰指针 常量指针
    int a = 10;
    int b = 10;
    const int* p = &a;
    //指针指向的值不可以更改，指针的指向可以改 
    //*p = 20;错误
    p = &b;//正确
    //2、Const修饰常量 
    int* const p2 = &a;
    //指针的指向不可以改，指针指向的值可以改
    *p2 = 20;//正确
    //p2 = &b;错误
    //3、Const既修饰指针，又修饰常量
    const int* const p3 = &a;
    //指针的指向和指针指向的值都不可以改
    //*p3 = 20;//错误
    //p3 = &b;错误
    system("pause");
    return 0;
}
7.6指针和数组

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

#include<iostream>
using namespace std;
int main()
{
    //指针和数组
    //利用指针访问数组中的元素
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    cout << "第一个元素为： " << arr[0] << endl;
    int* p = arr;//arr就是数组的首地址
    cout << "利用指针来访问第一个元素： " << *p << endl;
    p++;//让指针向后偏移4个字节
    cout << "利用指针来访问第二个元素： " << *p << endl; 
    //这里已经经过了p++，所以只要让*(p+1)即可访问第三个元素
    cout << "利用指针来访问第三个元素： " << *（p+1） << endl;
    cout << "利用指针遍历数组" << endl;
    int* p2 = arr;
    for (int i = 0; i < 10; i++)
    {
        //cout << arr[i] << endl;
        cout << *p2 << endl;
        p2++;
    }
    system("pause");
    return 0;
}
7.7指针和函数

作用：利用指针作函数参数，可以修改实参的值

#include<iostream>
using namespace std;
//实现两个数字进行交换
void swap01(int a, int b)
{
    int temp = a;
    a = b;
    b = temp;
    cout << "swap01 a= " << a << endl;
    cout << "swap02 b= " << b << endl;
}
void swap02(int* p1, int* p2)
{
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}
int main()
{
    //指针和函数
    //1、值传递   值传递不会改变实参
    int a = 10;
    int b = 20;
    //swap01(a, b);
    swap02(&a, &b);
    cout << "a= " << a << endl;
    cout << "b= " << b << endl;
    //2、地址传递  地址传递会改变实参
    //如果是地址传递，可以修饰实参
    system("pause");
    return 0;
}
7.8指针，数组，函数

案例描述：封装一个函数，利用冒泡排序，实现对整型数组的升序排序

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

#include<iostream>
using namespace std;
//冒泡排序函数 参数1 数组的首地址  参数2 数组长度
void bubblesort(int *arr,int len)
{
    for (int i = 0; i < len - 1; i++)
    {
        for (int j = 0; j < len - i - 1;j++)
        {
            //如果j>j+1的值  交换数字
            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()
{
    //1、先创建数组
    int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
    //数组长度
    int len = sizeof(arr) / sizeof(arr[0]);
    //2、创建函数，实现冒泡排序
    bubblesort(arr, len);
    //3、打印排序后的数组
    printArray(arr, len);
    system("pause");
    return 0;
}
八.结构体
8.1结构体的基本概念

结构体属于用户自定义的数据类型，允许用户存储不同的数据类型

8.2结构体定义和使用

语法：struct 结构体名 {结构体成员列表};

通过结构体创建变量的方式有三种：

struct 结构体 变量名

struct 结构体名 变量名={成员1值，成员2值....}

定义结构时顺便创建变量

#include<iostream>
using namespace std;
#include<string>
//1、创建学生的数据类型：学生包括（姓名，年龄，分数）
//自定义数据类型，一些类型集合组成的一个类型
//语法 struct 类型名称 {成员列表}
struct student
{
    //成员列表

    //姓名
    string name;
    //年龄
    int age;
    //分数
    int score;
}s3;//顺便创建一个结构体变量
//2、通过学生类型创建具体学生
int main()
{
    //struct的关键字可以省略，上面那个struct不可以省略
    //2.1 struct student s1
    struct student s1;
    //通过.来访问结构体变量中的属性
    s1.name = "张三";
    s1.age = 18;
    s1.score = 100;
    cout << "姓名 " << s1.name << "年龄 " << s1.age << "分数 " << s1.score << endl;
    //2.2 struct student s2={......}
    struct student s2 = { "李四",19,80 };
    cout << "姓名 " << s2.name << "年龄 " << s2.age << "分数 " << s2.score << endl;
    //2.3 在定义结构体时，顺便创建结构体变量
    s3.name = "王五";
    s3.age = 20;
    s3.score = 60;
    cout << "姓名 " << s3.name << "年龄 " << s3.age << "分数 " << s3.score << endl;
    system("pause");
    return 0;
}
8.3结构体数组

作用：将自定义额结构放入到数组中方便维护

语法：struct 结构体名 数组名{元素个数}={ {},{}......}

#include<iostream>
using namespace std;
#include<string>
//结构体数组
//1、定义结构体
struct Student
{
    //姓名
    string name;
    //年龄
    int age;
    //分数
    int score;
};
int main()
{
    //2、创建结构体数组
    struct Student stuArray[3] =
    {
        {"张三",18,100},
        {"李四",28,99},
        {"王五",38,66}
    };
    //3、给结构体中的元素赋值
    stuArray[2].name = "赵六";
    stuArray[2].age = 80;
    stuArray[2].score = 60;
    //4、遍历结构体数组
    for (int i = 0; i < 3; i++)
    {
        cout << "姓名 " << stuArray[i].name << "年龄 " << stuArray[i].age << "分数 " << stuArray[i].score << endl;
    }
    system("pause");
    return 0;
}
8.4结构体指针

作用：通过指针访问结构体中的成员

利用操作符->可以通过结构体指针访问结构体属性

#include<iostream>
using namespace std;
#include<string>
//结构体指针
//定义学生的结构体
struct student
{
    
    string name;//姓名
    int age;    //年龄
    int scoer;  //分数
};
int main()
{
    //1、创建学生的结构体变量
    struct student s = { "张三",18,100 };
    //2、通过指针指向结构体变量
    struct student* p = &s;     //struct可以省略
    //3、通过指针访问结构体变量中的数据
    cout << "姓名 " << p->name << "年龄 " << p->age << "分数 " << endl;
    system("pause");
    return 0;
}
8.5结构体嵌套结构体

作用：结构体中的成员可以是另外一个结构体

例如：每个老师辅导一个学员，一个老师的结构体中，记录一个学生的结构体

#include<iostream>
using namespace std;
#include<string>
//定义学生的结构体
struct student
{
    string name; //姓名
    int age;     //年龄
    int score;   //分数
};
//定义一个老师的结构体
struct teacher
{
    int id;        //教师编号
    string name;   //教师姓名
    int age;       //教师年龄
    struct student stu;   //辅导的学生
};
int main()
{
    //结构体嵌套结构
    //创建老师
    teacher t;
    t.id = 10000;
    t.name = "老王";
    t.age = 50;

    t.stu.name = "小王";
    t.stu.age = 20;
    t.stu.score = 60;
    cout << "老师的姓名 " << t.name << "老师的编号 " << t.id << "老师的年龄 " << t.age
        << "老师辅导的学生姓名： " << t.stu.name << "学生的年龄： " << t.stu.age
        << "学生的成绩： " << t.stu.score << endl;
    system("pause");
    return 0;
}
8.6结构体做参数函数

作用：将结构体作为参数向函数中传递

传递方式有两种：

值传递

地址传递

#include<iostream>
using namespace std;
#include<string>
struct student
{
    string name; //姓名
    int age;     //年龄
    int score;   //分数
};
//打印学生信息函数
//1、值传递
void printStudent1(struct student s)
{
    s.age = 100; //更改之后main函数中值不变
    cout << "子函数中  姓名：" << s.name << "年龄：" << s.age << "分数：" << s.score << endl;
}
//2、地址传递
void printStudent2(struct student* p)
{
    p->age = 200;//更改之后main函数中值变化
    cout << "子函数2中 姓名：" << p->name << "年龄：" << p->age << "分数：" << p->score << endl;
}
int main()
{
    //结构体做函数参数
    //将学生传入到一个函数中，打印学生身上的所有信息
    //创建结构体变量
    struct student s;
    s.name = "张三";
    s.age = 20;
    s.score = 80;
    //cout << "main函数中打印 姓名：" << s.name << "年龄：" << s.age << "分数：" << s.score << endl;
    printStudent1(s);
    printStudent2(&s);
    cout << "在main函数中  姓名：" << s.name << "年龄：" << s.age << "分数：" << s.score << endl;
    system("pause");
    return 0;
}
8.7结构体中const的使用场景

作用：用const来防止误操作

#include<iostream>
using namespace std;
#include<string>
//const的使用场景
struct student
{
    //姓名
    string name;
    //年龄
    int age;
    //分数
    int scoer;
};
//将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来
void printStudent(const student *s)
{
    //s->age = 50; 加入const后，一旦有修改的操作就会报错，可以防止我们的误操作
    cout << "姓名：" << s->name << "年龄：" << s->age << "分数：" << s->scoer << endl;
}
int main()
{
    //创建结构体变量
    struct student s = { "张三",16,70 };
    //通过函数来打印结构体变量信息
    printStudent(&s);
    cout << "在main函数中张三的年龄为：" << s.age << endl;
    system("pause");
    return 0;
}
8.8结构体案例

案例1

案例描述：

学校正在做毕设项目，每名老师带领5个学生，总共有3名老师，需求如下

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

学生的成员有姓名，考试分数，创建数组存放3名老师，通过函数给每位老师及所带的学生赋值，最终打印出老师数据以及老师所带学生的数据

#include<iostream>
using namespace std;
#include<string>
#include<Ctime>
//学生的结构体
struct Student
{
    //姓名
    string sName;
    //分数
    int score;
};
//老师的结构体的定义
struct Teacher
{
    //姓名
    string tName;
    //学生数组
    struct Student sArray[5];
};
//给老师和学生赋值的函数值
void allocateSpace(struct Teacher tArray[],int len)
{
    string nameSeed = "ABCDE";
    //给老师开始赋值
    for (int i = 0; i < len; i++)
    {
        tArray[i].tName = "Teacher_";
        tArray[i].tName += nameSeed[i];
        //通过循环给每名老师所带的学生赋值
        for (int j = 0; j < 5; j++)
        {
            tArray[i].sArray[j].sName = "Student_";
            tArray[i].sArray[j].sName += nameSeed[j];

            int random = rand() % 61+40;   //40~100
            tArray[i].sArray[j].score = random;
        }
    }
}
//打印所有信息
void printInfo(struct Teacher tArray[],int len)
{
    for (int i = 0; i < len; i++)
    {
        cout << "老师的姓名  " << tArray[i].tName << endl;
        for (int j = 0; j < 5; j++)
        {
            cout << "\t学生的姓名为：" << tArray[i].sArray[j].sName << "成绩为："
                << tArray[i].sArray[j].score << endl;
        }
    }
}
int main()
{
    //随机数种子
    srand((unsigned int)time(NULL));
    //1.创建三名老师的数组
    struct Teacher tArray[3];
    //2.通过函数给三名老师的信息赋值，并给老师带的学生信息赋值
    int len = sizeof(tArray) / sizeof(tArray[0]);
    allocateSpace(tArray, len);
    //3.打印所有老师及所带学生信息
    printInfo(tArray, len);
    system("pause");
    return 0;
}

案例2

案例描述：

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

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

五名英雄信息如下：

{"刘备",23,"男"},

{"关羽",22,"男"},

{"张飞",20,"男"},

{"赵云",21,"男"},

{"貂蝉",19,"女"}.

#include<iostream>
using namespace std;
#include<string>
//1.创建英雄的结构体
struct Hero
{
    //姓名
    string name;
    //年龄
    int age;
    //性别
    string sex;
};
//冒泡排序 实现年龄升序
//void bubbleSort(struct Hero heroArray[], int len)
//{
//    for (int i = 0; i < len - 1; i++)
//    {
//        for (int j = 0; j < len - i - 1; j++)
//        {
//            if (heroArray[j].age > heroArray[j + 1].age)
//            {
//                int temp = heroArray[j].age;
//                heroArray[j].age = heroArray[j + 1].age;
//                heroArray[j + 1].age = temp;
//            }
//        }
//    }
//}
void bubbleSort(struct Hero heroArray[], int len)
{
    for (int i = 0; i < len - 1; i++)
    {
        for (int j = 0; j < len - i - 1; j++)
        {
            if (heroArray[j].age > heroArray[j + 1].age)
            {
                struct Hero temp = heroArray[j];
                heroArray[j] = heroArray[j + 1];
                heroArray[j + 1] = temp;
            }
        }
    }
}
//打印排序后的输出信息
void printSort(struct Hero heroArray[], int len)
{
    for (int i = 0; i < len; i++)
    {
        cout << "姓名 " << heroArray[i].name << "年龄 " << heroArray[i].age
            << "性别 " << heroArray[i].sex << endl;
    }
}
int main()
{
    //2.创建一个数组存放五名英雄
    struct Hero heroArray[5] =
    {
        {"刘备",23,"男"},
        {"关羽",22,"男"},
        {"张飞",20,"男"},
        {"赵云",21,"男"},
        {"貂蝉",19,"女"},
    };
    int len = sizeof(heroArray) / sizeof(heroArray[0]);
    /*for(int i = 0; i < len; i++)
    {
        cout << "姓名 " << heroArray[i].name << "年龄 " << heroArray[i].age
            << "性别 " << heroArray[i].sex << endl;
    }*/
    //3.对数组进行排序，按照年龄进行升序排序
    bubbleSort(heroArray,len);
    //4.排序后的结果打印输出
    printSort(heroArray, len);

    
    system("pause");
    return 0;
}
1个程序源
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++入门学习（黑马程序员课程讲义）——第二阶段
qq_49850649的博客
02-25 9278
黑马程序员C++核心编程课程学习笔记
C++泛型函数学习
hkk1151043545的博客
04-14 3720
1 模板 1.1 模板的概念 1.2 函数模板 1.2.1 函数模板语法 1.2.3 函数模板案例 1.2.4 普通函数与函数模板的区别 1.2.5 普通函数与函数模板的调用规则–可以发送函数重载 1.2.6 模板的局限性 1.3 类模板 1.3.1 类模板语法 1.3.3 类模板中成员函数创建时机 1.3.5 类模板与继承 C++提高编程 本阶段主要针对C++泛型编程和STL技术做详细讲解，探讨...
C++学习全记录（全）
qq_41918369的博客
04-03 1340
C++核心编程 本阶段主要针对C++面向对象编程技术做详细讲解，探讨C++中的核心和精髓。 1 内存分区模型 C++程序在执行时，将内存大方向划分为4个区域 代码区：存放函数体的二进制代码，由操作系统进行管理的 全局区：存放全局变量和静态变量以及常量 栈区：由编译器自动分配释放, 存放函数的参数值,局部变量等 堆区：由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收 内存四区意义： 不同区域存放的数据，赋予不同的生命周期, 给我们更大的灵活编程 1.1 程序运行前 ​ 在程序编译后，生成了ex
黑马程序员c++讲义课件笔记
热门推荐
weixin_48953899的博客
06-09 5万+
黑马程序员c++讲义课件笔记
【黑马之C++基础入门讲义】
sunshine_world的博客
07-30 1万+
C++基础入门 1 C++初识 1.1 第一个C++程序 编写一个C++程序总共分为4个步骤 创建项目 创建文件 编写代码 运行程序 1.1.1 创建项目 Visual Studio是我们用来编写C++程序的主要工具，我们先将它打开 1.1.2 创建文件 右键源文件，选择添加->新建项 给C++文件起个名称，然后点击添加即可。 1.1.3 编写代码 #include<iostream> using na..
第一阶段 黑马程序员C++基础入门
06-07
黑马程序员C++基础入门PDF
黑马程序员C++从0到1笔记教程-pdf带目录
05-07
有七个阶段：第1阶段C++ 匠心之作 从0到1入门，第2阶段实战-通讯录管理，第3阶段-C++核心编程 资料，第4阶段实战-基于多态的企业职工系统，第5阶段-C++提高编程资料，第6阶段实战-基于STL泛化编程的演讲比赛资料，第...
第二阶段 黑马程序员C++核心编程
最新发布
06-07
第二阶段 黑马程序员C++核心编程.md
黑马程序员，C++核心编程
04-17
黑马程序员，C++核心编程
传智播客旗下黑马程序员c++视频课程内部讲义
04-16
传智播客旗下黑马程序员c++视频课程内部讲义 就是上课时老师翻阅的那个讲义
c++入门，核心，提高讲义笔记
11-27
最详细的c++入门，核心，提高讲义笔记，看会成为大佬没问题，下载后有疑问请私信。
黑马程序员C++核心编程
weixin_73900785的博客
12-25 1083
作用：函数名可以相同，提高复用性同一个作用域下函数名相同函数类型不同或个数不同或顺序不同函数的返回值不可以作为函数重载的条件​//函数重载满足条件：​//+同一个作用域下//+ 函数名相同//+ 函数 类型不同 或 个数不同 或 顺序不同 * *​//都是全局作用域，函数名相同，cout
【C++】黑马程序员《C++从入门到精通》
浪里小飞侠的博客
10-15 2万+
黑马程序员《C++从入门到精通》--学习笔记第八部分：bug与思考01、iostream和iostream.h和stdio.h的区别02、#define和const的区别03、using names std 什么意思？04、数据类型的意义？第一部分：基础入门知识（1-71）01、课程安排02、C++书写helloworld03、程序的注释04、变量05、常量06、关键字07、标识符命名规则08、数据类型第二部分：通讯录管理系统（01-12）0102第三部分：C++进阶知识（01-64）0102第四部分：职工
C++基础入门
杰之行的博客
02-05 476
前言 本文对应的视频：《黑马程序员匠心之作|C++教程从0到1入门编程,学习编程不再难》 本科学过，但是没有做笔记的习惯，基本上是忘完了，用书查不太现实，特地将这个视频对应的笔记上传，希望对大家有用！ 第一阶 | | | |–|--| | | | 段：C++基础语法入门 对C++有初步了解，能够有基础编程能力（通讯录管理系统） 第二阶段：C++核心编程 C++核心编程，为大型项目做铺垫（职工管理系统） 第三阶段：C++提高编程 介绍C++泛型编程思想，以及STL的基本使用（演讲比赛系统） C++
C++黑马程序员教程-学习笔记一
阿叶叶的博客
07-08 1901
C++基础入门（黑马程序员） 视频来源：https://www.bilibili.com/video/BV1et411b73Z?p=72&spm_id_from=pageDriver&vd_source=88c0c0295ff9ec865f2a0901b402c92b
笔记 黑马程序员C++教程从0到1入门编程——基础语法入门
m0_58125693的博客
04-13 3030
1.C++初识 02 C++书写helloworld #include <iostream> using namespace std; int main() { cout << "hello world!" << endl; system("pause"); return 0; } 03 注释 1.单行注释 //描述信息 2.多行注释 /*描述信息*/ 04 变量 作用：给一段指定的内存空间起名，方便操作这段内存 数据类型 变量名=变量初始..
学习笔记：黑马程序员C++从0到1（1~2）
SEEK的博客
03-25 6655
学习笔记：黑马程序员C++从0到1（1~2） 1.C++基础 2.数据类型
哔哩哔哩黑马程序员C++课程个人学习笔记
weixin_53073284的博客
08-01 3525
此博文仅作为个人c++学习笔记记录，或有错误不建议参考！！！
黑马程序员C++基础入门教程：创建与运行
本资源是一份名为"C++基础入门.md"的文档，由黑马程序员团队精心制作，旨在为初学者提供C++语言的基础入门教程。文档详细介绍了C++编程的初步步骤，包括使用Visual Studio这个主流的开发工具进行开发。 1. **C++...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值