C++学习

c++
C++基础
发布日期:   2020-11-12
更新日期:   2021-01-30
文章字数:   4,865
阅读时长:   20 分
阅读次数:  

使用VS2017C++基础进行学习

C++入门

创建项目并运行第一个程序

创建项目->创建文件->编写程序->运行程序

创建项目(Visual C++)->空项目->填写项目名和项目存在的路径->源文件(右键创建一个cpp文件)

第一个c++程序(C++程序的Hello world程序)

#include 
using namespace std;
int main(){

    cout << "Hello,Xing" << endl;
    system("pause");
    return 0;
}

变量和常量

变量存在的意义：便于程序员管理内存

数据类型 变量名 = 变量初始值

例如 int a = 10;

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

c++定义常量的两种方式

方式1：

#define 宏常量： #define 常量名 常量值。

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

#define DAY 7

方式2：

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

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

const int num = 20;

关键字

在对变量或者常量进行命名是不能与标识符重复，编译器会报错。

asm do if return typedef
auto double inline short typeid
bool dynamic_cast int signed typename
break else long sizeof union
case enum mutable static unsigned
catch explicit namespace static_cast using
char export new struct virtual
class extern operator switch void
const false private template volatile
const_cast float protected this wchat_t
continue for public throw while
default friend register true
delete goto reinterpret_cate try

标识符命名规则

标识符(变量、常量)命名时，有一定的规则

标识符不能是关键字

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

标识符的第一个字符不能是数字开头，只能是数字或者下划线

标识符区分大小写

注：标识符命名是最好做到见名知意，命名为其表示的功能。

数据类型

为什么需要数据类型？

c++中变量需要有数据类型，否则在内存中无法对其进行内存分配，数据类型为了给变量分配合适的内存空间。

整型

c++中整型，占用空间如下：

数据类型 占用空间 取值范围
short(短整型) 2字节 -2^15~2^15-1
int(整型) 4字节 -2^31~2^31-1
long(长整型) windows为4字节，linux32为4字节，64位为8字节 -2^31~2^31-1
long long(长长整型) 8字节 -2^63~2^63-1 
#include 
using namespace std;
int main(){
    //短整型(-32768~32767)
    short num1 = 10;
    //整型
    int num2 = 10;
    //长整型
    long num3 = 10;
    //长长整型
    long long num4 = 10;
    return 0;
}

sizeof关键字

作用：利用sizeof关键字可以统计变量占用的内存空间

整数类型之间的关键字占用空间(short<int <= long <= long)

使用方式：

#include 
using namespace std;
int main(){
    short num1 = 10;
    cout << "短整型占用内存空间：" << sizeof(short) << endl;
    cout << "查看变量占用的内存空间" << sizeof(num1) << endl;
    return 0;
}

实型(浮点型)

浮点数分为两种，用于表示小数

单精度float

双精度double

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

数据类型 占用空间 有效数字范围
float 4字节 7位有效数字
double 8字节 15~16位有效数字 
#include 
using namespace std;

int main(){
    //单精度，在初始数据后添加f表示该数值为单精度，默认小数为双精度
    float f1 = 3.14f;
   //双精度，默认情况下，c++小数默认输出为6位有效数字
    double d1 = 3.1415926;
    //输出结果为3.14159
    cout<

字符型

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

char ch = ‘a’;

注意:在显示字符变量时，用单引号将字符括起来，不用双引号

注意：单引号内只能有一个字符，不可以是字符串

#include 
using namespace std;
//a  的ASCII97   A 的ASCII为65
int main() {
    //字符型变量创建方式
    char ch1 = 'A';
    cout << ch1 << endl;
    //字符型变量占用的空间大小
    cout << sizeof(ch1) << endl;
    //字符类型常见的错误
    //char ch2 = "A";
    //char ch3 = 'asda';
    //字符型变量对应的ASCII码
    cout << (int)ch1 << endl;
    system("pause");
    return  0;
}

转义字符

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

转义字符有\n、\\、\t(第12节课)

#include 
using namespace std;

int main() {
    //转义字符
    cout << "\n" << endl;
    //换行符
    cout << "Hello ， Xing" << endl;
    //反斜杠 
    cout << "打印一个反斜杠\\" << endl;
    //制表符 \t
    cout << "姓名\t年龄\t性别\t" << endl;
    cout << "星仔\t25\t男\t" << endl;
    system("pause");
    return  0;
}

字符串

作用：表示一串字符 需要引入头文件

#include

1.char 变量名[] = “字符串值”

2.string 变量名 = “字符串值”

//处理字符串
void handleString() {
    //c语言定义的字符串，使用字符数组表示，且字面量使用双引号包含起来
    char hello[] = "Hello xing";
    cout << hello << endl;
    //c++的字符串
    string hello2 = "you are my hero";
    cout<

布尔类型

作用：布尔数据类型表示逻辑的真或者假 只有两个值true、false

//布尔类型
void booleanDemo() {
    bool flag = true;
    //输出为1
    cout<

输入操作

cin

//从键盘录入数据 cin
void getString() {
    //获取整形
    /*int a = 0;
    cout<<"请给数据a赋值："<> a;
    cout <<"整数类型a = "<< a << endl;*/
    //获取浮点数
    float f = 3.14f;
    cout<<"请给浮点数f赋值"<> f;
    cout<<"字符型变量f = "<

运算符

运算符类型 作用
算数运算 处理四则运算
赋值运算 将表达式赋值给变量
比较运算 用于表达式的比较，返回一个真值或假值
逻辑运算 根据表达式返回真值或者假值

算数运算符

常用的算数运算，加、减、乘、除、取余、++、–等

运算符 术语 示例 结果
+ 正号 +2 2
- 负号 -3 -3
+ 加 1+2 3
- 减 3-1 2
* 乘 10*2 20
/ 除 10/2 5
% 取余(取模) 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

除法运算时，整数/整数结果为整数，除数不能为零(运行时异常)。浮点数进行除法运算，结果可以为小数。

取余运算时，除数不能为0，浮点数不可以做取模运算

示例程序：

//++和--
void jiajian() {
    //前置递增 先对变量进行+1操作，然后进行表达式运算
    int a = 2;
    int b = ++a * 10;
    cout << a << endl; //3
    cout << b << endl; //30
    //后置递增 先使用原先的值进行表达式计算，然后再将变量+1
    int c = 2;
    int d = c++ * 10;
    cout << c << endl; //3
    cout << d << endl; //20
    //前置递减
    int e = 2;
    int f = --e * 10;
    cout << e << endl; //1
    cout << f << endl; //10
    //后置递减
    int g = 2;
    int h = g-- * 10;
    cout << g << endl; //1
    cout << h << endl; //20
}

赋值运算符

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

运算符 术语 示例 结果
= 赋值 a=2;b=3 a=2;b=3
+= 加等于 a=2;a+=2 a=4
-= 减等于 a=2;a-=1 a=1
*= 乘等于 a=2;a*=2 a=4
/= 除等于 a=2;a/=2 a=1
%= 模等于 a=3;a%=2 a=1

示例程序：

//赋值运算符
void assignDemo() {
    int a = 10;
    a = 20;
    cout << a << endl;
    a += 10;
    cout << a << endl;
    a -= 10;
    cout << a << endl;
    a *= 2;
    cout << a << endl;
    a /= 3;
    cout << a << endl;
    a %= 2;
    cout << a << endl;
}

比较运算符

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

运算符 术语 示例 结果
== 相等于 4==3 0
！= 不等于 4！=3 1
< 小于 4<3 0
> 大于 4>3 1
<= 小于等于 4<=3 0
>= 大于等于 4>=3 1 
//比较运算符
void exchangeNum() {
    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;//1
    cout << (a >= b) << endl;//0
}

逻辑运算符

运算符 术语 示例 结果
! 非 !a 取反运算
&& 与 a&&b 有一个为假，结果为假
|| 或 a||b 有一个为真即为真

程序流程结构

顺序结构、选择结构、循环结构

顺序结构: 程序按顺序执行，不发生跳转

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

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

选择结构

if语句

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

单行格式if 多行格式if 多条件的if语句 if语句可以嵌套(if语句中含有if更精准的判断)

// 程序结构 选择结构 
void select() {
    //if语句
    int num = 0;
    cout << "请输入一个分数：" << endl;
    cin >> num;
    if (num > 80) {
        cout << "你的得分为："<< num <<"，优秀啊"<< endl;
    }else if (num>60) { 
        cout << "你的得分为：" << num <<"，及格了"<< endl;
    }else {
        cout << "您的得分过低，不予处理" << endl;
    }
}

简单的练习：

问题：输入三个数据，使用if语句判断三个数据中最大的数，并输出最大的数

void ifdemo() {
    int a = 0;
    int b = 0;
    int c = 0;
    cout << "请输入数字a,b,c" << endl;
    cin >> a;
    cin >> b;
    cin >>c ;
    if (a > b && a>c) {
        cout << "最大的数为a = " << a << endl;
    }
    else if (b > a && b > c) {
        cout << "最大的数为b = " << b << endl;
    }
    else {
        cout << "最大的数字为c = " << c << endl;
    }
}
三目运算符

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

//三目运算符
void threeDemo() {
    int a = 0;
    int b = 0;
    int c = 0;
    cout << "请输入数字a,b,c" << endl;
    cin >> a;
    cin >> b;
    cin >> c;
    int d = a > b ? (a>c?a:c):(b>c?b:c) ;
    cout << "a,b,c中的最大值为" << d << endl;
}
switch语句

执行多条件分支语句

switch(表达式){

case 结果1: 执行语句；break;

case 结果2: 执行语句；break;

…

default :执行语句;break;

}

//switch语句
void switchdemo() {
    int a = 0;
    cout << "请输入打分分数：" << endl;
    cin >> a;

    switch (a) {
        case 5:
            cout << "差评，您当前的评分为"<

switch与if区别：

switch结构清晰，执行速度快

if能够进行区间条件的判断，switch只能为整数或者字符类型

循环结构

作用：满足条件执行循环语句，重复执行语句直到满足条件

while循环：

示例练习(猜数字)：

//添加头文件
#include 
//while练习
void caiNum() {
    //添加一个时间种子，产生随机数
    srand((unsigned int) time(NULL));
    //1.生成一个随机数
    int num = rand() % 100+1;
    //2.进行猜测
    int a = 0;
    while (true) {
        cout << "请输入您猜测的数字：" << endl;
        cin >> a;
        //正确停止输出
        if (a == num) {
            cout << "恭喜您，猜中了！！！" << endl;
            break;
        }
        //猜错了继续猜测(提示大小关系)
        else if (a > num)cout << "哎呀，您猜大了！" << endl;
        else cout << "嘿嘿，您猜小了" << endl;
    }
}

do…while循环

do{

执行语句;

}while(循环条件);

do…while与while的区别

do…while至少执行一次，先执行循环体再进行判断

示例：水仙花数 一个数等于三个位数的立方和(153 = 1^3+5^3+3^3),利用do…while循环

//水仙花数 数字为100~999  153 370 371 407
void waterflower() {
    int num = 100;
    do {
        //获取一个数字的个位、十位、百位
        int a = num % 10;
        int b = num / 10 % 10;
        int c = num / 100;
        if (a*a*a+b*b*b+c*c*c == num) {
            cout<<"水仙花数是"<

for循环语句

语法结构：for (起始表达式;条件表达式;条件变换) {执行语句}

    //for循环
    for (int i = 10; i >= 0; i--)
    {
        cout << "开始输出i = " << i << endl;
    }

for循环练习：

void testFor() {
    for (int i = 1; i < 100;i++) {
        int a = i % 10;
        int b = i / 10 % 10;
        if (i % 7 == 0 || a == 7 || b == 7)cout<<"当前数字与7相关的有："<

嵌套循环

//嵌套循环
void qiantao() {
    //打印*图
    for (int i = 0; i < 10;i++) {
        for (int j = 0;j<10;j++) {
            cout << "*";
        }
        cout << endl;
    }
}

打印输出一个乘法口诀表

//打印乘法口诀表
void chengfakoujue() {
    for (int i = 1; i < 10;i++) {
        for (int j = 1; j <= i;j++) {
            cout << j<<"*"<

跳转语句

作用：跳转语句能够使得程序跳出选择或者循环语句

break语句

出现在switch中，跳出当前的case语句

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

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

continue语句

在循环语句中，跳出本次循环进行下一次的循环语句执行

可以使用continue挑选一些数字减少循环次数

goto语句(不推荐使用)

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

数组

一维数组

数组的定义方式

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

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

3.数据类型 数组名[] = { 值1，值2… }；

特点：数组为一片连续的内存空间、数组中的每一个元素都是同一个数据类型

//数组的遍历
void printArr(int num[], int arrSize) {
    for (int i = 0; i < arrSize; i++) {
        cout << num[i] << endl;
    }
}

//数组的使用
void testArray(){
    //数组的定义 方式1
    int numArr[10];
    for (int i = 0; i < 10;i++) {
        numArr[i] = i * 10;
    }
    //数组的定义 方式2
    int numArr2[5] = {1,2,5};
    //使用该方式进行数组初始值赋值，初始值为0
    for (int i = 0; i < 5; i++) {
        numArr2[i] = i * 10;
    }
    //数组的定义 方式3
    int numArr3[] = { 1,2,5 };
    //定义数组时，必须要有数组的长度
    for (int i = 0; i < 3; i++) {
        numArr3[i] = i * 10;
    }

    printArr(numArr3,3);
}

一维数组名的作用：

可以统计整个数组在内存中的长度

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

数组名的使用：

//使用数组名计算数组占用空间大小，数组元素占用的字节数，数组中的元素个数，数组的首地址以及各个元素的地址。
void arrayTest() {
    int num[] = {2,5,6,3,8,4,5,6};
    cout<<"数组占用的地址空间："<

示例：求数组中的最大元素

//获取数组中最大的元素
int getmax() {
    int num[] = { 2,5,6,3,8,4,5,6 };
    int len = sizeof(num) / sizeof(num[0]);
    cout << sizeof(num) << endl;
    cout << sizeof(num[0]) << endl;
    int max = 0;
    for (int i = 0; i < len;i++) {
        max = max > num[i] ? max:num[i] ;
    }
    return max;
}

问题:如果在函数中传入一个int num[]类型，然后进行计算sizeof(num)计算的结果不是数组的长度，而只是int类型的字节数4(具体原因待定)

冒泡排序

对数组内的所有元素进行排序

1.相邻元素进行比较，将大的数字向后置换

2.每一对相邻元素进行相同的比较，每次循环能够将最大的数移到最后面

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

//冒泡排序
void bubbleSort(){
    int num[] = {9,6,8,5,7,4,3,2,1};
    int len = sizeof(num) / sizeof(num[0]);
    for (int i = 0; i < len;i++) {
        for (int j = 1; j < len - i;j++) {
            if (num[j] < num[j - 1]) {
                int temp = num[j];
                num[j] = num[j - 1];
                num[j - 1] = temp;
            }
        }
    }
    for (int i = 0; i < len; i++) {
        cout << num[i] << " ";
    }
}

二维数组

四种定义方式：

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

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

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

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

//二维数组
void twoWei() {
    //数组定义方式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;
    //数组定义2
    int num[2][3] = 
    {
        {1,2,3},{4,5,6}
    };

    //数组定义3
    int arr2[2][3] = { 1,2,3,4,5,6 };
    //数组定义4
    int arr3[][3] = {1,2,3,4,5,6};
}

二维数组名的使用

用来查看占用内存空间的大小

用来查看二维数组的首地址

    //数组定义4
    int arr3[][3] = {1,2,3,4,5,6};

    cout << "占用的地址空间大小为" << sizeof(arr3) << endl;
    cout << "二维数组第一行占用的地址空间大小为" << sizeof(arr3[0]) << endl;
    cout << "二维数组第一个元素占用的地址空间大小为" << sizeof(arr3[0][0]) << endl;
    cout << "二维数组行数" << sizeof(arr3)/sizeof(arr3[0]) << endl;
    cout << "二维数组列数" << sizeof(arr3[0])/sizeof(arr3[0][0]) << endl;
    cout << "二维数组首地址" << (int) arr3 << endl;
    cout << "二维数组第一行的首地址" << (int)arr3[0] << endl;
    cout << "二维数组第一个元素的首地址" << (int)& arr3[0][0] << endl;

函数

将一段经常使用的代码封装起来，减少重读的代码。一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能。

函数定义

函数名、返回值类型、参数列表、函数体语句、return表达式

语法：

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

函数体语句;

return 表达式; //void类型的返回值，该语句可省略

}

值传递

值传递时，函数的形参发生改变，并不会影响实参

例如数据交换函数

void swap(int num1,int num2) {
    int temp = num1;
    num1 = num2;
    num2 = temp;
    return;
}
//a，b实参并不会改变
int main() {
    int a = 10;
    int b = 20;
    swap(a,b);
    system("pause");
    return  0;
}

函数常见的样式

无参无返、有参无返、无参有返、有参有返

void fun1(){ }

void fun2(int a){ }

int fun3(){ return 0; }

int fun4(int a){ return a; }

函数的声明

函数需要告诉编译器，该函数存在

函数的声明使用的是：返回值类型，函数名，参数，但是没有函数体。函数的声明在main函数之前。

注：函数的声明可以有多次，函数的实体只能够有一次

函数的分文件编写

函数份文件编写步骤:

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

2.创建后缀名为.CPP文件(源文件)

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

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

头文件(.h)

#include 
using namespace std;
void fun1();

源文件(.cpp)

int main() {
    fun1();
    system("pause");
    return  0;
}
void fun1() {
    cout << "源文件" << endl;
}

指针

作用：通过指针间接访问内存

内存编号是从0开始记录的，一般使用十六进制数字表示；可以利用指针变量保存地址

指针的定义和使用

指针变量的定义 数据类型 * 变量名;

//指针的定义与使用
void funprimary() {
    int a = 10;
    //指针的定义 数据类型 * 变量名;
    int * p;
    //指针变量的赋值操作
    p = &a;
    cout << &a << endl;
    cout << p << endl;
    //修改地址中的值
    *p = 100;
    cout << a << endl;
    cout << *p << endl;
}

指针占用的空间

32位操作系统中，指针占用的空间为4个字节，64位的操作系统，指针占用8个字节(无论什么样的数据类型)

sizeof(int *) 4

sizeof(double *) 4

空指针与野指针

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

用途：初始化指针变量

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

//空指针 指向编号为0的指针
    int * p = NULL;

野指针

指针变量指向非法(未申请)的地址空间

int* p = (int *)0x1100;
cout << *p << endl;

const修饰指针(常量指针)

常量指针(const修饰指针)：指针的指向可以修改，指针指向的值不可以修改

const int *p;

指针常量(const修饰变量)：指针的指向不能够修改，指针指向的值可以修改

int* const p ;

const修饰指针和常量：指针指向的值不能够修改，指针指向的值也不能修改

const int * const p;

void constpoint() {
    int  a = 10;
    int b = 20;
    //常量指针 可以修改指向，不能修改值
    const int* p = &a;
    //*p = 20;不能修改
    p = &b;
    //指针常量 不可以修改指向，可以修改值
    int * const p2 = &a;
    *p2 = 20;

    //const都修饰 指针指向和指向的值都不可修改
    const int * const p3 = &a;
}

指针与数组

//使用指针访问数组
void pointArr() {
    int arr[] = {2,3,5,6,9,8,7,4};
    int * pin = arr;
    cout << "使用指针遍历数组" << endl;
    for (int i = 0; i

指针域函数

指针传递地址

将两个变量对应地址的值进行交换：

void swapNum(int* add1,int* add2) {
    int temp = *add1;
    *add1 = *add2;
    *add2 = temp;
}

int main() {
    int a = 10;
    int b = 20;
    swapNum(&a,&b);
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    system("pause");
    return  0;
}

数组、指针、函数

抽象一个函数，传入的参数为数组的指针和数组长度，利用冒泡排序对数组重排

void bubblesort2(int* num,int len) {
    for (int i = 0; i < len;i++) {
        for (int j = 1;j < len-i;j++) {
            if (num[j]

结构体(类似于Java中的类)

结构体定义和使用

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

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

通过结构体创建变量的方式:

struct 结构体名 变量名;

struct 结构体名 变量名 = { 成员1值 , 成员2值… }

定义结构体时顺便创建变量

#include 
#include 
using namespace std;

//1.自定义数据类型
struct Student {
    //成员列表:姓名、年龄、分数
    string name;
    int age;
    int score;
} s3;
//2.使用自定义结构体
void useStruct() {
    //2.1 struct Student s1
    struct Student s1;
    s1.name = "张三";
    s1.age = 25;
    s1.score = 80;
    cout << "当前的用户信息" << s1.name <<" 年龄 "<< s1.age <<" 得分： "<< s1.score << endl;
    //2.2 struct Stident s2={...};
    struct Student s2 = {"李四",26,87};
    //2.3定义结构体时创建一个具体的值(不推荐使用)
    s3.name = "王五";
}
int main() {
    useStruct();
    system("pause");
    return 0;
}

结构体数组

将自定义的结构体放入数组中方便进行维护

语法：struct 结构体名 数组名[个数] = { { }，{ }，{ } }；

示例：

#include 
#include 
using namespace std;

//1.自定义数据类型
struct Student {
    //成员列表:姓名、年龄、分数
    string name;
    int age;
    int score;
};
int main() {
    //结构体数组
    Student students[5] = { {"赵",25,78},{"钱",26,88},{"孙",30,77},{"李",24,98},{"周",25,97} };
    for (int i = 0; i < 5;i++) {
        cout << "姓名"<

结构体指针

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

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

#include 
#include 
using namespace std;

//1.自定义数据类型
struct Student {
    //成员列表:姓名、年龄、分数
    string name;
    int age;
    int score;
};
//结构体指针
void pointStruct() {
    //定义结构体变量
    Student s1 = {"王二牛",18,80};
    //创建一个结构体指针
    Student * p = &s1;
    //使用->进行对结构体成员的访问
    cout << "姓名：" << p->name << "年龄：" << p->age << "分数：" << p->score << endl;
}
int main() {
    pointStruct();
    system("pause");
    return 0;
}

结构体嵌套结构体

结构体嵌套结构体相当于类间的关系

例如：每个老师的类型会知道自己的学生信息

struct Student {
    //成员列表:姓名、年龄、分数
    string name;
    int age;
    int score;
};

struct Teacher {
    int id;
    string name;
    int age;
    Student stu;
};

结构体作为函数的参数

将结构体作为函数参数时传递有两种方式：值传递、地址传递

#include 
#include 
using namespace std;

struct Student {
    //成员列表:姓名、年龄、分数
    string name;
    int age;
    int score;
};
//将结构体作为函数的参数传递 值传递
//值传递对变量赋值并不会改变父函数中的变量值
void function(Student stu) {
    cout << stu.name << stu.age << stu.score << endl;
    stu.name = "haha";
}

//结构体作为参数进行传递，地址传递
//地址传递修改主函数中的变量
void function2(struct Student* stu) {
    cout << stu->name << stu->age << stu->score << endl;
    stu->name = "heihei";
}
//主函数
int main() {
    Student stu = {"星仔",25,86};
    //function(stu);
    function2(&stu);
    cout << stu.name << stu.age << stu.score << endl;
    system("pause");
    return 0;
}

结构体中使用const

使用const防止误操作

//结构体使用const  表示该函数不能修改传递的值
void constStruct(const Student * stu) {
    //s->age = 25;不允许更改
}

结构体示例

问题1需求

设计两个结构体，一个为老师结构体，一个为学生结构体，每个老师带领5个学生，一共有3名老师。学生有学生姓名、考试分数，创建数组存放3名老师，通过函数给每个老师以及所带的学生赋值，最后打印老师的数据以及老师所带学生的数据。

#include 
#include 
#include 
using namespace std;
//设计学生、老师结构体
struct student {
    string name;
    int score;
};
struct teacher {
    string name;
    struct student stu[5];
};
//给老师进行赋值，并对其学生进行赋值
void insertNum(teacher* teach,int len) {
    string seedName = "ABCDE";
    for (int i = 0; i < len;i++) {
        teach[i].name = "teacher_";
        teach[i].name += seedName[i];
        for (int j = 0; j < 5;j++) {
            teach[i].stu[j].name = "Student_" ;
            teach[i].stu[j].name += seedName[j];
            int random = rand() % 60 + 40;

            teach[i].stu[j].score = random;
        }
    }
}
//输出老师信息以及学生信息
void printNum(struct teacher teach[],int len) {
    for (int i = 0; i < len;i++) {
        cout << "老师姓名" << teach[i].name << endl;
        for (int j = 0; j < 5;j++) {
            cout << "\t学生姓名：" << teach[i].stu[j].name << "学生分数:" << teach[i].stu[j].score << endl;
        }
        cout << endl;
    }
}

int main() {
    srand((unsigned int)time(NULL));
    teacher teach[3];
    insertNum(teach,3);
    printNum(teach,3);
    system("pause");
    return 0;
}

问题2问题描述

设计一个英雄的结构体，包括成员姓名，年龄，性别;创建结构体数组，数组中存放5名英雄。通过冒泡排序对5名英雄按照年龄进行排序，输出最后的结果。(71课结束)

#include 
#include 
#include 
using namespace std;
//英雄结构体定义
struct Legend {
    string name;
    int age;
    string sex;
};
//排序
void sortLegend(Legend * lengends,int len) {
    for (int i = 0; i < len; i++) {
        for (int j = 1; j
文章作者: it星
文章链接: https://github.com/fengyanxing/2020/11/12/c-ji-chu/
版权声明: 本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源 it星 !
c++
赏
 上一篇
软件工程设计 软件工程设计
it星
软件工程软件生命周期 软件的生命周期又称为软件的生存周期或系统开发生命周期，是指从软件的产生直到报废的整个过程，它包括问题定义、可行性分析、总体描述、系统设计、编码、调试和测试、验收与运行、维护升级与报废等阶段。每一个阶段都有确定的任务，并
2020-12-19 工程建模
面向对象技术
下一篇 
Ros仿真系统 Ros仿真系统
Ros的安装Ubuntu安装地址 本次环境：Ubuntu16.04+ROS Kinetic版本 安装成功后，测试命令 roscore 安装成功后，下载编译工具： sudo wget https://github.com/Tony
2020-10-25 仿真系统
Ros操作系统
  目录
Copyright © 2020 it星 | Powered by Hexo | Theme Matery
  站点总字数: 171.8k 字 |  总访问量:  次 |  总访问人数:  人
载入运行时间...