网站建设seo方案,wordpress怎么写描述,东莞百推网络,电子商务网站建设读书笔记入门了解
注释
**作用#xff1a;**在代码中加一些注释和说明#xff0c;方便自己或者其他程序员阅读代码
两种格式#xff1a;
单行注释#xff1a;// 描述信息 通常放在一行代码的上方#xff0c;或者一条语句的末尾#xff0c;对该行代码进行说明 多行注释#x…入门了解
注释
**作用**在代码中加一些注释和说明方便自己或者其他程序员阅读代码
两种格式
单行注释// 描述信息 通常放在一行代码的上方或者一条语句的末尾对该行代码进行说明 多行注释/* 描述信息 */ 通常放在一段代码的上方对该段代码做整体说明 提示编译器在编译代码时会忽略注释的内容 代码示例
#includeiostreamusing namespace std;// 1、单行注释// 2、 多行注释/*
* main是一个程序的入口
* 每个程序都必须有这么一个函数
* 有且仅有一个
*/
int main()
{// 第17行代码的含义就在屏幕中间输出一个 hello worldcout hello world endl;system(pause);return 0;
}
变量
作用给一段指定的内存空间起名方便操作这段内存
注意**数据初始值**一定要给不给会报语法错误。【是在方法中必给在数组、结构体、类中不是必给】
语法**数据类型 变量名 数据初始值;**
代码示例
#includeiostreamusing namespace std;int main()
{// 创建变量的语法数据类型 变量名 变量初始值;int a 10;cout a a endl;system(pause);return 0;
}
常量
作用用于记录查询中不可更改的数据
注意常量值一定要给不给会报语法错误。【虽然应该没人会定义常量却不给常量值】
C定义常量两种方式
#define宏常量【实际上是编译之后做的文本替换内存中不会存在这个地址】#define 变量名 常量值 通常在文件上方定义表示一个常量。 const修饰变量const 数据类型 变量名 常量值; 通常在变量定义前加关键字const修饰该变量为常量不可修改。
代码示例
#includeiostreamusing namespace std;
// 定义宏常量
#define Day 7int main()
{cout 一周总共有: Day 天 endl;// day 8; 会报错因为常量不可修改// const 修饰变量成为常量const int month 12;cout 一年一共有: month 个月 endl;// month 13; 会报错因为常量不可修改system(pause);return 0;
} 关键字C关键字如下
作用关键字是C中预先保留的单词标识符
在定义变量和常量的时候不要使用关键字。 C关键字如下
asmdoifreturntypedefautodoubleinlineshorttypeidbooldynamic_castintsignedtypenamebreakelselongsizeofunioncaseenummutablestaticunsignedcatchexplicitnamespacestatic_castusingcharexportnewstructvirtualclassexternoperatorswitchvoidconstfalseprivatetemplatevolatileconst_castfloatprotectedthiswchar_tcontinueforpublicthrowwhiledefaultfriendregistertruedeletegotoreinterpret_casttry
提示在给变量或者常量起名称时候不要用C得关键字否则会产生歧义。
代码示例
#includeiostreamusing namespace std;int main()
{// 定义变量 数据类型 变量名 变量初始值;int a 10; // 正确// int int 3; 错误变量名不能为关键字system(pause);return 0;
}标识符命名规则
作用C规定给标识符变量、常量命名时有一套自己的规则
标识符不能是关键字标识符只能由字母、数字、下划线组成第一个字符必须为字母或者下划线标识符中字母区分大小写 建议给标识符命名时争取做到见名知意的效果方便自己和他人的阅读。 代码示例
#includeiostreamusing namespace std;int main()
{//int int 10; 标识符不可以是关键字int b 10;int _a 10; int db_x2a 2; // 标识符可以是数字、下划线、字母组成的//int 2a; 标识符不能以数字开头int a 10;int A 10;// 区分大小写system(pause);return 0;
}数据类型
C规定在创建一个变量或常量的时候必须要指定出相应的数据类型否则无法给变量分配内存
整型
作用整型变量表示的是整数类型的数据。
C中能够表示整型的类型有以下几种方式区别在于所占的内存空间不同
数据类型占用空间取值范围short(短整型)2字节(-2^15 ~ 2^15-1)32,768【三万】int(整型)4字节(-2^31 ~ 2^31-1)2,147,483,648【二十一亿】long(长整形)Windows为4字节Linux为4字节(32位)8字节(64位)(-2^31 ~ 2^31-1)2,147,483,648【二十一亿】long long(长长整形)8字节(-2^63 ~ 2^63-1)9223372036854775808
对于溢出的理解举例short 32767: 0111 1111 1111 1111 - 正数的补码为本身故补码为0111 1111 1111 1111 0 为符号位111 1111 1111 1111为数值故为 32767 32768: 1000 0000 0000 0000 - 负数的补码为反码加一故补码为:1000 0000 0000 0000 1 为符号位000 0000 0000 0000 为数值故为 -32768 32769: 1000 0000 0000 0001 - 负数的补码为反码加一故补码为:1111 1111 1111 1111 1 为符号位111 1111 1111 1111 为数值故为 -32767 代码示例
#includeiostreamusing namespace std;int main()
{/*32767: 0111 1111 1111 1111 -正数的补码为本身故补码为0111 1111 1111 11110 为符号位111 1111 1111 1111为数值故为 3276732768: 1000 0000 0000 0000 - 负数的补码为反码加一故补码为:1000 0000 0000 0000 1 为符号位000 0000 0000 0000 为数值故为 -3276832769: 1000 0000 0000 0001 - 负数的补码为反码加一故补码为:1111 1111 1111 1111 1 为符号位111 1111 1111 1111 为数值故为 -32767*/// 整型// 1. 短整型 -32768~32727short num1 32769; // 溢出后变成-32767cout num1 endl;// 2. 整型int num2 10;cout num2 endl;// 3. 长整型long num3 10;cout num3 endl;// 4. 长长整型long long num4 10;cout num4 endl;system(pause);return 0;
}sizeof关键字
作用利用sizeof关键字可以**统计数据类型所占内存大小**
语法**sizeof(数据类型 | 变量)**
代码示例
#includeiostreamusing namespace std;int main()
{// 整型short(2) int((4) long(4) long long(8)// 可以利用sizeof求出数据类型占用的内存大小short num1 10;cout c中short占用的内存空间为: sizeof(num1) endl;cout c中short占用的内存空间为: sizeof(short) endl;cout c中int占用的内存空间为: sizeof(int) endl;cout c中long占用的内存空间为: sizeof(long) endl;cout c中long long占用的内存空间为: sizeof(long long) endl;system(pause);return 0;
}整型结论short int long long long 实型浮点型
作用用于表示小数
浮点型变量分为两种
单精度float双精度double
两种的区别在于表示的有效数字范围不同。【有效数字范围是指数字的个数如3.1415926是8位数字而3141592.6也是8位数字】
数据类型占用空间有效数字范围float4字节7位有效数字double8字节15~16位有效数字
代码示例
#includeiostreamusing namespace std;int main()
{// 1、单精度 float// 2、双精度 double// 默认情况下输出一个小数会显示出6为有效数字3.14会显示3.143.1415926会显示3.14159float f1 3.14f;cout f1 f1 endl;double d1 3.14;cout d1 d1 endl;float f2 3.1415926f;cout f2 f2 endl;double d2 3.1415926;cout d2 d2 endl;// 统计float 和 double 占用的内存空间cout float: sizeof(float) endl; // 4字节cout double: sizeof(double) endl; // 8字节// 科学计数法float f3 3e4; // 3 * 10 ^ 4;cout f3 f3 endl;float f4 3e-4; // 3 * 10 ^ -4 3 * 0.1 ^ 4cout f4 f4 endl;system(pause);return 0;
}字符型
作用字符型变量用于显示单个字符【输出单个字符只能显示ASCII值中能显示的字符因此故也不会显示中文字符】
语法char ch a; 注意1在显示字符变量时用单引号将字符括起来不能使用双引号。【双引号是字符数组】 注意2字符型变量并不是把字符本身放到内存变量中而是将对于的ASCII编码放到存储单元 C和C中字符型变量只占用1个字节字符型变量并不是把字符本身放到内存变量中而是将对于的ASCII编码放到存储单元
代码示例
#includeiostreamusing namespace std;int main()
{/** 常用的ASCII值* a : 97* A : 65* 0 : 48*/char ch a;cout ch endl; // 输出a因为a对应的ASCII值是可显示字符char chinese 哈;cout chinese endl; // 不输出 哈 这个字符而是输出空白因为 哈 这个字符对应的ASCII值不是可显示字符cout char: sizeof(char) endl;cout (int)ch endl; // 输出 字符变量对应的ASCII值ch 65; // 可以直接用ASCII值给字符变量赋值cout ch endl;system(pause);return 0;
}ASCII码表格
ASCII值控制字符ASCII值字符ASCII值字符ASCII值字符0NUT32(space)6496、1SOH33!65A97a2STX3466B98b3ETX35#67C99c4EOT36$68D100d5ENQ37%69E101e6ACK3870F102f7BEL39,71G103g8BS40(72H104h9HT41)73I105i10LF42*74J106j11VT4375K107k12FF44,76L108l13CR45-77M109m14SO46.78N110n15SI47/79O111o16DLE48080P112p17DCI49181Q113q18DC250282R114r19DC351383S115s20DC452484T116t21NAK53585U117u22SYN54686V118v23TB55787W119w24CAN56888X120x25EM57989Y121y26SUB58:90Z122z27ESC59;91[123{28FS6092/12429GS6193]125}30RS6294^12631US63?95_127DEL
ASCII 码大致由以下两部分组成
ASCII 非打印控制字符 ASCII 表上的数字 0-31 分配给了控制字符用于控制像打印机等一些外围设备。ASCII 打印字符数字 32-126 分配给了能在键盘上找到的字符当查看或打印文档时就会出现。
转义字符
作用用于表示一些不能显示出来的ASCII字符
现阶段常用的转移字符有\n、\\、\t
转义字符含义ASCII码值十进制\a警报007\b退格(BS) 将当前位置移到前一列008\f换页(FF)将当前位置移到下页开头012\n换行(LF) 将当前位置移到下一行开头010\r回车(CR) 将当前位置移到本行开头013\t水平制表(HT) 跳到下一个TAB位置009\v垂直制表(VT)011\代表一个反斜线字符092’代表一个单引号撇号字符039代表一个双引号字符034?代表一个问号063\0数字0000\ddd8进制转义字符d范围0~73位8进制\xhh16进制转义字符h范围09afA~F3位16进制
代码示例
#includeiostreamusing namespace std;int main()
{// 转义字符// 换行符 \ncout hello \nworld;// 反斜杠 \\
cout \\ endl;// 水平制表符 \t // 1. 默认和前面的字符组成长度为八个字符的倍数不足八个字符倍数长度则补空格。// 2. 如果前面字符长度为8的倍数则直接补8个空格即\t一定会生效cout aaaaa\thelloworld endl; // 一个\t,前面五个a故输出5个a再加三个空格cout aa\t\thelloworld endl; // 两个\t,前面两个a故先输出2个a加6个空格【使用了2个a和一个\t】再输出8个空格【第二个\t】cout aaaaaaaa\thelloworld endl; // 1个\t,前面8个a故输出8个a和8个空格【1个\t自己对自己生效】system(pause);return 0;
}字符串型
作用表示一串字符
两种风格
C语言风格字符串char 变量名[] 字符串值;
代码示例
#includeiostream
#includestringusing namespace std;int main()
{// 1、C风格字符串// 注意事项1 char 字符串名[] // 注意事项2等号后面要用双引号包起来字符串char str[] hello world;cout str endl;return 0;
}C风格字符串 string 变量名 字符串值;
#includeiostream
#includestringusing namespace std;int main()
{// 2、C风格字符串 // 需要包含一个头文件 #includestringstring str2 hello world;cout str2 endl;system(pause);return 0;
}布尔类型
作用布尔数据类型代表真或者假的值
语法bool a1 true | false
true: 真本质是1—实际上是非0false假本质是0
bool类型占一个字节大小
代码示例
#includeiostreamusing namespace std;int main()
{bool a1 true;cout a1 endl; // 1a1 false;cout a1 endl; // 0cout bool: sizeof(bool) endl; // 1system(pause);return 0;
}数据的输入
作用用于从键盘获取数据
关键字cin
语法cin 变量;
代码示例
#includeiostreamusing namespace std;int main() {//整型输入int a 0;cout 请输入整型变量 endl;cin a;cout a endl; // 输入什么数字则输出什么数字如果超过了2^32-1,则数据只会保存2^32-1,即21亿//浮点型输入double d 0;cout 请输入浮点型变量 endl;cin d;cout d endl; // 输出精度默认为6为数字//字符型输入char ch 0;cout 请输入字符型变量 endl;cin ch;cout ch endl; // 只能输出单个字符//字符串型输入string str;cout 请输入字符串型变量 endl;cin str;cout str endl; // 只能接受一个单词如果有空格则空格之后的单词不会被输入进入//布尔类型输入bool flag true;cout 请输入布尔型变量 endl;cin flag;cout flag endl; // 输入非0的数字都是true-即1但输入字符或者0则为false-即0system(pause);return 0;
}运算符
作用用于执行代码的运算
本章我们主要讲解以下几类运算符
运算符类型作用算术运算符用于处理四则运算赋值运算符用于将表达式的值赋给变量比较运算符用于表达式的比较并返回一个真值或假值逻辑运算符用于根据表达式的值返回真值或假值
算术运算符
作用用于处理四则运算
运算符号包括以下几种
运算符术语示例结果正号33-负号-3-3加10 515-减10 - 55*乘10 * 550/除10 / 52%取模(取余)10 % 31前置递增a2; ba;a3; b3;后置递增a2; ba;a3; b2;–前置递减a2; b–a;a1; b1;–后置递减a2; ba–;a1; b2;
注意
取模时结果的符号看左边除数如 -7 % 3 -1 7 % -3 1 7 % 3 1 -7 % -3 -1 使用除法时除数不能为0使用取模时除数不能为0使用取模时除数和被除数均不能为浮点数tip➗前面的叫被除数➗后面的叫除数
代码示例1
//加减乘除
int main() {int a1 10;int b1 3;cout a1 b1 endl;cout a1 - b1 endl;cout a1 * b1 endl;cout a1 / b1 endl; //两个整数相除结果依然是整数int a2 10;int b2 0;//cout a2 / b2 endl; //报错除数不可以为0//两个小数可以相除double d1 0.5;double d2 0.25;cout d1 / d2 endl; // 除数结果为整数则返回整数system(pause);return 0;
}总结
在除法运算中除数不能为0
代码示例2
//取模
int main() {int a1 10;int b1 3;cout 10 % 3 endl; // 1int a2 10;int b2 20;cout a2 % b2 endl; // 10int 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;
}
总结
只有整数才能进行取模运算且不能为0
代码示例3
//递增
int main() {//后置递增int a 10;a; //等价于a a 1cout a endl; // 11//前置递增int b 10;b;cout b endl; // 11//区别//前置递增先对变量进行再计算表达式int a2 10;int b2 a2 * 10;cout b2 endl; // 110//后置递增先计算表达式后对变量进行int a3 10;int b3 a3 * 10;cout b3 endl; // 100system(pause);return 0;
}
赋值运算符
作用用于将表达式的值赋给变量
赋值运算符包括以下几种
运算符术语示例结果赋值a2; b3;a2; b3;加等于a0; a2;a2;-减等于a5; a-3;a2;*乘等于a2; a*2;a4;/除等于a4; a/2;a2;%模等于a3; a%2;a1;
代码示例
int main() {//赋值运算符// int a 10;a 100;cout a a endl; // 100// a 10;a 2; // a a 2;cout a a endl; // 12// -a 10;a - 2; // a a - 2cout a a endl; // 12// *a 10;a * 2; // a a * 2cout a a endl; // 20// /a 10;a / 2; // a a / 2;cout a a endl; // 5// %a 10;a % 2; // a a % 2;cout a a endl; // 0system(pause);return 0;
}比较运算符
作用用于表达式的比较并返回一个真值或假值
比较运算符有以下几种
运算符术语示例结果相等于4 30!不等于4 ! 31小于4 30大于4 31小于等于4 30大于等于4 11
代码示例
int main() {int a 10;int b 20;cout (a b) endl; // 0 cout (a ! b) endl; // 1cout (a b) endl; // 0cout (a b) endl; // 1cout (a b) endl; // 0cout (a b) endl; // 1system(pause);return 0;
}注意
在C/C语言的比较运算中 “真”用数字【1–非0即可】来表示“假”用数字【0】来表示
逻辑运算符
作用用于根据表达式的值返回真值或者假值
逻辑运算符有以下几种
运算符术语示例结果!非!a如果a为假则!a为真 如果a为真则!a为假。与a b如果a和b都为真则结果为真否则为假。或
代码示例 非
//逻辑运算符 --- 非
int main() {int a 10;cout !a endl; // 0cout !!a endl; // 1system(pause);return 0;
}代码示例 与
//逻辑运算符 --- 与
int main() {int a 10;int b 10;cout (a b) endl;// 1a 10;b 0;cout (a b) endl;// 0 a 0;b 0;cout (a b) endl;// 0system(pause);return 0;
}
代码示例 逻辑或
//逻辑运算符 --- 或
int main() {int a 10;int b 10;cout (a || b) endl;// 1a 10;b 0;cout (a || b) endl;// 1 a 0;b 0;cout (a || b) endl;// 0system(pause);return 0;
}程序流程结构
C/C支持最基本的三种程序运行结构顺序结构、选择结构、循环结构
顺序结构程序按顺序执行不发生跳转选择结构依据条件是否满足又选择的执行相应的功能循环结构依据条件是否满足循环多次执行某段代码
注意
if、while、for 后面可以直接加上分号此时相当于执行的是空语句只有for的括号里面可以不写任何表达式只把分号写了就可以if|while、do…while、switch的括号里面都必须填写内容可以使用大括号来包语句这个不是语法错误示例【这里只是演示语法开发不可能会这样使用】
#includeiostreamint main()
{// 直接写个括号包起来没有语法错误{std::cout 你好 std::endl;}// 不写括号不会语法报错。故要注意不要写错加上去了不然if无效。if (1 2);for(;;);while(1 2);do{} while (12);// if、while括号中不写判断表达式会有语法错误// if(); while(); do{}while(); 都会报错对do{}while来说单写do不写while也会报错system(pause);return 0;
}选择结构
if 语句
作用执行满足条件的语句
if 语句的三种形式
单行格式if语句多行格式if语句多条件的if语句
单行格式if语句
格式if(条件){ 条件满足执行的语句 } 示例
int main() {//选择结构-单行if语句//输入一个分数如果分数大于600分视为考上一本大学并在屏幕上打印int score 0;cout 请输入一个分数 endl;cin score;cout 您输入的分数为 score endl;//if语句//注意事项在if判断语句后面不要加分号if (score 600){cout 我考上了一本大学 endl;}system(pause);return 0;
}注意if 条件表达式后不需要加分号 多行格式if语句
格式if(条件) { 条件满足执行的语句 } else { 条件不满足执行的语句 } 示例
int main() {int score 0;cout 请输入考试分数 endl;cin score;if (score 600){cout 我考上了一本大学 endl;}else{cout 我未考上一本大学 endl;}system(pause);return 0;
}多条件if语句
格式if(条件1){ 条件1满足执行的语句 } else if(条件2) { 条件2满足执行的语句 } else if (条件3) { 条件3满足执行的语句 } ...... else { 都不满足执行的语句 } 示例 int main() {int score 0;cout 请输入考试分数 endl;cin score;if (score 600){cout 我考上了一本大学 endl;}else if (score 500){cout 我考上了二本大学 endl;}else if (score 400){cout 我考上了三本大学 endl;}else{cout 我未考上本科 endl;}system(pause);return 0;
}嵌套if语句
作用在if语句中可以嵌套的使用if语句达到更精确的条件判断
案例需求
提示用户输入一个高考考试分数根据分数做如下判断分数如果大于600分视为考上一本大于500分考上二本大于400考上三本其余视为未考上本科在一本分数中如果大于700分考入北大大于650分考入清华大于600考入人大。
示例
int main() {int score 0;cout 请输入考试分数 endl;cin score;if (score 600){cout 我考上了一本大学 endl;if (score 700){cout 我考上了北大 endl;}else if (score 650){cout 我考上了清华 endl;}else{cout 我考上了人大 endl;}}else if (score 500){cout 我考上了二本大学 endl;}else if (score 400){cout 我考上了三本大学 endl;}else{cout 我未考上本科 endl;}system(pause);return 0;
}练习案例
三只小猪称体重
有三只小猪ABC请分别输入三只小猪的体重并且判断哪只小猪最重
代码
#includeiostreamusing namespace std;int main()
{double A, B, C;cout 请分别输入三种小猪的体重 endl;cout 请输出A小猪的体重;cin A;cout 请输出B小猪的体重;cin B;cout 请输出C小猪的体重;cin C;if (A B){if (A C){cout A小猪最重体重为: A endl;}else {cout C小猪最重体重为: C endl;}}else{if (B C){cout B小猪最重体重为: B endl;}else{cout C小猪最重体重为: C endl;}}system(pause);return 0;
}三目运算符
作用通过三目运算符实现简单的判断
语法表达式1 ? 表达式2 : 表达式3
解释
如果表达式1的值为真则执行表达式2并返回表达式2的结果。
如果表达式1的值为假则执行表达式3并返回表达式3的结果。
示例
int main() {int a 10;int b 20;int c 0;c a b ? a : b;cout c c endl;//C中三目运算符返回的是变量,可以继续赋值(a b ? a : b) 100;cout a a endl;cout b b endl;cout c c endl;system(pause);return 0;
}总结
三目运算符也可以放在左边充当变量和if语句比较三目运算符的优点是短小整洁缺点是如果用嵌套的话结构不清晰。
switch 语句
**注意**当case中的执行语句超过两行时需要使用大括号{}将case中的语句给包起来否则会报语法错误。
强调一定要记得给case中的代码体加上**{}**已经出现过很多次错误了。因为不加**{}**所有的case和switch的同一级别声明变量的作用域相同加了**{}**之后每个case的变量才能限制作用域只能自己使用
作用执行多条分支语句【按编写行数顺序从上到下依次执行每一个case】
语法
switch(表达式)
{case 结果1: 执行语句;break;case 结果2: 执行语句;break;case 结果3: 执行语句;break;...default: 执行语句;break;
}代码示例
#includeiostreamusing namespace std;int main()
{//请给电影评分 //10 ~ 9 经典 // 8 ~ 7 非常好// 6 ~ 5 一般// 5分以下 烂片int score 0;cout 请给电影打分 endl;cin score;switch (score){case 10:case 9:cout 经典 endl;break;case 8:cout 非常好 endl;break;case 7:case 6:cout 一般 endl;break;default:cout 烂片 endl;break;}char c a;switch (c){case a:cout a endl;case b:cout b endl;default:cout 默认 endl;break;}string s asd;/*switch (s) // 报错因为switch只能用与整型或者字符型不能用于字符串{}*/system(pause);return 0;
}注意
switch语句中表达式类型只能是整型或者字符型。case里如果没有break那么会一直往下执行直到【case中包含break/default/所有case走完】
总结
与if语句相比对应多条件判断时switch的结果清晰执行效率高。缺点是switch不可以判断区间。
再次注意swtich一定走满足的case即如下代码的语法是合法的。 int count 1024 * 1024 * 1024;int n (count 7) / 8;int to 0, from 0;switch(count % 8) {case 0: do {to from;case 1: to from;case 2: to from;case 3: to from;case 4: to from;case 5: to from;case 6: to from;case 7: to from;} while (--n 0);}即其他case虽然是在case0里面但是如果给出的条件满足case 1...7就会直接进入对应的case相当于case:0每次都是必进的。【这个只是C的语法满足如果在JAVA就不满足了因为JAVA中Switch中的所有case需要在同一作用域下】
循环结构
while循环语句
作用满足循环条件执行循环语句
语法while(循环条件){循环语句}
解释只要循环条件为真则执行循环语句然后再次判断循环条件如果为真则再次执行循环语句无限重复直到循环条件为假则结束该循环。 示例
int main() {int num 0;while (num 10){cout num num endl;num;}system(pause);return 0;
}注意
在执行循环语句的时候程序必须提供跳出循环的出口否则会出现死循环【一般情况下是一定不能出现的】。
练习案例:猜数字
案例描述系统随机生成一个1到100之间的数字玩家进行猜测如果猜错提示玩家数字过大或过小如果猜对恭喜玩家胜利并且退出游戏。
代码示例
#includeiostreamusing namespace std;int main()
{// 添加随机数种子作用是利用当前系统时间生成随机数不然每次生成的随机数都是相同的42// time 函数需要添加头文件 #includectime// time(NULL) 会返回当前时间戳---所以才会使得每次随机数种子都不同// 也可以给自定义一个时间种子如 srand(132567984)【注这里的数字是随便输入的】// 那么就会按照这个种子来生成随机数虽然每次重启程序得到的随机数还是都一样但不是系统自带的42了。srand((unsigned int)time(NULL));int ans rand() % 100 1; // 随机生成一个数字范围在1~100cout ans endl;int num ans - 1; // 用户输入的数字,初始值肯定与ans不同while (ans ! num){cout 请输入您猜的数字: endl;cin num;if (num ans){cout 您猜测的数字过大请输入数字进行下一轮猜测 endl;}else if (num ans){cout 您猜测的数字过小请输入数字进行下一轮猜测 endl;}else {cout 恭喜您猜中啦 endl;}}system(pause);return 0;
}注意
rand() 函数可以随机生成一个数字rand()函数是需要配合 srand()函数来使用的否则每次重启程序之后生成的随机数和重启程序前生成的随机数是相同的。在 srand(unsigned int a) 传入一个整型当作时间种子即可只要时间种子不同那么每次生成的随机数不同。故想要每次时间种子都不同可使用 time(NULL)函数来获取当前时间戳作为时间种子即可保证每次时间种子都不同。随机数相同指的是第一次启动程序如果随机数是13、33、55如果时间种子相同那么第二次启动程序生成的随机数也会是13、33、55即第一次启动程序使用了n次rand()获得的数字和第二次启动程序使用了n次rand()获得的数字相同而不是说第n次rand()和第n1次rand()获得的数字相同。
do…while循环语句
作用满足循环条件执行循环语句
语法do{循环语句}while(循环条件)
注意与 while 的区别在与do...while会先执行一次循环语句再判断循环条件 代码示例
int main() {int num 0;do{cout num endl;num;} while (num 10);system(pause);return 0;
}练习案例水仙花数
案例描述水仙花数是指一个 3 位数它的每个位上的数字的 3次幂之和等于它本身
例如1^3 5^3 3^3 153
请利用do…while语句求出所有3位数中的水仙花数
代码
int main() {int num 100;do{int p1 num % 10;int p2 num / 10 % 10;int p3 num / 100 % 10;if(p1 * p1 * p1 p2 * p2 * p2 p3 * p3 * p3 num){cout num 是水仙花数 endl;}num;} while (num 1000);system(pause);return 0;
}for 循环语句
作用满足循环条件执行循环语句
语法for(起始表达式;条件表达式;末尾循环体) {循环语句}
示例
int main() {for (int i 0; i 10; i){cout i endl;}system(pause);return 0;
}详解 注意
for循环中【小括号】的表达式要用分号进行分割while、do…while、for 都是开发中常用的循环语句for循环结构比较清晰比较常用for常用于知道要执行多少次的循环while/do…while常用于不知道要执行多少次但会有条件发生改变的循环
练习案例敲桌子
案例描述从1开始数到数字100 如果数字个位含有7或者数字十位含有7或者该数字是7的倍数我们打印敲桌子其余数字直接打印输出。
代码
#includeiostreamusing namespace std;int main()
{for (int i 1; i 99; i){if (i % 7 0 || i / 10 7 || (i / 7 0 i 7)){cout i 是敲桌子数 endl;}}system(pause);return 0;
}嵌套循环
作用在循环体中再嵌套一层循环解决一些实际问题
例如我们想在屏幕中打印如下图片就需要利用嵌套循环 示例
int main() {//外层循环执行1次内层循环执行1轮for (int i 0; i 10; i){for (int j 0; j 10; j){cout * ;}cout endl;}system(pause);return 0;
}练习案例乘法口诀表
案例描述利用嵌套循环实现九九乘法表
代码
int main() {//外层循环执行1次内层循环执行1轮for (int i 1; i 9; i){for (int j 1; j i ; j){cout i * j i * j \t;}cout endl;}system(pause);return 0;
}跳转语句
break语句
作用用于跳出选择结构或者循环结构
break使用的时机
出现在switch条件的语句中作用是终止当前case并跳出switch出现在循环语句中作用是跳出当前的循环语句出现在嵌套循环中跳出最近的内层循环语句
示例switch:
int main() {//1、在switch 语句中使用breakcout 请选择您挑战副本的难度 endl;cout 1、普通 endl;cout 2、中等 endl;cout 3、困难 endl;int num 0;cin num;switch (num){case 1:cout 您选择的是普通难度 endl;break;case 2:cout 您选择的是中等难度 endl;break;case 3:cout 您选择的是困难难度 endl;break;}system(pause);return 0;
}示例for:
int main() {//2、在循环语句中用breakfor (int i 0; i 10; i){if (i 5){break; //跳出循环语句}cout i endl;}system(pause);return 0;
}示例嵌套循环
int main() {//在嵌套循环语句中使用break退出内层循环for (int i 0; i 10; i){for (int j 0; j 10; j){if (j 5){break;}cout * ;}cout endl;}system(pause);return 0;
}注意break只能影响自己所在的循环不能影响更外层的循环即嵌套循环只能跳出内存循环而不会影响外层循环。
continue语句
作用在循环语句中跳过本次循环中剩余尚未执行的语句继续执行下一次循环。
示例
int main() {for (int i 0; i 100; i){if (i % 2 0){continue;}cout i endl;}system(pause);return 0;
}注意continue并没有使整个循环终止只是直接开始下一次循环而break会终止掉整个循环。
goto 语句
作用可以无条件跳转语句
语法
goto 标记;
...
标记:
...【标记的名称一般习惯字母全大写】
解释如果标记的名称存在执行到goto语句时会跳转到标记的位置。如果标记的名称不存在则会报语法错误。
示例
int main() {cout 1 endl;goto FLAG;cout 2 endl;cout 3 endl;cout 4 endl;FLAG:cout 5 endl;system(pause);return 0;
}注意
在程序中不建议使用goto语句以免造成程序流程混乱如果真的使用了一定要注意不能导致死循环
数组
概述
所谓数组就是一个集合里面存放了相同类型的数据元素
特点1数组中的每个font stylecolor:rgb(51, 51, 51);数据元素都是相同的数据类型/font
特点2数组是由font stylecolor:rgb(51, 51, 51);连续的内存/font位置组成的
一维数组
一维数组定义方式
一维数组定义的三种方式
数据类型 数组名[数组长度];【此时所有值均为垃圾值】数据类型 数组名[数组长度] {值1,值2,...};【此时不够数据长度的值补0】、【如果值的数量比数组长度要长那么会报错】数据类型 数组名[] {值1,值2,...};【给的值的长度就是数组的长度】
int main() {//定义方式1//数据类型 数组名[元素个数];int score[10];//利用下标赋值score[0] 100;score[1] 99;score[2] 85;// 剩余未定义的score[3~9]都是垃圾值//利用下标输出cout score[0] endl;cout score[1] endl;cout score[2] endl;//第二种定义方式//数据类型 数组名[元素个数] {值1值2 值3 ...};//如果{}内不足10个数据剩余数据用0补全int score2[10] { 100, 90,80,70,60,50,40,30,20,10 };//逐个输出//cout score2[0] endl;//cout score2[1] endl;//一个一个输出太麻烦因此可以利用循环进行输出for (int i 0; i 10; i){cout score2[i] endl;}//定义方式3//数据类型 数组名[] {值1值2 值3 ...};int score3[] { 100,90,80,70,60,50,40,30,20,10 };// 此时数组的长度就是给的值的个数for (int i 0; i 10; i){cout score3[i] endl;}system(pause);return 0;
}注意
数组名的命名规范与变量名规范一致不要和变量重名数组中下标是从0开始的索引
一维数组数组名称的作用
一维数组名称的用途
可以统计整个数组在内存中的长度可以获取数组在内存中的首地址
代码示例
int main() {//数组名用途//1、可以获取整个数组占用内存空间大小int arr[10] { 1,2,3,4,5,6,7,8,9,10 };cout 整个数组所占内存空间为 sizeof(arr) endl;cout 每个元素所占内存空间为 sizeof(arr[0]) endl;cout 数组的元素个数为 sizeof(arr) / sizeof(arr[0]) endl;//2、可以通过数组名获取到数组首地址cout 数组首地址为 (int)arr endl;cout 数组中第一个元素地址为 (int)arr[0] endl;cout 数组中第二个元素地址为 (int)arr[1] endl;//arr 100; //错误数组名是常量因此不可以赋值//arr[0] 100; // 错误地址是常量不可以赋值system(pause);return 0;
}注意
数组名【地址】是常量不可以赋值。直接打印数组名可以查看数组所占内存的首地址对数组名进行sizeof可以获取整个数组占内存内存空间的大小
练习案例五只小猪称体重
案例描述
在一个数组中记录了五只小猪的体重如int arr[5] {300,350,200,400,250};
找出并打印最重的小猪体重。
int main() {//数组名用途//1、可以获取整个数组占用内存空间大小int arr[5] { 300,350,200,400,250 };int maxI 0, maxW arr[i];for(int i 1; i 5; i){if(arr[i] maxW){maxI i;maxW arr[i];}}cout 第 i 只小猪最重体重为 maxW endl;system(pause);return 0;
}练习案例数组元素逆置
案例描述请声明一个5个元素的数组并且将元素逆置.
(如原数组元素为1,3,2,5,4;逆置后输出结果为:4,5,2,3,1);
int main() {//数组名用途//1、可以获取整个数组占用内存空间大小int arr[5] { 1,3,2,5,4 };for(int i 0, j 5 - 1; i j; i, j--){int temp arr[i];arr[i] arr[j];arr[j] temp;}for(int i 0; i 5; i){cout arr[i] ;}system(pause);return 0;
}冒泡排序
作用 最常用的排序算法对数组内元素进行排序
比较相邻的元素。如果第一个比第二个大就交换他们两个。对每一对相邻元素做同样的工作执行完毕后找到第一个最大值。重复以上的步骤每次比较次数-1直到不需要比较 示例 将数组 { 4,2,8,0,5,7,1,3,9 } 进行升序排序
int main() {int arr[9] { 4,2,8,0,5,7,1,3,9 };int n sizeof(arr) / sizeof(arr[0]);for(int i 0; i n - 1; i){for(int j 0; j n - i - 1; j){if(arr[j] arr[j 1]){int temp arr[i];arr[i] arr[j];arr[j] temp;}}}for (int i 0; i n; i){cout arr[i] endl;}system(pause);return 0;
}二维数组
二维数组就是一维数组上多加一个维度
二维数组的定义方式
二维数组的四种定义方式
数据类型 数组名[行数][列数];【此时所有的值均为垃圾值】数据类型 数组名[行数][列数] { {数据1,数据2}, {数据3,数据4} };【此时未定义的数据由0填充】、【如果数据的长度比行数/列数要长那么会报错】数据类型 数组名[行数][列数] {数据1,数据2,数据3,数据4};【此时未定义的数据由0填充】、【如果数据的长度比行数*列数要长那么会报错】数据类型 数组名[][列数] {数据1,数据2,数据3,数据4};长度不够一列的由0填充至一列的长度
建议使用第二种定义形式更加直观可以提高代码的可读性
代码示例
int main() {//方式1 //数组类型 数组名 [行数][列数]int arr[2][3];arr[0][0] 1;arr[0][2] 3;arr[1][0] 4;arr[1][2] 6;for (int i 0; i 2; i){for (int j 0; j 3; j){cout arr[i][j] ;}cout endl;}//方式2 //数据类型 数组名[行数][列数] { {数据1数据2 } {数据3数据4 } };int arr2[2][3] {{1,2},{4,5}};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 }; 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 };for (int i 0; i 2; i){for (int j 0; j 3; j){cout arr4[i][j] ;}cout endl;}system(pause);return 0;
}总结
在定义二维数组的时候如果初始化了数据可以省略行数
二维数组数组名称的作用
二维数组名称的用途
查看二维数组所占内存空间获取二维数组首地址
代码示例
int main() {//二维数组数组名int arr[2][3] {{1,2,3},{4,5,6}};cout 二维数组大小 sizeof(arr) endl;cout 二维数组一行大小 sizeof(arr[0]) endl;cout 二维数组元素大小 sizeof(arr[0][0]) endl;cout 二维数组行数 sizeof(arr) / sizeof(arr[0]) endl;cout 二维数组列数 sizeof(arr[0]) / sizeof(arr[0][0]) endl;//地址cout 二维数组首地址 arr endl;cout 二维数组第一行地址 arr[0] endl;cout 二维数组第二行地址 arr[1] endl;cout 二维数组第一个元素地址 arr[0][0] endl;cout 二维数组第二个元素地址 arr[0][1] endl;system(pause);return 0;
}总结
二维数组名就是这个数组的首地址对二维数组名进行sizeof时可以获取整个二维数组所占用内存空间的大小
二维数组应用案例
考试成绩统计
案例描述有三名同学张三李四王五在一次考试中的成绩分别如下表请分别输出三名同学的总成绩
语文数学英语张三100100100李四9050100王五607080
int main() {int scores[3][3] {{100, 100 ,100},{90, 50, 100},{60, 70, 80}};string names[3] {张三, 李四, 王五};string subjects[3] {语文, 数学, 英语};for(int i 0; i 3; i){cout names[i] 同学的得分情况为 ;for(int j 0; j 3; j){cout subjects[j] : scores[i][j] \t;}cout endl;}system(pause);return 0;
}函数
概述
作用将一段经常使用的代码封装起来减少重复代码
解释一个较大的程序一般分为若干个程序块每个模块实现特定的功能。
函数的定义
函数的定义一般主要有5个步骤
返回值类型函数名参数列表函数体语句return 表达式
语法
返回值类型 函数名 参数列表
{函数体语句return 表达式}返回值类型一个函数可以返回一个值。函数名给函数起名称【同一个命名空间下函数名唯一】参数列表使用该函数时传入的数据函数体语句花括号内的代码函数内需要执行的语句return 表达式和返回值类型挂钩函数执行完成后返回相应的数据
示例定义一个加法函数实现两个数相加
//函数定义
int add(int num1, int num2)
{int sum num1 num2;return sum;
}函数的调用
功能使用定义好的函数
语法函数名(参数)
示例
int add(int num1, int num2)
{return num1 num2;
}int main()
{int a 10;int b 10;// 调用add函数int sum add(a, b); // 调用时的ab成为实际参数简称实参cout sum sum endl;a 100;b 100;sum add(a, b);cout sum sum endl;system(pause);return 0;
}总结
函数定义里的小括号内称为形参函数调用时传入的参数称为实参
值传递
所谓值传递就是函数调用时实参将数值传入给形参值传递时如果形参发生改变并不会影响实参。
示例
void swap(int num1, int num2)
{cout 交换前 endl;cout num1 num1 endl;cout num2 num2 endl;int temp num1;num1 num2;num2 temp;cout 交换后 endl;cout num1 num1 endl;cout num2 num2 endl;//return ; 当函数声明时候不需要返回值可以不写return
}int main() {int a 10;int b 20;swap(a, b);cout mian中的 a a endl;cout mian中的 b b endl;system(pause);return 0;
}总结
值传递时形参是改变不了实参的
函数的常见样式
常见的函数样式有4种
无参无返无参有返有参无返有参有返
示例
//函数常见样式
//1、 无参无返
void test01()
{//void a 10; //无类型不可以创建变量,原因无法分配内存cout this is test01 endl;//test01(); 函数调用
}//2、 有参无返
void test02(int a)
{cout this is test02 endl;cout a a endl;
}//3、无参有返
int test03()
{cout this is test03 endl;return 10;
}//4、有参有返
int test04(int a, int b)
{cout this is test04 endl;int sum a b;return sum;
}/函数的声明
作用告诉编译器函数名称以及如何调用函数。函数的实际主体可以单独定义
规则函数的声明可以多次【虽然可以多次但基本上只会声明一次因为多了也没什么用】但是函数的定义只能有一次【定义其实就相当于是特殊的声明了】。
示例
//声明可以多次定义只能一次
//声明
int max22(int a, int b);
int max22(int a, int b);
//定义
int max22(int a, int b)
{return a b ? a : b;
}int main() {int a 100;int b 200;cout max22(a, b) endl;system(pause);return 0;
}注意函数的一定要在**main**方法之前有过至少一次声明否则该方法无效。
错误写法
int main() {int a 100;int b 200;// 报错找不到该方法因为编译是从上到下编译的max定义在main函数的下方// 当扫码到main函数的时候还没有找到max这个函数故报错了cout max22(a, b) endl;system(pause);return 0;
}//定义
int max22(int a, int b)
{return a b ? a : b;
}不规范但可以运行的写法
//定义
int max22(int a, int b)
{return a b ? a : b;
}int main() {int a 100;int b 200;// 不报错因为main编译到main函数的时候已经扫描到max函数了// 定义函数就相当于是一次特殊的声明声明过函数就能找到了cout max22(a, b) endl;system(pause);return 0;
}正常写法
//声明可以多次定义只能一次
//声明
int max22(int a, int b);
int max22(int a, int b);int main() {int a 100;int b 200;cout max22(a, b) endl;system(pause);return 0;
}//定义--可以放在main方法前面也可以方法在main方法后面
int max22(int a, int b)
{return a b ? a : b;
}函数的分文件编写
**作用**让代码结构更加清晰
函数分文件编写一般有4个步骤
创建后缀名为.h的头文件创建后缀名为.cpp的源文件在头文件中写函数的声明在源文件中写函数的定义
代码示例:
//swap.h文件//实现两个数字交换的函数声明
void swap22(int a, int b);
//swap.cpp文件
#include swap.h
// 因为下面用到了 cout所以需要加上 iostream
#includeiostream
// 因为下面的cout、endl,没有加上命名空间需要加上了这段
using namespace std;void swap22(int a, int b)
{int temp a;a b;b temp;cout a a endl;cout b b endl;
}//main函数文件
#include swap.h
int main() {int a 100;int b 200;swap22(a, b);system(pause);return 0;
}
指针
指针的基本概念
指针的作用可以通过指针间接访问内存
内存编号是从0开始记录的一般用十六进制数字表示可以利用指针变量保存地址
指针变量的定义和使用
指针变量定义语法事件类型 * 变量名;
示例
#includeiostreamusing namespace std;int main()
{// 1、指针的定义int a 10; // 定义整型变量a// 指针定义语法事件类型 * 变量名;int* p;// 指针变量赋值p a;cout a endl; // 打印a的地址cout p endl; // 打印指针变量p 【实际上也是地址】// 2、指针的使用// 通过 * 操作指针变量指向的内存cout *p *p endl;system(pause);return 0;
}指针变量和普通变量的区别
普通变量存放的是数据指针变量存放的是地址。指针变量可以通过 *操作符来操作指针变量指向的内存空间这个过长称为解引用
总结
我们可以通过 符号获取变量的地址利用指针可以记录地址对指针变量进行解引用可以操作指针指向的内存
指针所占内存空间
提问指针也是数据类型那么这种数据类型占用多少内存空间
示例
int main() {int a 10;int * p;p a; //指针指向数据a的地址cout *p endl; //* 解引用cout sizeof(p) endl;cout sizeof(char *) endl;cout sizeof(float *) endl;cout sizeof(double *) endl;system(pause);return 0;
}总结
**所有指针类型在 ****32位操作系统**下是4个字节**所有指针类型在 ****64位操作系统**下是8个字节
在VIsual Studio中可以点击这里切换操作系统
空指针和野指针
空指针
空指针指针变量指向内存编号为0的空间
用途初始化指针变量
注意空指针指向的内存是不可以访问的
代码示例
#includeiostreamint main()
{//指针变量p指向内存地址编号为0的空间int* p NULL; //实际上NULL就是数字0故可以直接写0即 int * p 0;std::cout p;// 访问空指针报错//内存编号0~255为系统占用内存不允许用户访问*p 123;std::cout *p;return 0;
}注意直接点击运行可能不会报错但是调试运行肯定会报错的。 野指针
解释指针变量执向非法的内存空间【如0~255编号的内存】
#includeiostreamusing namespace std;int main()
{//指针变量p指向内存地址编号为0x12的空间int* p (int *)0x12;//访问野指针报错 cout *p endl;return 0;
}注意直接点击运行可能不会报错但是调试运行肯定会报错的。【后续有报错的地方将不再提示注意自己学会点击调试】 总结
空指针和野指针都不是我们申请的空间因此不要访问。
const修饰指针
const修饰指针有三种情况
const修饰指针 ——常量指针const修饰常量 ——指针常量const即修饰指针有修饰常量
代码示例
int main() {int a 10;int b 10;//const修饰的是指针指针指向可以改指针指向的值不可以更改const int * p1 a; p1 b; //正确//*p1 100; 报错//const修饰的是常量指针指向不可以改指针指向的值可以更改int * const p2 a;//p2 b; //错误*p2 100; //正确//const既修饰指针又修饰常量const int * const p3 a;//p3 b; //错误//*p3 100; //错误system(pause);return 0;
}技巧看const右侧紧跟的是指针还是常量是指针就是常量指针是常量就是指针常量。
const int * p称为常量指针【先常量再指针】const修饰的是int *即修饰的*故不能进行任何直接跟*相关的操作即*p 20会报错故值不能修改只能修改指向。故称为常量指针即值不能变——常量但是可以修改指向——指针。int * const p称为指针常量【先指针再常量】const修饰的是p故不能进行任何直接跟p相关的操作即p c会报错故不能修改指针指向但可以修改值的内容。故被称为指针常量即值可以变——指针不能修改指向——常量【指针】
指针和数组
作用利用指针访问数组中元素
代码示例
#includeiostreamusing namespace std;int main()
{int a[] { 1,2,3,4,5,6,7,8,9,10 };int* p a;//指向数组的指针cout 第一个元素 a[0] endl;cout 指针访问第一个元素 *p endl;for (int i 0; i 10; i){cout a[i] endl;}for (int i 0; i 10; i){cout *p endl;p;}system(pause);return 0;
}指针和函数
作用利用指针作为函数参数可以修改实参的值
代码示例
#includeiostreamusing namespace std;//值传递
void swap1(int a, int b)
{int temp a;a b;b temp;
}
// 地址传递
void swap2(int* a, int* b)
{int temp *a;*a *b;*b temp;
}int main()
{int a 10;int b 20;cout a : b endl;swap1(a, b);//值传递不会改变实参cout a : b endl;swap2(a, b);//地址传递会改变实参cout a : b endl;return 0;
}总结不想修改实参就用值传递如果想要修改实参就用地址传递。
指针、数组、函数结合使用的案例
案例描述封装一个函数利用冒泡排序实现对整型数组的升序排序
例如数组int arr[10] { 4,3,6,9,1,2,10,8,7,5 };
//冒泡排序函数
void bubbleSort(int * arr, int len) //int * arr 也可以写为int arr[]
{for (int i 0; i len - 1; i){for (int j 0; j len - 1 - i; j){if (arr[j] arr[j 1]){int temp arr[j]; // 这里也可以使用 *(arr j)arr[j] arr[j 1];arr[j 1] temp;}}}
}//打印数组函数
void printArray(int arr[], int len)
{for (int i 0; i len; i){cout arr[i] endl;//也可以输入 *arr然后arr;}
}int main() {int arr[10] { 4,3,6,9,1,2,10,8,7,5 };int len sizeof(arr) / sizeof(int);bubbleSort(arr, len);printArray(arr, len);system(pause);return 0;
}总结当数组名传入函数作为参数时将退化为指向首元素的指针
方法中传入常量作为指针
结论传入常量使用时会报错【不管是系统自带的常量【如数字、字符串】还是程序员自定义的常量】
原因非法地址不可访问 代码示例
#includeiostreamusing namespace std;void test(int* a, int* b)
{cout *a endl;cout *b endl;
}int main()
{const int a 22;//test((int*) a, (int*) a); 报错//test((int*)33, (int *)44); 报错int b 22;int c 33;test(b, c); //正常运行system(pause);return 0;
}解决办法无法直接解决上述问题但可以通过…没有但是。
但可以使用形参常量指针来接受实参常量指针来达到类似的效果
代码示例
#includeiostreamusing namespace std;void test(const int* a, const int* b)
{cout *a endl;cout *b endl;
}int main()
{const int* a new int(22);test(a, a);system(pause);return 0;
}结构体
结构体的基本概念
结构体属于用户自定义的数据类型运行用户储存不同的数据类型
结构体的定义和使用
语法struct 结构体名{ 结构体成员列表 };
通过结构体创建变量的方式有三种
struct 结构体名 变量名struct 结构体名 变量名 {成员1值成员2值…}定义结构体时顺便创建变量
代码示例
#includeiostreamusing namespace std;struct Student
{int age;string name;int score;
}stu4;int main()
{//结构体变量创建方式1struct Student stu1;cout stu1.age endl;//垃圾值stu1.age 12;stu1.name 小花;stu1.score 99;cout stu1.age : stu1.name : stu1.score endl;//结构体变量创建方式1【struct可以省略】Student stu2;cout stu2.age endl;//垃圾值stu2.age 18;stu2.name 小黑;stu2.score 66;cout stu2.age : stu2.name : stu2.score endl;//结构体变量创建方式2Student stu3 { 20, 小白};//没写的值自动给0cout stu3.age : stu3.name : stu3.score endl;//结构体变量创建方式3 cout stu4.age endl;//跟随结构体定义的变量默认有初始值为0stu4.age 33;stu4.name 大红;stu4.score 22;cout stu4.age : stu4.name : stu4.score endl;return 0;
}总结
定义结构体的关键字是struct不可省略创建结构体变量时关键字struct可以省略结构体变量利用操作符.访问成员跟随结构体定义的变量的所有字段默认有初始值为0结构体变量创建方式2给的成员值是和结构体的字段按顺序一一对应的且没写的成员值会自动给0。
结构体数据
**作用**将自定义的结构体放入到数组中方便维护
语法struct 结构体名 数组名[元素格个数] { {}, {}, {}}【struct可以省略不写】
补充定义方式和一维数组是类似的都是三种只不过把定义方式中的数据类型换成了结构体名罢了。
代码示例
#includeiostreamusing namespace std;struct Student
{int age;string name;int score;
};void pri(Student a[], int n)
{for (int i 0; i n; i){cout a[i].age : a[i].name : a[i].score endl;}cout endl;
}int main()
{Student a1[10];a1[0] { 1,花,20 };pri(a1, 2);//剩余的结构体变量中的字段都是垃圾值Student a2[10] { { 1,花,20 } ,{ 1,花,20 } };pri(a2, 3);//剩余的结构体变量中的字段都是默认值Student a3[] { { 1,花,20 } ,{ 1,花,20 } ,{ 1,花,20 } };pri(a3, 3);//长度为3正常输出值// 不存在第4个变量输出int类型的字段输出垃圾值,输出string类型的字段直接报错··············cout a3[3].age : a3[3].name : a3[3].score endl;system(pause);return 0;
}总结
定义方式和一维数组的定义方式一样都是三种都是统一的定义格式只不过把数据类型换成了结构体名不同定义方式给的字段的默认值都是相同规则的不要越界输出结构体的内容否则会报错的【可能会报错所以还是不要使用的好】
结构体指针
**作用**通过指针访问结构体中的成员
利用操作符-可以通过结构体指针访问结构体属性
代码示例
//结构体定义
struct student
{//成员列表string name; //姓名int age; //年龄int score; //分数
};int main() {student stu { 张三,18,100, };student * p stu;p-score 80; //指针通过 - 操作符可以访问成员cout 姓名 p-name 年龄 p-age 分数 p-score endl;system(pause);return 0;
}结构体嵌套结构体
**作用**结构体中的成员可以是另一个结构体
**例如**每一个老师辅导一个学生一个老师的结构体中记录一个学生的结构体
代码示例
//学生结构体定义
struct student
{//成员列表string name; //姓名int age; //年龄int score; //分数
};//教师结构体定义
struct teacher
{//成员列表int id; //职工编号string name; //教师姓名int age; //教师年龄// 使用结构体时关键字struct可以省略不写student stu; //子结构体 学生
};int main() {struct teacher t1;t1.id 10000;t1.name 老王;t1.age 40;t1.stu.name 张三;t1.stu.age 18;t1.stu.score 100;cout 教师 职工编号 t1.id 姓名 t1.name 年龄 t1.age endl;cout 辅导学员 姓名 t1.stu.name 年龄 t1.stu.age 考试分数 t1.stu.score endl;system(pause);return 0;
}**总结**在实际问题中经常会用到一个结构体作为另一个结构体的成员
结构体作为函数参数
**作用**将结构体中作为参数向函数中传递
传递方式有两种
值传递地址传递
代码示例
//学生结构体定义
struct student
{//成员列表string name; //姓名int age; //年龄int score; //分数
};//值传递
void printStudent(student stu )
{stu.age 28;cout 子函数中 姓名 stu.name 年龄 stu.age 分数 stu.score endl;
}//地址传递
void printStudent2(student *stu)
{stu-age 28;cout 子函数中 姓名 stu-name 年龄 stu-age 分数 stu-score endl;
}int main() {student stu { 张三,18,100};//值传递printStudent(stu);cout 主函数中 姓名 stu.name 年龄 stu.age 分数 stu.score endl;cout endl;//地址传递printStudent2(stu);cout 主函数中 姓名 stu.name 年龄 stu.age 分数 stu.score endl;system(pause);return 0;
}总结
传递方式和普通的数据类型的传递方式是一样的不想修改实参就用值传递想要修改实参就用地址传递
结构体中const的使用场景
分析
方法的形参只有值传递和地址传递两种形式。值传递相当于把实参对象给copy一份出来当作形参那么实参的内存空间多大形参的内存空间就有多大相当于需要消耗两倍的实参空间。且在方法中对形参中的任何修改都不会影响到实参。地址传递是把实参对象的内存对应的地址传入到函数中形参接受到的是实参的内存地址所以形参的内存空间只占8个字节32位电脑占4个字节。故消耗的内存是实参的内存8个字节。且方法中对形参的修改会影响到实参。【相当于是对同一片内存地址空间内容的修改】注意地址传递的形参如果修改指针指向实参的指向并不会被修改。很简单假设实参是A形参是B那么此时B是指向A的即B-A,而A是指向自己的也是代表自己。在方法中如果修改B的属性内容那么B指向AB修改属性内容相当于修改的A内存空间的属性的内容。如果在方法中把B指向C此时B-C而A是没有任何影响的因为只是B不指向A的地址了而是指向C的地址了。此时A还是自己即AA。【实际理解是B存放的是地址B存放的内容从A变成C了。而不是说B直接是等于A的令BC就让AC了这是错误的理解。】
作用使用const防止误操作
代码示例
#includeiostreamusing namespace std;struct Student
{int age;string name;int score;
};void play(Student st)
{cout st.name : st.age : st.score endl;
}void ff1(Student st)
{st.name 大大;//值传递不影响实参
}void ff2(Student * st)
{st-name 大大;// 地址传递实参同步修改
}Student st09 { 20, 09指针, 90 };void ff3(Student* st)
{st st09;//对实参没有影响实参还是自己只不过这里的st形参指向变成了st09罢了
}void ff4(const Student* st)
{//st-name 小绿; //这行报错因为常量指针不能修改内容
}int main()
{Student st1 { 12, 小花, 33 };play(st1);ff1(st1);play(st1);ff2(st1);play(st1);ff3(st1);play(st1);system(pause);return 0;
}结构体案例
案例1
案例描述
学校正在做毕设项目每名老师带领5个学生总共有3名老师需求如下
设计学生和老师的结构体其中在老师的结构体中有老师姓名和一个存放5名学生的数组作为成员
学生的成员有姓名、考试分数创建数组存放3名老师通过函数给每个老师及所带的学生赋值
最终打印出老师数据以及老师所带的学生数据。
注意
字符串定义的时候不能使用拼接会报错。在之后可以拼接
#includeiostream
#includestring
#includectimeusing namespace std;struct Student
{string name;int score;
};struct Teacher
{string name;Student stu[5];
};void setStudent(Teacher te[])
{string teacherName 老师;string studentName 学生;string nameSeed ABCDE;for (int i 0; i 3; i){te[i].name teacherName nameSeed[i];for (int j 0; j 5; j){te[i].stu[j].name studentName nameSeed[j];te[i].stu[j].score (rand() % 100) 10;}}
}void printStudent(Teacher te[])
{for (int i 0; i 3; i){cout te[i].name : \t;for (int j 0; j 5; j){cout te[i].stu[j].name : te[i].stu[j].score \t;}cout endl;}
}int main()
{Teacher te[3];srand(time(NULL));setStudent(te);printStudent(te);system(pause);return 0;
}案例2
案例描述
设计一个英雄的结构体包括成员姓名年龄性别;创建结构体数组数组中存放5名英雄。
通过冒泡排序的算法将数组中的英雄按照年龄进行升序排序最终打印排序后的结果。
五名英雄信息如下
:::info {“刘备”,23,“男”}, {关羽,22,男},{张飞,20,男},{赵云,21,男},{貂蝉,19,女},:::
代码示例
#includeiostream
#includestringusing namespace std;struct Hero
{string name;int age;string sex;
};void swap(Hero* o1, Hero* o2);void bullbe(Hero hero[], int n)
{for (int i 0; i n - 1; i){for (int j 0; j n - i - 1; j){if (hero[j].age hero[j 1].age){swap(hero[j], hero[j 1]);}}}
}void swap(Hero * o1, Hero * o2)
{Hero hero *o1;*o1 *o2;*o2 hero;// 两种交换方式任选其一/*int age o1-age;string name o1-name;string sex o1-sex;o1-age o2-age;o1-name o2-name;o1-sex o2-sex;o2-age age;o2-name name;o2-sex sex;*/
}void printHero(Hero hero[], int n)
{for (int i 0; i n; i){cout hero[i].name : hero[i].age : hero[i].sex endl;}
}int main()
{Hero hero[] {{刘备,23,男},{关羽,22,男},{张飞,20,男},{赵云,21,男},{貂蝉,19,女}};//int n sizeof(hero) / sizeof(hero[0]);// 两种获取数组长度大小的方式int n sizeof(hero) / sizeof(Hero);bullbe(hero, n);printHero(hero, n);system(pause);return 0;
}总结案例
通讯录管理系统
