C++入门

已于 2023-11-16 19:20:03 修改
阅读量277 收藏
点赞数 2
文章标签： c++ 开发语言
于 2023-11-15 19:45:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67880792/article/details/134427481
版权

C++卑微的入门之路

1.c++初识

1.1 Hello World!
#include <iostream>
using namespace std;

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


system("pause");

return 0;


}
1.2 注释
#include<iostream>
using namespace std;

//1.单行注释
//2.多行注释
/*
	main是一个程序的入口
	每个程序都必须有这么一个函数
	有且仅有一个
*/
int main()
{
	cout << "Hello World" << endl;
	system("pause");
	return 0;
}
1.3 变量

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

#include<iostream>
using namespace std;
int main()
{
	//变量创建的语法: 数据类型 变量名=变量初始值
	int a = 10;
	cout << "a = " << a << endl;
	system("pause");
	return 0;
}
1.4 常量
#include<iostream>
using namespace std;
//常量的定义方式
//1.#define 宏常量
//2.const修饰的变量



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

int main()
{
	//Day = 14;//错误,Day是一个常量,一旦修改,就会报错
	cout << "一周总共有:" << Day << "天" << endl;

	2.const修饰的变量
	const int month = 12;
	//month = 24;//错误,const修饰的变量也成为常量
	cout << "一年总共有" << month << "个月份" << endl;
	system("pause");
	return 0;
}
1.5 关键字

作用:关键字是C++中预先保留的单词(标识符)

C++关键字如下:

asmdoifreturntypedef
autodoubleinlineshorttypeid
booldynamic_castintsignedtypename
breakelselongslzeofunion
caseenummutablestaticunsigned
catchexplicitnamespacestatic_castusing
charexportnewsturctvirual
classexternoperatorswitchvold
constfalseprivatetemplatevolatile
const_castfloatprotectedthiswchar_t
continueforpublicthrowwhile
defaultfriendregistertrue
deletegotoreinterpret_casttry

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

  • 再给变量或者常量起名称时,不要用C++的关键字,否则会产生歧义

    #include<iostream>
using namespace std;

int main() 
{
	//创建变量: 数据类型 变量名称 = 变量初始值
	//不要用关键字给变量或者常量起名称
	//int int = 10; 错误,第二个int是关键字,不可以作为变量名称
	int a = 10;
	system("pause");

	return 0;
}
1.6 标识符命名规则

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

  • 标识符不能是关键字

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

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

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

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

#include<iostream>
using namespace std;

//标识符命名
//1.标识符不可以是关键字
//2.标识符是由字母,数字,下划线构成
//3.标识符第一个字符只能是字母或下划线
//4.标识符是区分大小写的
int main()
{
	//1.标识符不可以是关键字
	//int int = 0;

	//2.标识符是由字母,数字,下划线构成
	int abc = 10;
	int _abc = 20;
	int _123abc = 30;

	//3.标识符第一个字符只能是字母或下划线
	//int 123abc = 40;

	//4.标识符区分大小写
	int aaa = 100;
	cout << aaa << endl;
	//cout << AAA << endl;
	//AAA和aaa不是同一名称;

	//建议给变量起名最好能够做到见名知意
	int num1 = 10;
	int num2 = 20;
	int sum = num1 + num2;
	cout << sum << endl;
	system("pause");

	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(数据类型/变量)

整型大小比较
short < int <= long <= long long

#include<iostream>
using namespace std;

int main()
{
	//整型: short(2)  int(4)  long(4)  long long(8)
	//可以利用sizeof求出数据类型占用内存大小
	//语法:  sizeof(数据类型/变量)

	short num1 = 10;
	cout << "short占用的空间内存为" << sizeof(short) << endl;
	cout << "short占用的空间内存为" << sizeof(num1) << endl;

	int num2 = 10;
	cout << "int占用的空间内存为" << sizeof(int) << endl;
	cout << "int占用的空间内存为" << sizeof(num2) << endl;

	long num3 = 20;
	cout << "long占用的空间内存为" << sizeof(long) << endl;
	cout << "long所占用的空间内存为" << sizeof(num3) << endl;

	long long num4 = 555;
	cout << "long long 占用的空间内存为" << sizeof(long long) << endl;
	cout << "long long 占用的空间内存为" << sizeof(num4) << endl;

	//整型大小比较
	//short < int <= long <= long long

	system("pause");
	return 0;
}
2.3 实型 (浮点型)

作用:用于表示小数

浮点型变量分为两种:

1.单精度float

2.双精度double

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

数据类型占用空间有效数字范围
float4字节7位有效数字
double8字节15~16位有效数字
#include<iostream>
using namespace std;

int main()
{
	//1.单精度 float
	//2.双精度 double
	//默认情况下输出一个小数,会显示6位有效数字
	float f1 = 3.1415926f;
	cout << "f1=" << f1 << endl;

	double d1 = 3.1415926;
	cout << "d1=" << d1 << endl;

	//统计float和double占用的内存空间
	cout << "float占用的空间内存为" << sizeof(f1) << endl;
	cout << "double占用的空间内存为" << 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++中字符变量只占一个字节
  • 字符型变量并不是把字符本身放到内存中存储,而是将对应的ASCII编码放入到存储单元
#include<iostream>
using namespace std;

int main()
{
	//1.字符型变量的创建方式
	char ch = 'a';
	cout << ch << endl;
	//2.字符型变量所占内存大小
	cout << "char字符型变量所占内存空间大小: " << sizeof(ch) << endl;
	//3.字符型变量常见错误
	//char ch2 = "b";创建字符型变量时,要用单引号
	//char ch2 = 'abcdef';创建字符型变量时,单引号内只能有一个字符
	//4.字符型变量对应ASCII编码
	cout << (int)ch << endl;
	// a-97
	// A-65
	system("pause");
	return 0;
}
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
?代表一个问号063
\0数字0000
\ddd八进制转义字符,d范围0~73位8进制
\xhh16进制转义字符,h范围09,af,A~F3位16进制
#include<iostream>
using namespace std;

int main()
{
	//转义字符

	//换行符 \n
	cout << "Hello World\n";
	//反斜杠 \\
	
	cout<<"\\"<<endl;
	//水平制表 \t  
	//可以整齐的输出数据
	cout << "aaa\thello world" << endl;//\t占八个空格,目前3个a,所以空5个格
	cout << "aa\thello world" << endl;//\t占八个空格,目前2个a,所以空6个格
	cout << "aaaa\thello world" << endl;//\t占八个空格,目前4个a,所以空4个格
	system("pause");
	return 0;
}
2.6 字符串型

作用:用于表示一串字符

两种风格

​ 1.C风格字符串

char 变量名[] = "字符串值"

  • 注意:C风格的字符串要用双引号括起来

    2.C++风格字符串:

    string 变量名 = "字符串值"
    • 注意:C++风格字符串,需要加入头文件#include
#include<iostream>
using namespace std;
#include<string>

int main()
{
	//1.C风格的字符串
	//注意事项1: char 字符串名[]
	//注意事项2: =后面要用双引号 包含起来字符串
	char str1[] = "Hello World";
	cout << str1 << endl;

//2.C++风格的字符串
//注意事项:要包含头文件#include<string>
string str2 = "hello world";
cout << str2 << endl;//要包含头文件#include<string>
system("pause");
return 0;

}
2.7 布尔类型

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

bool类型只有两个值:

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

bool类型占一个字节大小

#include<iostream>
using namespace std;

int main()
{
	//1.创建bool数据类型
	bool flag = true;//true代表为真
	cout << flag << endl;

	flag = false;//false代表假
	cout << flag << endl;

	//本质上 1代表真 0代表假
	
	//2.查看bool类型所占内存空间
	cout << "bool类型所占内存空间为: " << sizeof(bool) << endl;
	
	system("pause");
	return 0;
}
2.8 数据的输入

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

关键字:cin

语法:

cin >> 变量

#include<iostream>
using namespace std;
#include<string>

 
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;

	//4.字符串型
	string str = "abc";
	cout << "请给字符串型变量str赋值: " << endl;
	cin >> str;
	cout << "输出字符串型变量str=" << str << endl;

	//5.布尔类型
	bool flag = true;
	cout << "请给布尔型变量flag赋值: " << endl;
	cin >> flag;//bool类型,只要是非0的值都代表真
	cout << "输出布尔型变量flag=" << flag <l;

	system("pause");
	return 0;
}

3.运算符

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

本章我们主要讲解以下运算符:

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

作用:用于处理四则运算

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

算术运算符
运算符术语示例结果
+正号+3-3
-负号-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;
3.1.1 加减乘除
  • 两个整数相除,结果仍为整数,小数部分去除
  • 做除法运算,除数不能为0,否则程序崩掉
  • 两个小数可以相除,运算结果也可以为小数
#include<iostream>
using namespace std;


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.2;
	cout << d1 / d2 << endl;//运算结果可以是小数
	system("pause");
	return 0;
}
3.1.2 取模运算
  • 取余运算,除数仍不能为0,否则程序崩掉
  • 两个小数不可以做取模运算
#include<iostream>
using namespace std;

int main()
{
	//取模运算本质 就是求余数
	int a1 = 10;
	int b1 = 3;

	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 = 3.14;
	double d2 = 1.1;
	//cout << d1 % d2 << endl;
	system("pause");
	return 0;
}
3.1.3 前后置加减法运算
  • 前后置加分对于这个变量本身就是正常+1的一个运算
  • 不同之处在于这个变量参与了其他的运算,在这个运算过程中
    • 前置++:正常运算,先给变量+1,再用已经+1的变量的值去参与运算
    • 后置++:(记忆部分)先用未+1的变量的值进行运算,再给变量+1,此处的+只针对未参与运算的变量本身
#include<iostream>
using namespace std;

int main()
{
	//1.前置递增
	int a = 10;
	++a;//让变量+1
	cout << "a=" << a << endl;

	//2.后置递增
	int b = 10;
	b++;//让变量+1
	cout << "b=" << b << endl;

	//3.前置和后置的区别
	//前置递增,先让变量+1,然后进行表达式的运算(即正常逻辑运算)
	int a2 = 10;
	int b2 = ++a2 * 10;
	cout << "a2=" << a2 << endl;
	cout << "b2=" << b2 << endl;

	//后置递增,先进行表达式运算,后让变量+1(即运算时按照未+1的数进行运算,数本身的值+1)
	int a3 = 10;
	int b3 = a3++ * 10;
	cout << "a3=" << a3 << endl;
	cout << "b3=" << b3 << endl;
	system("pause");
	return 0;

	//减法同理
}
3.2 赋值运算符

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

  • a+=2 : a=a+2 [其余的类似]

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

赋值运算符
运算符术语示例结果
=赋值a=3;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;
#include<iostream>
using namespace std;

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;
	cout << "a=" << a << endl;

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

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

比较运算符有以下符号:

比较运算符
运算符术语示例结果
==相等4 == 30
!=不等于4 != 31
<小于4 < 30
>大于4 > 31
<=小于等于4 <= 30
>=大于等于4>=31
#include<iostream>
using namespace std;

int main()
{
	//比较运算符

	// ==
	int a = 10;
	int b = 20;

	cout << (a == b) << endl;//带括号加上优先级
	//  !=
	cout << (a != b) << endl;
	// <
	cout << (a < b) << endl;
	// >
	cout << (a > b) << endl;
	// <=
	cout << (a <= b) << endl;
	// >=
	cout << (a >= b) << endl;

	system("pause");
	return 0;
}
3.4 逻辑运算符

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

逻辑运算符有以下符号:

逻辑运算符
运算符术语示例结果
!非!a如果a为假,则!a为真;如果a为真,则!a为假,
&&与a&&b如果a和b都为真,则结果为真,否则为假.
||或a||b如果a和b有一个为真,则结果为真,二者都为假时,结果为假.
3.4.1 非
  • 1变0;0变1
#include<iostream>
using namespace std;

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

	cout << !!a << endl;
	system("pause");
	return 0;
}
3.4.2 与
  • 全1为1,有0为0
using namespace std;

int main()
{
	//逻辑运算符 - 与 &&
	int a = 10;
	int b = 10;

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

	a = 0;
	b = 10;
	cout << (a && b) << endl;

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

	//同真为真,有假为假
	system("pause");
	return 0;
}
3.4.3 或
  • 全0为0,有1为1
#include<iostream>
using namespace std;

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

	int a = 10;
	int b = 20;
	cout << (a || b) << endl;

	a = 0;
	b = 20;
	cout << (a || b) << endl;

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

	//有1为1,全0为0
	system("pause");
	return 0;
}

4.程序流程结构

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

  • 顺序结构:程序按顺序执行,不发生跳转
  • 选择结构:依据条件是否满足,有选择的执行相应功能
  • 循环结构:依据条件是否满足,循环多次执行某段代码
4.1 选择结构
4.1.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{条件不满足执行的语句};

在这里插入图片描述

#include<iostream>
using namespace std;

int main()
{
	//选择语句 多行If语句
	//输入考试分数
	//如果考试成绩大于600,视为考上一本大学,在屏幕上输出
	//如果没考上一本大学,打印未考上一本大学

	//1.输入考试分数
	int score = 0;
	cout << "请输入您的考试分数" << endl;
	cin >> score;

	//2.提示用户输入的分数
	cout << "您输入的分数为:" << score << endl;

	//3.判断如果大于600,打印考上一本,否则打印未考上一本
	if (score > 600)
	{
		cout << "恭喜,您考上了一本" << endl;
	}
		else
		{
		cout << "很遗憾,您没有考上一本" << endl;
		}
	system("pause");
	return 0;
}

3.多条件的If语句:

if(条件1){条件1满足执行的语句}else if(条件2){条件2满足执行的语句} ... 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.判断
	//如果大于600,考上一本
	if (score > 600)
	{
		cout << "恭喜,您考上了一本" << endl;
	}
	//大于500,二本
	else
		if (score > 500)
		{
			cout << "恭喜,您考上了二本" << endl;
		}
	//大于400,三本
		else
			if (score > 400)
			{
				cout << "恭喜,您考上了三本" << endl;
			}
	//否则,没考上本科
			else 
			{
				cout << "很遗憾,您没有考上本科" << endl;
			}

	system("pause");
	return 0;
}

4.1.4 嵌套if语句

在if语句中可以嵌套使用if语句,达到更精确的条件判断

案例需求:

  • 提示用户输入一个高考考试分数,根据分数做如下判断

  • 分数如果大于600分视为考上一本,大于500分考上二本,大于400 分开上三本,其余视为未考上本科

  • 在一本分数中,如果大于700,考入北大,大于650,考入清华,大于600,考入人大

    #include<iostream>
using namespace std;

int main()
{
	/*
	提示用户输入一个高考考试分数,根据分数做如下判断
	分数如果大于600分视为考上一本,大于500视为考上二本,大于400视为考上三本,其余视为未考上本科
	在一本分数中,如果大于700,考入北大,大于650,考入清华,大于600,考入人大
	*/

	//1.提示用户输入高考分数
	int score = 0;
	cout << "请输入一个高考分数" << endl;
	cin >> score;
	//2.显示高考分数
	cout << "您输入的分数为:" << score << endl;
	//3.判断
	//如果大于600,一本
	if (score > 600)
	{
		cout << "恭喜您,考上了一本" << endl;

		//大于700,考上北大
		if (score > 700)
		{
			cout << "您能考入北大" << endl;
		}
		//大于650,考上清华
		else if (score > 650)
		{
			cout << "您能考入清华" << endl;
		}
		//其余,考上人大
		else
		{
			cout << "您能考入人大" << endl;
		}
	}

	
	//如果大于500,二本
	else if (score > 500)
	{
		cout << "恭喜您,考上了二本" << endl;

	}
	//如果大于400,三本
	else if (score > 400)
	{
		cout << "恭喜您,考上了三本" << endl;
	}
	//其余未考上
	else
	{
		cout << "很遗憾,您没有考上本科" << endl;
	}
	system("pause");
	return 0;
}

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

    狼先生悬赏令:有三只小猪,请分别输入三只小猪的体重,并且找到哪只小猪最重
    在这里插入图片描述

#include<iostream>
using namespace std;

int main()
{
	cout << "猪猪王国的小猪你们好" << endl << "经过一年一度的选拔" << endl << "我们已经选出了三位优秀的猪猪来代表我们"<< endl <<"现在让我们来选出最胖的小猪献给狼先生吧!" << endl;
	//请输入三只小猪的体重
	int pig1 = 0;
	int pig2 = 0;
	int pig3 = 0;
	cout << "请分别输入三只小猪的体重:" << endl;
	cout << "首先,猪猪一号:" << endl;
	cin >> pig1;
	cout << "接下来,猪猪二号" << endl;
	cin >> pig2;
	cout << "最后,猪猪三号" << endl;
	cin >> pig3;
	//判断大小
	//先判断猪猪一号体重是否大于猪猪二号
	// 1 如果猪猪一号体重大于猪猪二号
		//接下来判断猪猪一号的体重是否大于猪猪三号
		// 1 如果大于,输出猪猪一号作为最胖小猪献给狼先生
		//如果不大于
		// 3 小于,输出猪猪三号被献给狼先生
        // 2 等于,输出 猪猪一号和猪猪三号一起被献给狼先生
	//如果猪猪一号体重不大于猪猪二号
	// 3 如果猪猪一号体重小于猪猪二号
			//判断猪猪二号体重是否大于猪猪三号
				// 1 大于,输出猪猪二号被献给狼先生
				// 3 小于,输出猪猪三号被献给狼先生
				// 2 等于,输出猪猪二号和猪猪三号被献给狼先生
	// 2 如果猪猪一号体重等于猪猪二号
			//判断猪猪二号是否大于猪猪三号
				// 1 大于,输出猪猪一号和猪猪二号一起被献给狼先生
				// 2 小于,输出猪猪三号被献给狼先生
				// 3 等于,输出三只小猪都被献给狼先生
	if (pig1 > pig2)
	{
		if (pig1 > pig3)
		{
			cout << "恭喜猪猪一号作为最胖小猪被献给狼先生" << endl;
		}
		else if(pig1 < pig3)
		{
			cout << "恭喜猪猪三号作为最胖小猪被献给狼先生" << endl;
		}
		else
		{
			cout << "恭喜猪猪一号和猪猪三号一起被献给狼先生" << endl;
		}
		
	}
	else if(pig1 < pig2)
	{
		if (pig2 > pig3)
		{
			cout << "恭喜猪猪二号作为最胖小猪被献给狼先生" << endl;
		}
		
		else if(pig2 <pig3)
		{
			cout << "恭喜猪猪三号作为最胖小猪被献给狼先生" << endl;
		}
		else 
		{
			cout << "恭喜二号猪猪和三号猪猪被献给狼先生咯" << endl;
		}
	}
	else 
	{
		if (pig2 > pig3)
		{
			cout << "恭喜猪猪一号和猪猪二号一起被献给狼先生" << endl;
		}
		else if (pig2 < pig3)
		{
			cout << "恭喜猪猪三号作为最胖小猪被献给狼先生" << endl;
		}
		else
		{
			cout << "恭喜三只小猪都被献给狼先生咯" << endl;
		}

	}
	system("pause");
	return 0;
}
4.1.2 三目运算符

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

语法:

表达式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++中三目运算符返回的是变量,可以继续赋值
	a > b ? a : b = 100;
	cout << "a=" << a << endl;//10
	cout << "b=" << b << endl;//100
	system("pause");
	return 0;
}
4.1.3 switch语句

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

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

	//if和switch区别
	//if可以设置区间
	//switch缺点 : 只能是整型或者字符型,不能表示区间
	//switch优点 :  结构清晰,执行效率高
	system("pause");
	return 0;
}

  • if和switch区别

    1.if可以设置区间

    2.switch缺点 : 只能是整型或者字符型,不能表示区间

    3.switch优点 : 结构清晰,执行效率高

    • case里如果没有break,那么程序会一直执行下去
4.2 循环结构
4.2.1 while循环语句

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

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

解释:只要循环条件的结果为真,就执行循环语句
在这里插入图片描述

#include<iostream>
using namespace std;

int main()
{
	//在屏幕中打印0~9这10个数字
	/*int num = 0;
	cout << num << endl;
	num++;
	cout << num << endl;
	num++;
	cout << num << endl;
	num++;
	cout << num << endl;
	num++;
	cout << num << endl;
	num++;
	cout << num << endl;
	num++;
	cout << num << endl;
	num++;
	cout << num << endl;
	num++;
	cout << num << endl;
	num++;
	cout << num << endl;*/

	int num = 0;

	//while循环
	//注意事项:再执行循环语句时,程序必须提供跳出循环的出口,否则出现死循环
	while (num < 10)
	{
		cout << num << endl;
		num++;
	}

	system("pause");
	return 0;
}
  • while循环-猜数字

在这里插入图片描述

随机生成一个1到100之间的数字,玩家进行猜测,如果猜错,提示玩家数字过大或过小,如果猜对,恭喜玩家胜利,并且退出游戏.

在这里插入图片描述

#include<iostream>
using namespace std;
//time系统时间头文件包括
#include<ctime>

int main()
{
	//随机生成一个1到100之间的数字,玩家进行猜测,如果猜错,提示玩家数字过大或过小,如果猜对,恭喜玩家胜利,并且退出游戏.
	
	//添加随机数种子,作用利用当前系统的时间生成随机数,防止每次随机数都一样
	srand((unsigned int)time(NULL));
	//1.系统生成随机数
	int num = rand() % 100 + 1;//rand()%100 + 1生成 0+1~99+1,即1~100
	//cout << num << endl;
	//2.玩家进行猜测
	cout << "您好,欢迎来到猜数字,请输入您的数字: " << endl;
	int val = 0;//玩家输入的数据
	//3.判断玩家的猜测
	while (1)//一直运行
	{
		cin >> val;//输入数据
		if (val > num)
		{
			cout << "您猜测的数字与正确答案相较过大了,请往小猜猜看呢" << endl;
		}
		else if (val < num)
		{
			cout << "您猜测的数字与正确答案相较过小了,请往大猜猜看呢" << endl;
		}
		else
		{
			cout << "恭喜您,猜对啦!" << endl;
			//猜对咯,退出当前循环
			break;
		}
	}
	//猜对  退出游戏
	//猜错  提示猜的结果 过大或过小 重新返回第二步
	system("pause");
	return 0;
}
4.2.2 do…while循环语句

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

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

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

在这里插入图片描述

#include<iostream>
using namespace std;

int main()
{
	//do..while语句
	//在屏幕中输出0到9这10个数字

	int num = 0;

	do
	{
		cout << num << endl;
		num++;
	} while (num < 10);
    //do...while和while循环的区别在于do...while会先执行弄过一次循环语句
	system("pause");
	return 0;
}

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

  • do…while-水仙花数
    练习案例:水仙花数
    案例描述:水仙花数是指一个3位数,它的每个位上的数字的3次幂之和等于它本身
    例如: 1^3 + 5^3 + 3^3 = 153
    请利用do…while语句,求出所有3位数中的水仙花数

#include<iostream>
using namespace std;

int main()
{
	int num = 100;//最小的三位数
	do
	{
		int a = 0;
		int b = 0;
		int c = 0;


		a = num % 10;//取余于10,求个位数
		b = (num / 10) % 10;//三位数除以10得前两位,再取余于10得十位数
		c = num / 100;//三位数除以100得百位数
		if ((a * a * a + b * b * b + c * c * c) == num)
		{
			cout << num << "为水仙花数" << endl;
		}
		num++;

	} while (num<999);

	system("pause");
	return 0;
}
4.2.3 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;
 }

  • for循环-拍桌子

    练习案例:敲桌子

在这里插入图片描述

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

#include<iostream>
using namespace std;

int main()
{
	/*从1开始数到数字100,
		如果数字个位含有7,
		或者数字十位含有7,
		或者是该数字是7的倍数,
	我们打印敲桌子,
		其余数字直接打印输出*/
	
	//打印1~100
	for (int i = 1; i < 101; i++)
	{
		
		if (i % 7 == 0||i % 10 == 7|| i / 10  == 7)
		{
			cout << i <<"敲桌子..." << endl;
		}
		else
		{
			cout << i << endl;
		}
		
	}

	system("pause");
	return 0;
}
4.2.4 嵌套循环

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

假如我们想在屏幕中打印如下图片,需要利用嵌套循环

在这里插入图片描述

#include<iostream>
using namespace std;

int main()
{
	//利用嵌套循环实现星图

	//打印一行星图
	for (int i = 0; i < 10; i++)
	{
		for (int j = 0; j < 10; j++)
		{
			if (j < 10)
			{
				cout << "* ";
			}
		}
		cout << endl;
	}
	

	system("pause");
	return 0;
}

  • 嵌套循环-乘法口诀表

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

#include<iostream>
using namespace std;

int main()
{
	for (int i = 1; i < 10; i++)
	{
		for (int j = 1; j < i+1; j++)
		{
			cout << i << "*" << j << "=" << i * j << " ";
		}
		cout << endl;
	}

	system("pause");
	return 0;
}

结果如下图所示:
在这里插入图片描述

4.3 跳转语句
4.3.1 break语句

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

break使用的时机:

  • 出现在switch条件语句中,作用是终止case并跳出switch
  • 出现在循环语句中,作用是跳出当前的循环语句
  • 出现在嵌套循环中,跳出最近的内层循环语句
#include<iostream>
using namespace std;

int main()
{
	//brerak的使用时机

	//1.出现在循环语句中
	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;//退出
	defalult:
		break;
	}

	//2.出现在循环语句中
	for (int i = 0; i < 10; i++)
	{
		//如果i等于5,退出循环,不再打印
		if (i == 5)
		{
			break;//退出循环
		}
		cout << i << endl;
	}
	//3.出现在嵌套循环语句中
	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 语句

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

#include<iostream>
using namespace std;

int main()
{
	for (int i = 0; i < 100; i++) 
	{
		//偶数输出,奇数不输出
		if (i % 2 == 1)
		{
			continue;//可以筛选条件,执行到此就不再向下执行,执行下一次循环
			//break会退出循环,而continue不会
		}
		cout << i << endl;
	}
	system("pause");
	return 0;
}
  • continue可以筛选条件,执行到此就不再向下执行,执行下一次循环
  • break会退出循环,而continue不会
4.3.3 goto语句

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

语法:

goto 标记;

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

#include<iostream>
using namespace std;

int main()
{

	cout << "1" << endl;
	cout << "2" << endl;
	goto FLAG;
	cout << "3" << endl;
	cout << "4" << endl;
	FLAG:
	cout << "5" << endl;
	cout << "6" << endl;

	system("pause");
	return 0;
}

在这里插入图片描述

5. 数组

5.1 概述

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

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

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

5.2 一维数组
5.2.1 一维数组定义方式

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

数据类型 数组名[数组长度];

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

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

#include<iostream>
using namespace std;

int main()
{
	//定义方式1
	/*1.数据类型 数组名[数组长度];
	2.数据类型 数组名[数组长度] = { 值1,值2... };
	3.数据类型 数组名[] = { 值1,值2... };*/


	//1.数据类型 数组名[数组长度];
	int arr[5];
	arr[0] = 10;
	arr[1] = 20;
	arr[2] = 30;
	arr[3] = 40;
	arr[4] = 50;
	//访问数据元素
	cout << arr[0] << endl;
	cout << arr[1] << endl;
	cout << arr[2] << endl;
	cout << arr[3] << endl;
	cout << arr[4] << endl;


	//2.数据类型 数组名[数组长度] = { 值1,值2... };
	//如果在初始化数据时,没有全部赋值,那么会用0来填补剩余数据
	int arr2[5] = { 10,20,30,40,50 };
	
	cout << arr2[0] << endl;
	cout << arr2[1] << endl;
	cout << arr2[2] << endl;
	cout << arr2[3] << endl;
	cout << arr2[4] << endl;

	//利用循环 输出数组中的元素
	for (int i = 0; i < 5; i++)
	{
		cout << arr2[i] << endl;
	}

	//3.数据类型 数组名[] = { 值1,值2... };
	//定义数组的时候,必须有一个初始的长度
	int arr3[] = { 90,80,70,60,50,40,30,20,10 };
	for (int i = 0; i < 9; i++)
	{
		cout << arr3[i] << endl;
	}


	//利用下标赋值
	system("pause");
	return 0;
}
5.2.2 一维数组数组名

一维数组名称用途:

1.可以统计整个数组在内存中的长度 sizeof(数组名)

2.可以获取数组在内存中的首地址 sizeof(数组名[0])

3.元素个数=sizeof(数组名) / sizeof(数组名[0])

#include<iostream>
#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;
	cout << "数组中第一个元素地址为: " << (int)&arr[0] << endl;
	cout << "数组中第二个元素地址为: " << (int)&arr[1] << endl;
	cout << "数组中第三个元素地址为: " << (int)&arr[2] << endl;

	//数组名是一个常量,不可以进行赋值操作
	//arr=100;
	system("pause");
	return 0;
}

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

    案例描述:

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

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

  1. 定义一个max变量,用以更替最大值
  2. 循环比较五个数值与max的大小,如果该数大,则替换max,否则不做改变
  3. 最后输出max即可
#include<iostream>
using namespace std;

int main()
{

```
//定义数组表示五只小猪体重
int arr[5] = { 100,200,350,200,400 };
int max = 0;
for (int i = 0; i < 5; 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()
{
	//定义五个数的数组
	int arr[5] = { 1,3,2,5,4 };
	for (int i = 4; i >= 0; i--)
	{
		cout << arr[i] << " " ;
	}

	system("pause");
	return 0;
}

输出逆序的数组:

#include<iostream>
using namespace std;

int main()
{
	//定义数组
	int arr[5] = { 4,3,2,5,1 };
	//输出
	cout << "元素逆置前数组为: " << endl;
	for (int i = 0; i < 5; i++)
	{
		cout << arr[i] << " ";
	}
	//定义始末元素下标
	int start = 0;
	int end = sizeof(arr) / sizeof(arr[0]) - 1;
	//定义temp暂时存储替换元素
	int temp = 0;

	//替换
	//法1:	
	/*for (int i = 0; i < 5; i++)
	{
		if (start < end)
		{
			temp = arr[start];
			arr[start] = arr[end];
			arr[end] = temp;
			start++;
			end--;
		}

	}*/
	//法2:
	while (start < end)
	{
		temp = arr[start];
		arr[start] = arr[end];
		arr[end] = temp;
		start++;
		end--;
	}
	cout << endl;
	cout << "数组元素逆置后: " << endl;
	for (int j = 0; j < 5; j++)
	{
		cout << arr[j] << " ";
	}
	cout << endl;

	system("pause");
	return 0;
}
5.2.3 冒泡排序

​ 1.比较相邻的元素,如果第一个比第二个大,就交换他们两个
​ 2.对每一对相邻元素做同样的工作,执行完毕后,找到第一个最大值
​ 3.重复以上步骤,每次比较次数-1,直到不需要比较

#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;
	//开始冒泡排序
	//0-8排序轮数
	for (int i = 0; i < 9; i++)
	{
		//内层循环代表 每次比较次数=9-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] << " ";
	}
	system("pause");
	return 0;

}
5.3 二维数组
5.2.1 二维数组定义方式

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

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

​ {数据3,数据4}
​ };

常用

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

4.数据类型 数组名[ ][ 列数 ]={ 数据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;

	//外层循环打印行数,内层循环打印列数
	cout << "1双层循环打印数列:" << endl;
	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}
	};
	//打印数组
	cout << "2打印数组" << endl;
	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 };
	cout << "3打印数组" << endl;
	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 };
	cout << "4打印数组" << endl;
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr[i][j] << " ";
		}
		cout << endl;
	}
	system("pause");
	return 0;
}
5.3.2 二维数组命名

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

    sizeof()

  • 获取二维数组首地址

    查看第一个元素首地址要加取地址符&

    #include<iostream>
using namespace std;

int main()
{
	//二维数组命名用途
	//1.可以查看占用内存空间大小
	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;

	//2.可以查看二维数组首地址
	cout << "二维数组的首地址为: " << (int)arr << endl;
	cout << "二维数组第一行首地址为:" << (int)arr[0] << endl;
	cout << "二维数组第二行首地址为:" << (int)arr[1] << endl;

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

	system("pause");
	return 0;
}
二维数组案例-考试成绩统计
#include<iostream>
using namespace std;

int main()
{
	//二维数组案例-考试成绩统计

	//1.创建二维数组
	int scores[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 += scores[i][j];
		}
		cout << names[i] << "的总成绩为: " << sum << endl;
	}

	system("pause");
	return 0;
}

6.函数

6.1 概述

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

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

6.2 函数的定义

函数的定义一般主要有5个步骤:

1.返回值类型

2.函数名

3.参数表列

4.函数体语句

5.return 表达式

语法

返回值类型 函数名 (参数列表)
{
	函数体语句
	
	return表达式
	
}

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

	//函数调用的语法:函数名称 (参数)
	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.无参无返

​ 2.有参无返

​ 3.无参有返

​ 4.有参有返

示例:

#include<iostream>
using namespace std;

//1.无参无返
void test01()
{
	cout << "this is test01" << endl;
}
//2.有参无返
void test02(int a)
{
	cout << "this is teat02" << endl;
}
//3.无参有返
int test03()
{
	cout << "this is test03" << endl;
	return 1000;
}
//4.有参有返
int test04(int a)
{
	cout << "this is test04 a=" << a << endl;
	return a;
}
int main()
{
	//无参无返函数调用
	test01();

	//有参无返函数调用
	test02(100);

	//无参有返函数调用
	int num1 = test03();
	cout << "num1=" << num1 << endl;

	//有参有返函数调用
	int num2 = test04(20);
	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;
}
//下面是错的,定义只能有一次
//int max(int a, int b)
//{
//	return a > b ? a : b;
//}
6.7 函数的分文件编写

作用:让代码结构更清晰

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

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

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

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

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

示例:

#include<iostream>
using namespace std;
//函数的声明
void swap(int a, int b);


#include"swap.h"

//函数的定义
void swap(int a, int b)
{
	int temp = a;
	a = b;
	b = temp;

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

}

#include<iostream>
using namespace std;
#include"swap.h"

//函数的分文件编写
//实现两个数字进行交换的函数


//1.创建.h头文件

//2.创建.cpp源文件

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

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

int main()
{

	int a = 10;
	int b = 20;
	swap(a, b);
	system("pause");
	return 0;
}

7.指针

7.1 指针的基本概念

指针的作用:可以通过指针间接访问内存

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

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

示例:

#include<iostream>
using namespace std;

int main()
{
	//1.定义一个指针
	int a = 10;
	//指针定义的语法:数据类型*指针变量名;
	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个字节空间大小,x86
	//在64位操作系统下,不管什么数据类型,指针占8个字节空间大小,x64

	cout << "sizeof(int *) = " << sizeof(int *) << endl;
	cout << "sizeof(int *) = " << sizeof(float *) << endl;
	cout << "sizeof(int *) = " << sizeof(double *) << endl;
	cout << "sizeof(int *) = " << sizeof(char *) << endl;

	system("pause");
	return 0;
}
7.4 空指针和野指针

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

用途:初始化指针变量

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

示例1:空指针

#include<iostream>
using namespace std;

int main()
{
	//空指针
	//1.空指针用于给指针变量初始化
	int* p = NULL;

	//2.空指针是不可以进行访问的
	//0~255之间的内存编号是系统占用的,因此不可访问
	*p = 100;

	system("pause");
	return 0;
}

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

示例2:野指针

#include<iostream>
using namespace std;

int main()
{
	//野指针
	int* p = (int *)0x1100;

	cout << *p << endl;
	system("pause");
	return 0;
}

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

7.5 const修饰指针

const修饰指针有三种情况:

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

​ 2.const修饰常量 —指针常量

​ 3.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 = 100;//正确的
	//p2 = &b;//错误的,指针的指向不可以改
	
	//3.const修饰指针和常量
	const int * const p3 = &a;
	//指针的指向和指针指向的值都不可以改
	//*p3 = 100;//错误
	//p3 = &b;//错误
	system("pause");
	return 0;
}

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

就是const在谁前就限制谁不能修改

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++;//指针向后偏移四个字节

	cout << "利用指针来访问第二个元素: " << *p << endl;

	//利用指针遍历数组

	cout << "利用指针来遍历数组" << endl;
	int* p2 = arr;

	for (int i=0;i<10;i++)
	{
		cout << *p2 << " ";
		p2++;
	}

	system("pause");
	return 0;
}
7.7 指针和函数

作用:利用指针做函数参数,可以改变实参的值

示例:

#include<iostream>
using namespace std;
//实现两个数字交换
void swap01(int num1, int num2)
{
	int temp;
	temp = num1;
	num1 = num2;
	num2 = temp;
	cout << "swap01中num1=" << num1 << endl;
	cout << "swap01中num2=" << num2 << endl;

}

void swap02(int* p1, int* p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}
int main()
{
	//指针和函数
	//1.值传递
	int num1 = 10;
	int num2 = 20;
	swap01(num1, num2);
	
	//2.地址传递
	swap02(&num1, &num2);
	cout << "num1=" << num1 << endl;
	cout << "num2=" << num2 << endl;
	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.结构体

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;



int main()
{

	//通过学生类型创建具体的学生
//2.1 struct Student s1
	//创建变量struct 关键字可以省略
	 //struct Student s1;
	Student s1;
	//给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 = 13;
	s3.score = 60;
	cout << "姓名: " << s3.name << "  年龄多大: " << s3.age << "      成绩: " << s3.score << endl;

	system("pause");
	return 0;
}

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

总结2:创建结构体变量时,关键字struct可以省略

总结3:结构体变量利用操作符"."访问成员

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},
		{"李四",19,87},
		{"王五",28,89}
	};
//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 nammmespace std;
//结构体指针

//定义学生结构体
struct student
{
	string name;//姓名
	int age;//年龄
	int score;//成绩
};
int main()
{
	//1.创建学生结构体变量
	struct student s = { "张三",18,100 };

	//2.通过指针指向结构体变量
	struct student* p = &s;

	//3.通过指针访问结构体变量中的数据
	//如果想通过一个结构体指针,来访问结构体中的属性,需要利用"->"
	cout << "姓名: " << p->name << "年龄: " << p->age << " 分数: " << p->score << endl;


	system("pause");
	return 0;
}

总结:结构体指针可以通过->操作符,来访问结构体中的成员

8.5 结构体嵌套结构体

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

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

示例:

#include<iostream>
using namespace std;

//定义学生结构体
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;
//定义学生结构体
struct student
{
	string name;
	int age;
	int score;
};

//打印学生信息函数
//1.值传递
void printStudent1(struct student s)
{
	s.age = 100;
	cout << "子函数1中 姓名: " << s.name << " 年龄: " << s.age << " 分数:" << s.score << endl;
}

//2.地址传递
void printStudent2(struct student* p)
{
	p->age = 200;
	cout << "子函数2中 姓名: " << p->name << " 年龄:" << p->age << "  分数: " << p->score << endl;
}
int main()
{

	//结构体做函数参数
	//将学生传入到一个参数中,打印学生身上所有的信息

	//创建结构体变量
	struct student s;
	s.name = "张三";
	s.age = 20;
	s.score = 85;

	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;

//const使用场景
struct student
{
	string name;
	int age;
	int score;
};
//将函数中形参改为指针,可以减少内存空间,而且不会复制新的副本出来
void printStudent(const student *s)
{
	//s->age = 150;//加入const后.一旦有修改的操作就会报错,可以防止我们的误操作
	cout << "姓名: " << s->name << " 年龄: " << s->age << " 得分: " << s->score << endl;
}
int main()
{
	//创建结构体变量
	struct student s = { "张三",15,70 };

	//通过函数来打印结构体变量的信息

	printStudent(&s);
	cout << "main函数中张三年龄为:  " << s.age << endl;
	system("pause");
	return 0;
}
8.8 结构体案例

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

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

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

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

示例:

#include<iostream>
using namespace std;
#include<ctime>
//学生的结构体定义
struct Student
{
	string sName;
	int score;

};

//老师的结构体定义
struct Teacher
{
	//姓名
	string tName;
	//学生数组
	struct Student sArray[5];

};
string nameSeed = "ABCDE";
//给学生和老师赋值的函数
void allocateSpace(struct Teacher tArray[],int len)
{
	//给老师赋值
	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.创建3名老师的数组
	struct Teacher tArray[3];
	//2.通过函数给3名老师的信息赋值,并给老师所带的学生信息赋值
	int len=sizeof(tArray)/sizeof(tArray[0]);
	allocateSpace(tArray, len);
	//3.打印所有老师及所带的学生信息
	printInfo(tArray, len);
	system("pause");
	return 0;
}
/辅导的学生
};
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;
//定义学生结构体
struct student
{
	string name;
	int age;
	int score;
};

//打印学生信息函数
//1.值传递
void printStudent1(struct student s)
{
	s.age = 100;
	cout << "子函数1中 姓名: " << s.name << " 年龄: " << s.age << " 分数:" << s.score << endl;
}

//2.地址传递
void printStudent2(struct student* p)
{
	p->age = 200;
	cout << "子函数2中 姓名: " << p->name << " 年龄:" << p->age << "  分数: " << p->score << endl;
}
int main()
{

	//结构体做函数参数
	//将学生传入到一个参数中,打印学生身上所有的信息

	//创建结构体变量
	struct student s;
	s.name = "张三";
	s.age = 20;
	s.score = 85;

	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;

//const使用场景
struct student
{
	string name;
	int age;
	int score;
};
//将函数中形参改为指针,可以减少内存空间,而且不会复制新的副本出来
void printStudent(const student *s)
{
	//s->age = 150;//加入const后.一旦有修改的操作就会报错,可以防止我们的误操作
	cout << "姓名: " << s->name << " 年龄: " << s->age << " 得分: " << s->score << endl;
}
int main()
{
	//创建结构体变量
	struct student s = { "张三",15,70 };

	//通过函数来打印结构体变量的信息

	printStudent(&s);
	cout << "main函数中张三年龄为:  " << s.age << endl;
	system("pause");
	return 0;
}
8.8 结构体案例
8.8.1 案例1

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

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

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

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

示例:

#include<iostream>
using namespace std;
#include<ctime>
//学生的结构体定义
struct Student
{
	string sName;
	int score;

};

//老师的结构体定义
struct Teacher
{
	//姓名
	string tName;
	//学生数组
	struct Student sArray[5];

};
string nameSeed = "ABCDE";
//给学生和老师赋值的函数
void allocateSpace(struct Teacher tArray[],int len)
{
	//给老师赋值
	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.创建3名老师的数组
	struct Teacher tArray[3];
	//2.通过函数给3名老师的信息赋值,并给老师所带的学生信息赋值
	int len=sizeof(tArray)/sizeof(tArray[0]);
	allocateSpace(tArray, len);
	//3.打印所有老师及所带的学生信息
	printInfo(tArray, len);
	system("pause");
	return 0;
}
8.8.2 案例2

案例描述:

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

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

无名英雄信息如下:

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

#include<iostream>
using namespace std;

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)
			{
				struct Hero temp = heroArray[j];
				heroArray[j] = heroArray[j + 1];
				heroArray[j + 1] = temp;
			}

		}
	}
}
//打印排序后的数组中的信息

void printHero(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()
{
	//1.设计一个英雄的结构体
	
	//2.创建一个数组存放5名英雄
	struct Hero heroArray[5] =
	{
		{"刘备",23,"男"},
		{"关羽",22,"男"},
		{"张飞",20,"男"},
		{"赵云",21,"男"},
		{"貂蝉",19,"女"},
	};
	int len = sizeof(heroArray) / sizeof(heroArray[0]);
	cout << "排序前的数组: " << endl;
	for (int i = 0; i < len; i++)
	{
		cout << "姓名: " << heroArray[i].name 
			 << " 年龄: " << heroArray[i].age 
			 << " 性别: " << heroArray[i].sex
			 << endl;
	}
	//3.对数组进行排序,按照年龄进行升序排列
	bubbleSort(heroArray, len);

	//4.将排序后的结果打印输出
	cout << "排序后的数组: " << endl;
	printHero(heroArray, len);
	system("pause");
	return 0;
}
C++ 【重载】使用 "cout" 输出字符数组/字符指针的首地址
⚡
01-07 6016
char *p = "Hello,World!"; cout << p << endl; //输出Hello,World! cout << *p << endl; //输出H 正确输出：cout << (void *)p << endl; **********************************...
C++入门基础(万字总结）（建议收藏！！！）
热门推荐
IamGreeHand的博客
09-22 26万+
文章目录什么是C++C++的发展史C++关键字命名空间命名空间的定义1.命名空间的普通定义2.命名空间可以嵌套3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。命名空间使用1.加命名空间名称及作用域限定符2.使用using namespace 命名空间名称引入3.使用using将命名空间中的成员引入C++中的输入和输出缺省参数全缺省半缺省参数函数重载函数重载的原理extern “C”引用引用的特征1.引用在定义时必须初始化2.一个变量可以有多个引用3.引用一旦引用了一个实体
C++中cout的使用
九霄星河的博客
09-21 22万+
C++中cout的使用1. cout使用的三种方式2. cout和i/i++/++i的组合使用3. 以不同进制输出数字4. 输出数字位数的控制5. 强制显示小数点和正负号6. 设置宽度和对齐方式7. 设置填充字符8. iomanip库用法总结 cout 是C++中 ostream 类型的对象，该类被封装在 &amp;lt; iostream &amp;gt; 库中，该库定义的名字都在命名空间 std 中，所以 c...
C++ cout 与cin的用法
m0_51571900的博客
09-17 4828
原因是他输出c地址的字符串，输出d地址的字符串，但是d是个字符它会在d的地址一直往后输出知道输出\0，所以字符g后的内容是不能确定的。count<<(char *)c<<endl与输出cout<<&c<<endl的地址是一样的，前者c+1表示下一个元素位置，&c+1表示数组末尾+1。在上面的对比我们可以看出C语言的的输出方式需要%来指定格式的，但是C++中是不要的指定的。注意 ：因为cout不指定输出的格式就导致了它输出char *类型时输出的是该地址的字符串。cout<<"输出的内容"
【自学】C++-基础
努力的里
07-17 84
泛型编程：应用与模版，可以实现一个接口可以处理多种数据类型。2.c++标准：c++98、描述了已有的 c++特性，还对语言进行了扩展，添加了异常、运行阶段类型识别(RTTI)、模板和标准模 板库(STL).3.之前的cpp头文件是xx.h，现在是cpp头文件是xx，也可以是cxx；
cout<<endl
weixin_35750747的博客
12-31 9463
cout 是 C++ 中的输出流，它的作用是向输出设备(通常是屏幕)输出信息。 << 是流插入运算符，它的作用是将一个值插入到输出流中。 endl 是换行符，它的作用是在输出完当前行后换到下一行。 所以，cout<<endl 的作用是向输出设备输出一个换行符，使得下一条输出语句输出到下一行。 例如： #include <iostream> using names...
小学生C++入门 - 2024.10.15(L)-239页.pdf
最新发布
10-17
这本教材是一份针对小学生编程兴趣培养和C++入门教育的宝贵资料，通过理论教学与实际案例结合的方式，激发学生的编程热情，提升学生的编程技能，并为学生参与各级各类信息学竞赛提供有力的支持和引导。
C++入门编程100题
06-30
《C++入门编程100题》课程是由WangTeacher精心制作一部视频教学实战课程，初步计划100个编程题目的详细讲解，从简单到复杂的顺序排列。并结合15+年的软件开发经验，把最先进的软件开发流程和编程技巧融合到课程中，...
C++入门指南-v2.4.pdf
06-23
这是DS小龙哥编写整理的C++入门指南PDF文档，适合C++初学者，C语言转C++工程师当做入门工具书学习。PDF里有完整示例、知识讲解，平时开发都可以复制粘贴，非常便捷。 目前一共写了7章，后续会持续更新资源包，更新后...
小学生C++入门班与提高班（2021.07.17）.pdf
07-25
根据提供的文件内容，我们可以了解到有关小学生C++入门班与提高班的详细情况。 首先，我们来看小学生C++入门班。入门班主要面向小学二、三、四年级的学生，目的是让完全编程零基础的学生能够顺利进入编程世界。入门...
关于cout 输出 char 型字符 ++ch和 ch+1 不同的结果（直接看详解）
坚持才能放假的博客
03-18 2913
一、简述 今天在做练习题时注意到了之前所没有注意到的问题： 若给同样的 ch ，cout << ++ch; 与 cout << ch+1; 输出后的结果不一样。 浅思之后明白了，其实这个现象解释起来不难，细心一点就能够解释。 二、代码 #include<iostream> using namespace std; int main() { char ch; cin.get(ch); //cin.get()读取缓冲区中第一个字符 //此时读取的字符不是
C++ cout char *
喵咖的专栏
11-09 5443
const char * p = "hello"; cout<<p<<endl;cout输出char *类型的时候一定要加endl，不然没有结束标志，至于原理，暂时也没细看。
C++知识点
weixin_43619564的博客
05-18 208
main 是一个程序的入口，每个程序都必须有这么一个函数，并且仅有一个。
【c++】cout打印char * 或者char[]的细节详解
m0_73726899的博客
09-01 2362
对于使用cout打印char类型有许多细节~
C++ cout char* 的问题
weixin_34060741的博客
05-05 1086
问题： 在C++中，为什么char *p="hello world"; cout<<p<<endl;打印出来的是字符串，而不是地址? 回答： 指针p指向字符串常量"hello word"，即p中存放该字符串的首地址，c++为了兼容c语言，当cout输出常量字符串的首地址时实际输出该字符串（对cout的<<运算符进行了重载，cout<<p被翻译为...
【C++基础学习】C++中用char定义的整数用cout输出的结果
b2655472的博客
12-10 1733
char定义的变量： 如果a是数字，cout <<a就会输出ASCII相对应的字符； 如果a是字符，cout<<a就会直接输出字符； 如果a是字符或数字，cout<<(int*)a就会输出ASCII对应的十六进制数 char a = 36; cout << a << endl; //...
C++:cout＜＜自定义类型输出
jsjgogogo的博客
03-21 3227
1.自定义类型 struct Student{ int id; string name; Student(); Student(int ID,string Name){ id=ID; name=Name; } friend ostream & operator << (ostream &out,const Student &s) { out<<s.id
C++ cout输出字符
7now_的博客
11-30 1万+
cout输出字符时，可以使用单引号 ：cout << ';' << endl; //输出分号";"仅可输出字符型，如果单引号内是两个或多个字符，则会输出对应的int值（将字符转换为对应ASCII码值） 如：cout << ';;' << endl; //输出15163“;”对应的ASCII码为59（0x3B），“;;”为0x3B3B，对应十进制为15163
C++中cout的常用用法
Jasmine-Lily的博客
10-13 4564
code: // File name: Cout_Usage // Last modified Date: 2021年10月12日22点09分 // Last Version: V1.0 // Descriptions: 本程序包含cout的常用用法 #include <iostream> #include <iomanip> using namespace std;//将命名空间std的所有名字都引用了 int main()
C++入门指南选择探讨
"C++入门书籍的选择和学习策略" 在C++的学习过程中，选择合适的入门书籍至关重要。讨论中提到了几本常见的C++教材，包括《C++Primer》、《Effective C++》和《Essential C++》。这些书籍各有特点，适用于不同的学习...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值