using namespac_c++基础 csdn">
当前位置:   article > 正文

C++——基础知识入门_c++基础 csdn

c++基础 csdn

1.初识C++

1.1第一个C++程序

创建新项目,选择创建C++的空项目:
在这里插入图片描述
选择项目名称与位置:
在这里插入图片描述
在源文件中添加C++文件:
在这里插入图片描述
在这里插入图片描述

# include <iostream>
using namespace std;

int main()
{
	// 不换行
	cout << "hello world" ;
	// 换行,换行加个 << endl
	cout << "hello world" << endl;
	// 所以说,这个就是单纯的换行
	cout << endl;

	system("pause");

	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

1.2注释

# include <iostream>
using namespace std;

// 1.单行注释

/*
多行注释
*/

int main()
{

	cout << "hello world" << endl;

	system("pause");

	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

1.3变量和常量

就是给一个指定的空间起名,方便操作这个空间。
创建变量:数据类型 变量名 = 变量初始值;

常量:记录程序中不可更改的数据
定义常量的方法:

  • # define 宏常量:# 常量名 常量值
    • 通常在文件上方定义,表示一个常量。
  • const修饰的变量:const 数据类型 常量名 = 常量值
    • 通常在变量定义前加关键字const,修饰该变量为常量,不可修改。
# include <iostream>
using namespace std;

# define Weekday 7

int main()
{

	const int a = 10;

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

	cout << "一周有:" << Weekday << "天" << endl;


	system("pause");

	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

1.4关键字

C++中预先保留的单词,定义变量或者常量的时候不可以使用
在这里插入图片描述

1.5标识符命名规则

  • 标识符不能是关键字
  • 标识符只能由字母、数字、下划线组成
  • 第一个字符必须为字母或者下划线
  • 标识符中字母区分大小写
  • 最好可以通过标识符知道它的含义

2.数据类型

数据类型存在的意义: 给变量分配一个合适的内存空间。

科学计数法:

  • 3e2:3 * 102
  • 3e-2:3 * 0.12

2.1整形

数据类型占用空间取值范围
short(短整型)2字节(-215 ~ 215-1 )
int(整形)4字节(-231 ~ 231-1 )
long(长整形)Windows为4字节,Linux为4字节(32位),8字节(64位)(-231 ~ 231-1 )
long long(长长整形)8字节(-263 ~ 263-1 )

2.2sizeof关键字

统计数据类型所占内存大小

2.3实型(浮点型)

数据类型占用空间有效数字范围
float(单精度)4字节7位有效数字
double(双精度)8字节15~16位有效数字

2.4字符型

用于表示单个字母

  • 字符型变量只占一个字节。
  • 字符型变量并不是把字符本身放到内存中存储,而是将对应的ASCII编码放到存储单元。
# include <iostream>
using namespace std;

int main()
{
	char ch = 'a';

	cout << ch << endl;
	cout << sizeof(ch) << endl;
	/*
	a
	1
	*/
	// 字符型变量对应的ASCII编码
	// a 97
	// A 65
	cout << (int)ch << endl;
	// 97
	// 可以通过ASCII给字符型变量赋值
	char ch2 = 98;
	cout << ch2 << endl;
	// b

	system("pause");

	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

常见错误:

  • 使用双引号:char ch = “a”;
  • 单引号内放多个字符:char ch = ‘asd’;

ASCII码表

  • ASCII非打印控制字符:ASCII表上的数字0~31分配给了控制字符,用于控制外围设备。
  • ASCII打印字符:数字32~126分配给了能在键盘上找到的字符,当查看或打印文档时就会出现。
ASCII值控制字符ASCII值字符ASCII值字符ASCII值字符
0NUT32(space)64@96`
1SOH33!65A97a
2STX34"66B98b
3ETX35#67C99c
4EOT36$68D100d
5ENQ37%69E101e
6ACK38&70F102f
7BEL3971G103g
8BS4072H104h
9HT4173I105i
10LF42*74J106j
11VT43+75K107k
12FF44,76L108l
13CR45-77M109m
14SO46.78N110n
15SI47/79O111o
16DLE48080P112p
17DC149181Q113q
18DC250282R114r
19DC351383S115s
20DC452484T116t
21NAK53585U117u
22SYN54686V118v
23TB55787W119w
24CAN56888X120x
25EM57989Y121y
26SUB5890Z122z
27ESC5991[123{
28FS60<92\124|
29GS61=93]125}
30RS62>94^126~
31US63?95-127DEL

2.5转义字符

作用: 用于显示一些不能直接表示出来的ASCII字符。

转义字符含义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范围09af,A~F3位8进制

2.6字符串型

表示一串字符

  • 数组风格字符串:char 变量名[] = “字符串值”;
  • C++风格字符串:string 变量名 = “字符串值”;(需要有一个头文件:# include < string >)

2.7布尔类型bool

代表真或者假的值
只有两个值:

  • true:代表真
  • false:代表假

他们本质上就是0或者1,bool类型就占1个字节大小。

2.8数据的输入

从键盘获取数据
关键字:cin

# include <iostream>
using namespace std;

int main()
{
	// 1.整形
	int a = 0;
	cout << "请给整型变量a赋值:" << endl;
	cin >> a;
	cout << "整型变量 a = " << a << endl;

	// 2.浮点型
	float f = 3.14f;
	cout << "请给浮点型变量f赋值:" << endl;
	cin >> f;
	cout << "整型变量 f = " << f << endl;
	
	// 3.字符型
	char ch = 'a';
	cout << "请给字符型变量ch赋值:" << endl;
	cin >> ch;
	cout << "整型变量 ch = " << ch << endl;
	
	system("pause");

	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

3.运算符

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

3.1算数运算符

运算符术语解释
+正号符号
-负号符号
+
-
*
/
%取模(取余)取余数(两个小数是不能取模的)
++前置递增先加一,后表达式的运算
++后置递增先表达式的运算,后加一
前置递减同上
后置递减同上

3.2赋值运算符

运算符术语
=赋值
+=加等于
-=减等于
*=乘等于
/=除等于
%=模等于

3.3比较运算符

运算符术语
==等等于
!=不等于
>大于
<小于
>=大于等于
<=小于等于

3.4逻辑运算符

运算符术语
||
&&

4.程序流程结构

4.1选择结构

4.1.1if语句

# include <iostream>
using namespace std;

int main()
{

	int score = 0;

	cout << "请输入您的分数:" << endl;
	cin >> score;
	// 单行if语句:if(条件) {条件满足执行的语句}
	if(score>=60){
		cout << "您及格了" << endl;
	}
	
	// 多行if语句:if(条件) {条件满足执行的语句} else {条件未满足执行的语句}
	if(score>=60){
		cout << "您及格了" << endl;
	}else{
		cout << "您未及格" << endl;
	}
	
	// 多条件的if语句:if(条件1) {条件1满足执行的语句} else if (条件2) {条件2满足执行的语句}...... else {所有条件都未满足执行的语句}
	if(score>=90)
	{
		cout << "成绩优秀" << endl;
	}
	else if(score>=60)
	{
		cout << "成绩及格" << endl;
	}
	else
	{
		cout << "未及格" << endl;
	}
	
	// 嵌套if语句:if(条件1) {if(条件2){if(条件3){}}}
	if(score>=60)
	{
		cout << "成绩及格" << endl;
		if(score>=90)
		{
			cout << "成绩优秀" << endl;
		}
	}
	else
	{
		cout << "未及格" << endl;
	}


	system("pause");

	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55

4.1.2三目运算符

# include <iostream>
using namespace std;

int main()
{

	// 表达式1?表达式2:表达式3;
	// 如果表达式1为真则执行表达式2,否则执行表达式3
	// 输出最大数
	int a = 10;
	int b = 20;
	int max = a>b?a:b;
	cout << max << endl;

	system("pause");

	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

4.1.3switch语句

# include <iostream>
using namespace std;

int main()
{

	// 多条件分支语句
	/*
	switch(表达式)
	{
		case 结果1:
			执行语句;
			break;
		case 结果2:
			执行语句;
			break;
		case 结果3:
			执行语句;
			break;
		case 结果4:
			执行语句;
			break;
		...
		default:执行语句;break;
	}
	*/

	system("pause");

	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

4.2循环结构

系统生成随机数:

//time系统时间头文件
# include <ctime>

// 添加随机数种子,利用当前系统时间生成随机数,防止每次随机数都一样。
srand((unsigned int)time(NULL));

rand() % 100 + 1;
// rand() 生成随机数
// rand() % 100 生成 0 ~ 99 的随机数
// rand() % 100 + 1 生成 1 ~ 100 的随机数
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

4.2.1while循环语句

# include <iostream>
using namespace std;

int main()
{
	/*
	while(循环条件)
	{
		循环语句
	}
	*/

	system("pause");

	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

4.2.2do…while循环语句

# include <iostream>
using namespace std;

int main()
{
	/*
	先执行一遍循环语句,再进行判断循环。
	do
	{
		循环语句;
	}
	while(循环条件);
	*/

	system("pause");

	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

4.2.3for循环语句

# include <iostream>
using namespace std;

int main()
{
	/*
	for(起始表达式;条件表达式;末尾循环体)
	{
		循环语句;
	}
	*/

	system("pause");

	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

4.2.4嵌套循环

# include <iostream>
using namespace std;

int main()
{
	/*
	for(起始表达式;条件表达式;末尾循环体)
	{
		循环语句;
		for(起始表达式;条件表达式;末尾循环体)
		{
			循环语句;
		}
	}
	*/

	system("pause");

	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

4.3跳转语句

4.3.1break语句

跳出选择结构或循环结构

  • 出现swith语句中,作用是终止case并跳出switch
  • 出现再循环语句中,作用是跳出当前的循环语句
  • 出现在嵌套循环中,作用是跳出最近的内层循环语句

4.3.2continue语句

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

4.3.3goto语句

不推荐使用

# include <iostream>
using namespace std;

int main()
{
	/*
	作用:无条件跳转
	用法:goto 标记;  执行到goto语句时,如果标记的名称存在,会跳转到标记的位置。
	*/
	cout << "第一个" << endl;
	goto FLAG;
	cout << "第二个" << endl;
	cout << "第三个" << endl;
	FLAG:
	cout << "第四个" << endl;
	cout << "第五个" << endl;
	cout << "第六个" << endl;

	system("pause");

	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

5.数组

数组就是里面放着相同元素的一个集合
特点:

  • 数组中每个数据元素都是相同的数据类型。
  • 数组是由连续的内存位置组成的。

5.1一维数组

数组的定义
  1. 数据类型 数组名[数组长度];
  2. 数据类型 数组名[数组长度] = {值1,值2…};
  3. 数据类型 数组名[] = {值1,值2…};
数组名的用途
  • 可以统计整个数组在内存中的长度。
    • sizeof(数组名);
  • 可以获取数组在内存中的首地址。
    • (int)数组名:这样输出十进制的首地址。
    • 数组名:这样输出十六进制的首地址。
    • (int)&数组名[0]:数组中第一个元素的地址,第一个元素的地址就是数组的首地址。
  • 数组名是常量,不可以进行赋值操作。

5.2二维数组

数组的定义(推荐使用第二种
  1. 数据类型 数组名[行数][列数];
  2. 数据类型 数组名[行数][列数] = {{值11,值12…},{值21,值22…}…};
  3. 数据类型 数组名[行数][列数] = {值1,值2,值3,值4,值5…};
  4. 数据类型 数组名[][列数] = {值1,值2,值3,值4,值5…};
数组名的用途
  • 查看二维数组所占内存空间
  • 获取二维数组首地址

6.函数

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

6.1函数的定义

/*
语法:
返回值类型 函数名(参数列表)
{
	函数体语句

	return表达式
}
*/
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

6.2函数的调用

# include <iostream>
using namespace std;
// 函数的声明:如果要调用的函数定义在需要调用它的后面,则需要声明函数。
int add(int num1,int num2);

int main()
{
	int a = 1;
	int b = 2;
	// 调用函数的时候,传过去的a,b有实际的数值,他们成为实参。
	int c = add(a, b);

	cout << "c=" << c << endl;

	system("pause");

	return 0;
}

// 定义的时候num1与num2没有真正的数据,此时它是形参。
int add(int num1, int num2)
{
	int sum = num1 + num2;
	return sum;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

注意: 值传递时形参在函数中发生任何改变,都不会影响实参值。

6.3函数的分文件编写

作用: 让代码结构更清晰
步骤:

  • 创建后缀名为.h的头文件
  • 创建后缀名为.cpp的源文件
  • 在头文件中写函数的声明
  • 在源文件中写函数的定义
// swap.h
# include <iostream>
using namespace std;
// 函数的声明

void swap(int a, int b);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
// 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;

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
// main函数所谓源文件
# include <iostream>
# include "swap.h"
// 使用双引号括起来是自己写的,使用尖括号括起来是调用别人写的。
using namespace std;

int main()
{
	int a = 1;
	int b = 2;
	
	swap( a, b);

	system("pause");

	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

7.指针

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

7.1指针的定义与使用

# include <iostream>
using namespace std;

int main()
{
	// 定义指针
	int a = 10;
	// 指针定义的语法:数据类型 * 指针变量名;
	int * p;
	//指针变量记录变量a的地址
	p = &a;
	// 使用指针
	cout << "a的地址为:" << &a << endl;
	cout << "a的地址为:" << p << endl;
	// 可以通过解引用的方式找到指针指向的内存存储的值。
	cout << "指针p指向内存空间所存储的值" << *p << endl;
	// 可以通过这种方式来改变指定内存空间存储的值
	*p = 100;
	cout << "a = " << a << endl;
	cout << "*P = " << *p << endl;
	
	system("pause");

	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

在32位操作系统下指针所占内存空间固定为4字节,64位操作系统为8字节(无论是int、double… 各种类型的指针都一样)

7.2空指针和野指针

空指针: 指针变量指向内存中编号为0的空间。
用途: 初始化指针变量。
注意: 空指针指向的内存是不可以访问的。

野指针: 指针变量指向非法的内存空间,在程序中避免出现野指针。

// 定义空指针
int *p = NULL;

// 定义野指针
int *p = (int *)0x1234;
// 0x1234这个内存空间并不是自己的,没有操作它的权限。
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

7.3const修饰指针

const修饰指针的三种情况:

  1. const修饰指针:常量指针。
  2. const修饰常量:指针常量。
  3. const即修饰指针,又修饰常量。
/*
常量指针
特点:指针的指向可以修改,但是指针指向的值不可以修改。
*/
const int * p = &a;
/*
指针常量
特点:指针的指向不可以修改,指针指向的值可以修改。
*/
int * const p = &a;
/*
const即修饰指针,又修饰常量
特点:指针的指向不可以修改,指针指向的值也不可以修改。
*/
const int * const p = &a;
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

7.4指针、数组与函数的联合使用

# include <iostream>
using namespace std;

void swap(int * p1, int * p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}

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

	// 利用指针访问数组中的元素
	int *p = arr;  // arr就是数组的首地址
	cout << "利用指针访问第一个元素:" << *p << endl;
	p++; // 让指针向后便宜4个字节,此时指针指向第二个元素。
	cout << "利用指针访问第二个元素:" << *p << endl;

	cout << "利用指针遍历数组:" << endl;
	// 利用指针便利数组
	int * p2 = arr;
	for (int i = 0; i < 10; i++)
	{
		cout << *p << endl;
		p++;
	}
	
	//地址传递,会改变实参值
	int a = 10;
	int b = 20;

	swap(&a, &b);

	cout << "交换后的a:" << a << endl;
	cout << "交换后的b:" << b << endl;
	
	system("pause");

	return 0;

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
// 封装一个使用冒泡排序对整形数组进行升序排列的函数
# include <iostream>
using namespace std;

void bubbleSort(int * arr, int len)
{
	for(int i = 0; i < len - 1; i++)
	{
		for(int j = 0; j < len - 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[10] = {4, 3, 6, 9, 1, 2, 7, 5, 8};
	bubbleSort(arr, 9);
	
	system("pause");

	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

8.结构体

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

8.1结构体定义和使用

语法: struct 结构体名 {结构体成员列表};
通过结构体创建变量的三种方式:

  • struct 结构体名 变量名
  • struct 结构体名 变量名 = {成员1值,成员2值…}
  • 定义结构体时,顺便创建变量
#include <iostream>
using namespace std;
#include <string>
struct Student
{
	string name;
	int age;
	int score;
}s3;
// 定义结构体的时候顺便创建变量

int main()
{
	// struct关键字在创建变量时可以省略
	struct Student s1;
	s1.name = "张三";
	s1.age = 15;
	s1.score = 90;

	struct Student s2 = {"李四", 16, 89};
	
	s3.name = "王五";
	s3.age = 16;
	s3.score = 91;
	
	system("pause");

	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

结构体数组: struct 结构体名 数组名[元素个数] = {{},{},{},…}

8.2结构体指针

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

  • 利用操作符 -> 可以通过结构体指针访问结构体属性
#include <iostream>
using namespace std;
#include <string>
struct Student
{
	string name;
	int age;
	int score;
};

int main()
{
	// 创建学生结构体变量
	Student s = {"张三", 18, 100};

	// 通过指针指向结构体变量
	Student *p = &s;
	
	// 通过指针访问结构体变量中的数据
	cout << "姓名:" << p->name << "年龄:" << p->age << "分数:" << p->score << endl; 
	
	system("pause");

	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

8.3结构体嵌套结构体

#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 = 100;
	t.name = "老王";
	t.age = 50;
	t.stu.name = "小王";
	t.stu.age = 18;
	t.stu.score = 89;
	
	cout << "老师的姓名:" << t.name << "老师的年龄:" << t.age << "老师的编号:" << t.id << << "老师的学生的姓名:" << t.stu.name << "老师的学生的年龄:" << t.stu.age << "老师的学生的成绩:" << t.stu.score << endl; 
	
	system("pause");

	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36

8.4结构体作为函数参数

  • 值传递
  • 地址传递

与普通的参数一样,值传递只是传递值,改变形参不会改变实参。

8.5结构体中const使用场景

作用: 防止误操作

#include <iostream>
using namespace std;
#include <string>
struct Student
{
	string name;
	int age;
	int score;
};

void printStudents(const Student * s)
{
	//s->age = 100; // 使用const修饰后,一旦有修改的操作就会报错,可以防止误操作。
	// 在这里,如果不使用地址传递,直接用值传递,就算修改了也不会改变最原始数据的值,那么为什么不用呢?
	    // 因为如果使用值传递,就需要重新开辟一块地址空间,如果传过来的数据量太大,会消耗大量空间,而使用地址传递,只需要开辟一块指针的空间。
	cout << "学生姓名:" << s->name << " 年龄:" << s->age << " 分数:" << s->score << endl; 
}

int main()
{
	// 创建学生结构体变量
	Student s = {"张三", 18, 100};

	printStudents(s);
	
	cout << "姓名:" << s.name << "年龄:" << s.age << "分数:" << s.score << endl; 
	
	system("pause");

	return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/知新_RL/article/detail/696747
推荐阅读
相关标签
  

闽ICP备14008679号