C++零基础自学笔记

第一课 数据类型

#include<iostream>
using namespace std;
/*main是一个程序的入口
每个程序都必须有一个函数
有且仅有一个
*/
int main(){
?? ?
?? ?//变量创建的语法；数据类型? 变量名=变量初始值
?? ?int a=10;
?? ?cout << "hello word"? <<endl ; //换行输出 ?无endl 内容输出在一行?
?? ?system("pause");
?? ?return 0;
}

-------------

#include<iostream>
using namespace std;
//常量的定义方式
//1.#define 宏常量
//2. const修饰的变量
#define DAY 7 ?
int main(){
?? ? //DAY=14 错误，day是常量，一旦修改就会报错
?? ? cout <<"一周共有" << DAY? <<"天" <<endl;
// const修饰变量
????? const int month=12;
// month=24 错误，const修饰的变量也称为常量
???? cout << "一年总共有：" << month? << "个月份"? <<endl;


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

-------------------? 加法（变量命名规则，与python一致）

#include<iostream>
using namespace std;


int main(){
int number1=10;
int number2=30;
int sum=number1+number2;

????? cout << sum <<endl ;

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

----------------整型数据类型

short 短整型 2字节

int????? 整型 ?? 4字节

long? 长整型? win4字节，linux4字节（32位），linux8字节（64位）

long long? 长长整型?? 8字节

#include<iostream>
using namespace std;

int main(){
?? ?//short < int <= long <= long long
short num1=32768;? //-32768~32767
int num2=32768;
long num3=10;
long long num4=10;

????? cout << "num1=" << num1 <<endl ;
?? ?cout << "num2=" << num2 <<endl ;
?? ?cout << "num3=" << num3 <<endl ;
?? ?cout << "num4=" << num4 <<endl ;
?? ?//sizeof ?? ?求数据类型占用内存大小
?? ?cout << "short占用内存空间为：" << sizeof (num1) <<endl ;
?? ?cout << "short占用内存空间为：" << sizeof (short) <<endl ;
?? ?cout << "int占用内存空间为：" << sizeof (num2) <<endl ;
cout << "long占用内存空间为：" << sizeof (num3) <<endl ;
cout << "long long占用内存空间为：" << sizeof (num4) <<endl ;
?? ?system("pause");
?? ?return 0;
}

----------------实型（浮点型）数据类型? 用于表示小数

1.单精度float?? 4字节? 7位有效数（小数点前后的数字）

2.双精度 double?? 8字节? 15-16有效数

若为小数，二者都默认为6位

3.科学计数法
#include<iostream>
using namespace std;

int main(){
float f1=3.14f;//加f表示其为单精度，若不加，会默认为双精度
double d1=3.14;
float f2=3e2; //相当于3*10的2次方 =300
//3.科学计数法
cout<<"f2="<<f2 <<endl;
float f3=3e-2; //相当于3*0.1的2次方 =0.03
cout<<"f3="<<f3 <<endl;
cout << "float 单精度="<<f1 <<endl ;
cout <<"double? 双精度="<<d1 <<endl ;
cout << "float占用内存空间为：" << sizeof (float) <<endl ;
cout << "double占用内存空间为：" << sizeof (double) <<endl ;
?? ?system("pause");
?? ?return 0;
}

第二课 运算符

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

现阶段常用? \n \\? \t

\n? 换行 将当前位置移到下一行开头

\r? 回车，将当前位置移到本行开头

\t? 水平制表（跳到下一个TAB位置）

\\? 一个反斜线字符\

#include<iostream>
using namespace std;

int main(){
cout << "hello word\n";????? //5.6行功能一致 结果一致
cout << "hello word"? <<endl;
cout << "\\"? <<endl;
cout << "aaa\thelloword"? <<endl;? //a后面5个空格? 一个t为8个 若aaaa则有4个空格
cout << "a\thelloword"? <<endl;
cout << "aa\thelloword"? <<endl;
cout << "aaaaaa\thelloword"? <<endl;? //7-10 helloword对齐
?? ?system("pause");
?? ?return 0;
}

----------------------------字符串

c风格字符串???? char? 变量名[]="字符串值"

c++风格字符串????? string 变量名=“字符串值”? 需要加入头文件#include<string>

#include<iostream>
using namespace std;
#include <string>? //使用c++字符串时所要包含的头文件
int main(){
//c风格
char str[]="hello word";
cout <<str <<endl;
//c++风格
string str2 ="hello word";
cout << str2 <<endl;
?? ?system("pause");
?? ?return 0;
}

----------------------------布尔类型

布尔两个值? true 1? 和false? 0

#include<iostream>
using namespace std;
int main(){
bool flag=true;
cout << flag<<endl; //1
flag=false;
cout<<flag<<endl;? //0
cout << "size of bool="<< sizeof(bool)<<endl; //所占存储空间1字节
?? ?system("pause");
?? ?return 0;
}

----------------------------数据输入

#include<iostream>
using namespace std;
#include<string> //string头文件
int main(){
//整型
int a=0;
cout<<"请输入整型变量a赋值："<<endl;
cin>>a;
cout<<"整型变量a="<<a<<endl;
//浮点型
float f=3.14f;
cout<<"请输入浮点型变量f赋值"<<endl;
cin>>f;
cout<<"浮点型变量f="<<f<<endl;
//字符型
char ch='a';//用单引号
cout <<"请输入字符型变量ch赋值"<<endl;
cin>>ch;
cout<<"字符型变量ch="<<ch<<endl;
//字符串型
string str="hello";//用双引号
cout <<"请输入字符型变量str赋值"<<endl;
cin>>str;
cout<<"字符串型变量str="<<str<<endl;
//布尔型
bool flag=false;
cout <<"请输入布尔型变量str赋值"<<endl;? //非零均为真（1）
cin>>flag;
cout<<"布尔型变量str="<<flag<<endl;
?? ?system("pause");
?? ?return 0;
}

----------------------------运算符之加减乘除

#include<iostream>
using namespace std;
int main(){
//加减乘除运算
int a1=10;
int b1=3;
cout<<a1+b1<<endl; //13
cout<<a1-b1<<endl; //7
cout<<a1*b1<<endl; //30
cout<<a1/b1<<endl; //两整数相除结果为整数3，将小数部分去除
int a2=10;
int b2=20;
cout<<a2/b2<<endl;//0
int a3=10;
int b3=0;
?//cout<<a3/b3<<endl; 提示异常两数相除，除数不可以为0；
double? d1=0.5;
double d2=0.25;
cout<<d1/d2<<endl;//2
double? d3=0.5;
double d4=0.23;
cout<<d3/d4<<endl;//2.17391
?? ?system("pause");
?? ?return 0;
}

----------------------------运算符之取模%

#include<iostream>
using namespace std;
int main(){
//取模运算本质：求余数
//两个数进行取模运算时，基于除法运算，所以不可以除0
//两个小数不可以做取模运算? 会报错
//只有整型变量可以进行取模运算
int a1=10;
?int b1=3;
?cout<<a1%b1<<endl;//1
?int a2=10;
?int b2=20;
?cout<<a2%b2<<endl;//10
?int a3=10;
?int b3= 0;
? //cout <<a3%b3<<endl;不可除0，会报错
?? ?system("pause");
?? ?return 0;
}

----------------------------运算符之递增递减

#include<iostream>
using namespace std;
int main(){
//1.前置递增
int a=10;
++a;
cout <<"a="<<a<<endl;//11
//2.后置递增
int b=10;
b++;
cout<<"b="<<b<<endl;//11
//3.前置与后置的区别
//前置：变量先加1，在运算
//后置：变量先运算，后变量+1
int a2=10;
int b2=++a2*10;
cout <<"a2="<<a2 <<endl;//11
?cout <<"b2="<<b2 <<endl;//110


int a3=10;
int b3=a3++*10;
cout <<"a3=" <<a3<<endl;//11
cout<<"b3="<<b3<<endl;//100
?? ?system("pause");
?? ?return 0;
}

----------------------------运算符之赋值运算符

#include<iostream>
using namespace std;
int main(){
//=
int a=10;
a=100;
cout<<"a="<<a<<endl;//100
//+=
a=10;
a+=2;
cout<<"a="<<a<<endl;//12
//-=
a=10;
a-=2;
cout<<"a="<<a<<endl;//8
//*=
a=10;
a*=2;
cout<<"a="<<a<<endl;//20
///=
a=10;
a/=2;
cout<<"a="<<a<<endl;//5
//%=
a=10;
a%=2;
cout<<"a="<<a<<endl;//0
?? ?system("pause");
?? ?return 0;
}

----------------------------运算符之比较运算符

#include<iostream>
using namespace std;
int main(){

int a=10;
int b=20;
cout<<(a==b)<<endl;//0
cout<<(a!=b)<<endl;//1
cout<<(a>b)<<endl;//0
cout<<(a<b)<<endl;//1
cout<<(a>=b)<<endl;//0
cout<<(a<=b)<<endl;//1
?? ?system("pause");
?? ?return 0;
}

----------------------------运算符之逻辑运算符

#include<iostream>
using namespace std;
int main(){
//逻辑运算非！
int a=10;
cout<<!a<<endl;//0,10为真，非真即为假
cout<<!!a<<endl;//1? 对a两次取反
//逻辑运算与&&? 有 0则0
int a0=10;
int b=10;
cout<<(a0&&b)<<endl;//1
int a1=0;
int b1=10;
cout<<(a1&&b1)<<endl;//0
int a2=0;
int b2=0;
cout<<(a2&&b2)<<endl;//0
// 逻辑运算或|| 有1则1
int a3=10;
int b3=10;
cout<<(a3||b3)<<endl;//1
a=0;
b=10;
cout<<(a||b)<<endl;//1
a=0;
b=0;
cout<<(a||b)<<endl;//0
?? ?system("pause");
?? ?return 0;
}

第三课 流程结构

--------------------流程结构，if语句之单行格式if

#include<iostream>
using namespace std;
int main(){
// 程序流程结构
//if之单行格式if语句：if(条件){条件满足执行的语句}
//输入分数，若>600，视为考上大学，在屏幕输出
//1.用户输入分数
int score=0;
cout <<"请输入一个分数：" <<endl;
cin>>score;
//2.打印用户输入得分数
cout <<"您输入得分数为：" <<score <<endl;
?
// 3.判断分数是否大于600，若大于，则输出
if (score>600) //if后不加分号，加上表示与下列{}中的内容相分离
{?????????????? //会导致不论输入的是否>600.均输出考上一本
?? ?cout<<"恭喜您考上了一本大学"<<endl;
}
?? ?system("pause");
?? ?return 0;
}

--------------------流程结构，if语句之多行格式if

#include<iostream>
using namespace std;
int main(){
// 程序流程结构
//多行格式if语句：if(条件){条件满足执行的语句}else{条件不满足执行的语句};
//输入分数，若>600，视为考上大学，在屏幕输出,没考上也输出内容
//1.用户输入分数
int score=0;
cout <<"请输入一个分数：" <<endl;
cin>>score;
//2.打印用户输入得分数
cout <<"您输入得分数为：" <<score <<endl;
?
// 3.判断分数是否大于600，若大于，则输出考上，否则输出没考上
if (score>600) //if后不加分号，加上表示与下列{}中的内容相分离
{?????????????? //会导致不论输入的是否>600.均输出考上一本
?? ?cout<<"恭喜您考上了一本大学"<<endl;
}else{
?? ?cout<<"很抱歉您未考上大学"<<endl;
}
?? ?system("pause");
?? ?return 0;
}

--------------------流程结构，if语句之多条件的if语句

#include<iostream>
using namespace std;
int main(){
// 程序流程结构
//多条件的if语句
//if(条件1){条件1满足执行的语句}else if(条件2){条件2满足执行的语句}..else{都不满足};
//输入分数，若>600，视为考上一本，在屏幕输出
//>500,视为考上二本，在屏幕输出
//>400，视为考上三本，在屏幕输出
//否则，输出没考上
//1.用户输入分数
int score=0;
cout <<"请输入一个分数：" <<endl;
cin>>score;
//2.打印用户输入得分数
cout <<"您输入得分数为：" <<score <<endl;
// 3.判断分数是
if (score>600) //if后不加分号，加上表示与下列{}中的内容相分离
{????????????? ?
?? ?cout<<"恭喜您考上了一本大学"<<endl;
}
else if(score>500)
{//第二个条件判断
?? ?cout<<"恭喜您考上了二本大学"<<endl;
}
else if(score>400)
{//第三个条件判断
?? ?cout<<"恭喜您考上了三本大学"<<endl;
}
?else
?{
?? ?cout<<"很抱歉您未考上大学"<<endl;
}
?? ?system("pause");
?? ?return 0;
}

--------------------流程结构，if语句之嵌套语句

#include<iostream>
using namespace std;
int main(){
/* 程序流程结构
多条件的if语句
if(条件1){条件1满足执行的语句}else if(条件2){条件2满足执行的语句}..else{都不满足};
>600，视为考上一本，在屏幕输出 ?
在>600中，若>700,考入本大 >650，考入清华 >600考入人大
>500，视为考上二本，在屏幕输出
>400，视为考上三本，在屏幕输出
否则，输出没考上
*/
int score=0;
cout <<"请输入一个分数：" <<endl;
cin>>score;
cout <<"您输入得分数为：" <<score <<endl;
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;
}

--------------------流程结构，if语句之练习案例 三只小猪称体重

#include<iostream>
using namespace std;
int main(){
//ABC称体重，判断谁更重
int num1=0;
int num2=0;
int num3=0;
cout<<"请输入小猪A的体重:"<<endl;
cin>>num1;
cout<<"请输入小猪B的体重："<<endl;
cin>>num2;
cout<<"请输入小猪C的体重:"<<endl;
cin>>num3;
cout<<"小猪A的体重为"<<num1<<endl;
cout<<"小猪B的体重为"<<num2<<endl;
cout<<"小猪C的体重为"<<num3<<endl; ?
//判断A>B(A>C则A，否则C），else(B>C则B,否则C)
if(num1>num2) //A比B重
{
?? ?if(num1>num3) //A比C重
?? ?{
?? ??? ?cout<<"小猪A最重"<<endl;
?? ? }
?? ? else//C比A重
?? ? {
?? ? ?? ?cout<<"小猪C最重"<<endl;
?? ?? }
?}
?else//B比A重
?{
??? ?if(num2>num3) //B比C重
?? ?{
?? ??? ?cout<<"小猪B最重"<<endl;
?? ? }
?? ? else//C比B重
?? ? {
?? ? ?? ?cout<<"小猪C最重"<<endl;
?? ?? }
? }
?? ?system("pause");
?? ?return 0;
}

--------------------三目运算符

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

--------------------switch：执行多条件分支语句

语法：
switch(表达式)
{
?? ?case 结果1：执行语句；break；
?? ?case 结果2：执行语句；break；
?? ?....
?? ?default：执行语句；break；?? ?? 若前面都为出现，则执行这一句
}
?#include<iostream>
using namespace std;
int main(){
//switch :执行多条件分支语句
//给电影打分（10分制）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;
break;?
? }
?//if和 switch的区别 ？
?/*
?switch缺点：在判断的时候只能是整型或是字符型
?不可以是一个区间（if可以）
?switch优点：结构清晰，执行效率高
?*/
?? ?system("pause");
?? ?return 0;
}

--------------------流程结构，循环结构之while循环

满足循环条件，执行循环语句

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

只要条件为真，就执行循环语句

#include<iostream>
using namespace std;
int main(){
//输出0-9数字
int num=0;
//while()中填入循环条件 注意避免死循环
while(num<10)
{
?? ?cout<<num<<endl;
?? ?num++;
?}
?? ?system("pause");
?? ?return 0;
}

--------------------流程结构，循环结构之案例

#include<iostream>
using namespace std;
#include <stdlib.h>//针对rand的头文件
#include<ctime> //time系统时间头文件 ?
int main(){
//1.系统生成随机数1-100
//添加一个种子，利用当前系统时间生成随机数，防止产生的随机数重复
srand((unsigned int)time(NULL));
int num=rand() % 100+1; //rand()%100 生成0-99的数字
//cout <<num<<endl; 不显示随机生成的数值
//2.玩家进行猜测
int val=0;//玩家输入数据
while (1)
{
cin >> val;
//3. 判断玩家的猜测
if(val>num)//猜错提示猜的结果 过大或者或小，重新返回第二步
{
?? ?cout<<"猜测过大"<<endl;
}
else if(val<num)
{
?? ?cout<<"猜测过小"<<endl;
?}
?else
?{
??? ?cout<<"恭喜您猜对了"<<endl;//猜对退出游戏
??? ?break; //猜对了退出循环
?}
?}
?? ?system("pause");
?? ?return 0;
}

--------------------流程结构，循环结构之do-while循环

语法：do{循环语句}while{循环条件}

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

#include<iostream>
using namespace std;
int main(){
//在屏幕中输入0-9这10个数字
int num=0;
do
{
?? ?cout<<num<<endl;
?? ?num++;
?}
?while(num<10);
?//do-while 会先执行一次循环在判断条件，while先判断在执行
?/*
?while(num);? 无结果
?{
?? ?cout<<num<<endl;
?? ?num++;
?}
?*/
?? ?system("pause");
?? ?return 0;
}

--------------------流程结构，循环结构之水仙花案例

水仙花数是指一个3位数，每个位上的数字的3次幂之和等于它本身

例如：1三次方+5三次方+3三次方=153

解题思路 ：1.将所有三位数输出（100-999）

2.在所有三位数中找到水仙花数

依次获取个位%10，十位//10%10，百位//100，判断三次方相加是否等于本身

#include<iostream>
using namespace std;
int main(){
//打印全部三位数
int num=100;
do
{
?? ?//找到水仙花
?? ?int a=0;//个位
?? ?int b=0;// 十位
?? ?int c=0; //百位
?? ?a=num%10;
?? ?b=num/10%10;
?? ?c=num/100;
?? ?if(a*a*a+b*b*b+c*c*c==num)//如果是水仙花，再打印? 无法用**，没有这个符号
?? ?{
?? ??? ?cout<<num<<endl;
?? ?}??
?? ?num++;
}while(num<1000);

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

--------------------流程结构，循环结构之for循环

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

#include<iostream>
using namespace std;
int main(){
//从数字0打印到数字9
//11-20行可直接写成
/*for(int i=0;i<10;1++)
{
?? ?cout<<i<<endl;
}执行顺序，先i=0执行一次，然后是判断i<0,执行输出i，在执行i++。
在判断i<10，依次循环，直至不满足条件 */
int i=0;
for(;;)
{
?? ?if(i>=10)
?? ?{
?? ??? ?break;
?? ?}
?? ?cout<<i<<endl;
?? ?i++;
?}
?? ?system("pause");
?? ?return 0;
}

--------------------流程结构，循环结构之for循环案例-敲桌子

从1开始到数字100，如果数字个位含有7或者数字十位含有7或者数字是7，打印敲桌子，其余数字直接打印输出

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

--------------------流程结构，循环结构之嵌套循环

案例：在屏幕中打印10*10的星星矩阵图

#include<iostream>
using namespace std;
int main(){
//6-12行重复十次可达到效果，但代码重复
for(int i=0;i<=9;i++)//外层执行一次，内层执行一周
{
for(int u=0;u<=9;u++)
{
?? ?cout<<"* ";//外层内层变量名一致，输出时输出内层的值
}
cout<<endl;?? ?
}
?? ?system("pause");
?? ?return 0;
}

--------------------流程结构，循环结构之嵌套循环实现乘法口诀表

规律：列数*行数=计算结果?? 列数<=当前行数

#include<iostream>
using namespace std;
int main(){
for (int i=1;i<=9;i++)
{
?? ?//cout<<i<<endl;
?? ?for (int j=1;j<=i;j++) //j<i? 列数<行数
?? ?{
?? ??? ?cout<<j<<"*"<<i<<"="<<j*i<<" ";
?? ?}
?? ?cout<<endl;
?}
?? ?system("pause");
?? ?return 0;
}

--------------------流程结构之跳转语句break

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

break使用时机：

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

#include<iostream>
using namespace std;
int main(){
//switch语句中
cout<<"请选择副本难度"<<endl;
cout<<"1.普通"<<endl;
cout<<"2.中等"<<endl;
cout<<"3.困难"<<endl;
int select = 0; //创建选择结果的变量
cin>>select;
switch(select)
{
case 1:
?? ?cout<<"您选择的是普通难度"<<endl;
?? ?break;
case 2:
?? ?cout<<"您选择的是中等难度"<<endl;
?? ??? ?break;
case 3:
cout <<"您选择的是困难难度"<<endl;
?? ?break;
?? ?default:
?? ??? ?break;
}
?? ?system("pause");
?? ?return 0;
}

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

#include<iostream>
using namespace std;
int main(){
//出现在循环语句中
for (int i=0;i<10;i++)
{//如果i=5则退出循环不在打印
if(i==5)
{
?? ?break;
}
?? ?cout<<i<<endl;
?}
?? ?system("pause");
?? ?return 0;
}

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

#include<iostream>
using namespace std;
int main(){
//出现在嵌套循环语句中
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;
}

--------------------流程结构之跳转语句continue

作用：执行到本行，就不再执行后面的代码（跳过本次循环中尚未执行的语句），继续执行下一次循环

#include<iostream>
using namespace std;
int main(){
for(int i=0;i<100;i++)
{
?? ?if(i%2==0)
?? ?{
?? ??? ?continue;//当值为偶数时，下面的cout不执行，继续下一步循环
?? ?}//若换成break，没有值，0%2==0，执行完这一步则直接退出循环
?? ?cout<<i<<endl;?? ?
?}
?? ?system("pause");
?? ?return 0;
}

--------------------流程结构之跳转语句goto

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

语法：goto 标记;

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

#include<iostream>
using namespace std;
int main(){
cout<<"1"<<endl;
goto FLAG;//输出1后，经过本行，跳转至goto标记点，直接输出5
cout<<"2"<<endl;
cout<<"3"<<endl;
cout<<"4"<<endl; ?
FLAG://尽量不用，功能过于强大，跳来跳去不方便语句的阅读
cout<<"5"<<endl; ??? ?
?? ?system("pause");
?? ?return 0;
}

第四课 数组

--------------------------------------第五章数组

概念：数组是一个集合，里面存放了相同类型的数据元素

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

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

定义方式：

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

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

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

注意：数组名的命名规范与变量名明明规范一致，且不要和变量名重名? 数组中下标是从0开始索引

#include<iostream>
using namespace std;
int main(){
//定义方式1数据类型 数组名[数组长度]；
int score[3];
score[0]=100;
score[1]=12;
score[2]=48;
cout<<score[0]<<" "<<score[1]<<" " <<score[2]<<" " <<endl;
cout<<"----------------------"<<endl;
//定义方式2.数据类型 数组名[数组长度]={值1，值2，...}；
int score1[5]={100,20,30};//5个数只赋值三个，剩下的补0
for (int i=0;i<5;i++)//利用循环，输出数组中的元素
{
?? ?cout<<score1[i]<<endl;
?}
?cout<<"----------------------"<<endl;
//定义方式3.数据类型 数组名[]={值1，值2，...}；?? ?
//定义数组时，必须有初始长度，不可以写int score3[];
int score3[]={90,20,14,52,78,52,48,65,25,85};
for (int j=0;j<10;j++)//若j<10超出上面自己输入的数字个数，计算机随机给出数值
?{
??? ?cout<<score3[j]<<endl;
?}
?? ??? ?system("pause");
?? ?return 0;
}

--------------------------------------数组之一维数组数组名

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

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

#include<iostream>
using namespace std;
int main(){
//获取整个数组占用内存的大小
int arr[10]={1,2,3,4,5,6,7,8,9,10};
cout<<"整个数组所占空间为："<<sizeof(arr)<<endl;//1个int为4B，共40B
cout<<"每个元素所占内存空间为："<<sizeof(arr[0])<<endl;
cout<<"数组的元素个数为："<<sizeof(arr)/sizeof(arr[0])<<endl;
//通过数组名获取到数组首地址
cout<<"数组首地址为："<<(long long)arr<<endl; //不加int输出16进制
//括号内写longlong因为64位系统原因
cout<<"数组中第一个元素地址为："<<(long long)&arr[0]<<endl;//&元素
cout<<"数组中第二个元素地址为："<<(long long)&arr[1]<<endl;//比上一个多4B
//数组名是常量，不可以进行赋值操作? arr=100就不可以
?? ??? ?system("pause");
?? ?return 0;
}

--------------------------------------数组之五只小猪称体重

在一个数组中记录五只小猪的体重，找出并打印最终的

#include<iostream>
using namespace std;
int main(){
//访问数组中每个元素，若这个元素比前面的大，就更新?? ?
int arr[5]={300,350,200,400,250};
int max=0;//先定义一个最大值
for(int i=0;i<5;i++)//5个值
{
?? ?if(arr[i]>max) //依次与定义的最大值比较
?? ?{
?? ??? ?max=arr[i];
?? ?}
}
?cout<<"最重的小猪体重为："<<max<<endl;?? ?
?? ??? ?system("pause");
?? ?return 0;
}

--------------------------------------数组之元素逆值

声明一个5个元素的数组，并且将元素逆置?

#include<iostream>
using namespace std;
int main(){
?? ?//创建数组
?? ?int arr[5]={1,3,2,5,4};
?? ?cout<<"数组逆置前："<<endl;
?? ?for(int i=0;i<5;i++)
?? ?{
?? ??? ?cout<<arr[i]<<endl;
?? ? }
?? ?? int start=0;//起始下标
?? ?? int end=sizeof(arr)/sizeof(arr[0]) -1;//末尾元素下标
?? ? while(start<end)
?? ? {//元素互换
?? ? ?? ?int temp=arr[start]; //先定义一个临时位置
?? ?? arr[start]=arr[end];
?? ?? arr[end]=temp;
?? ?? //下标更新
?? ??? start++;
?? ??? end--;
?? ? }
?? ?? cout<<"数组元素逆置后"<< endl;
?? ? ??? ?for(int i=0;i<5;i++)
?? ?{
?? ??? ?cout<<arr[i]<<endl;
?? ? }

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

--------------------------------------数组之冒泡排序

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

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;
//开始冒泡
//排序总轮数=总元素个数-1；
//每轮对比数=总元素个数-排序轮数-1；
?? ??? ?for(int i=0;i<9-1;i++)
?? ??? ?{
? ?? ??? ??? ??? ?//内层循环对比
?? ??? ??? ?for(int j=0;j<9-i-1;j++)
?? ??? ??? ?{
??? ??? ??? ?//如果第一个数字比第二个数字大，交换两个数字
?? ??? ??? ??? ?if(arr[j]>arr[j+1])
?? ??? ??? ??? ?{
?? ??? ??? ??? ??? ?int temp=arr[j];
?? ??? ??? ??? ??? ?arr[j]=arr[j+1];
?? ??? ??? ??? ??? ?arr[j+1]=temp;
?? ??? ??? ??? ?}
?? ??? ??? ?}
?? ??? ?}
//排序后结果
?? ?cout <<"排序后："<<endl;
?? ?for(int i=0;i<9;i++)
?? ?{
?? ??? ? cout<<arr[i]<<" ";
?? ?}
?? ??? ?cout<<endl;
?? ??? ?system("pause");
?? ?return 0;
}

---------------------二维数组之定义方式
概念：在一维数组上，多加一个维度
定义的四种方式,建议使用第二种，更加直观，提高代码可读性
定义时，如果初始化了数据，可以省略行数
方式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;
for (int i=0;i<2;i++)
{
?? ?for(int j=0;j<3;j++)
?? ?{
?? ??? ?cout<<"方式一："<<arr[i][j]<<endl;
?? ?}
}
//方式二 可读性更强
int arr2[2][3]=
{
?? ?{1,2,3},
?? ?{4,5,6}
};
for (int i=0;i<2;i++)
{
?? ?for(int j=0;j<3;j++)
?? ?{?? ?
?? ??? ?cout<<arr2[i][j]<<endl;
?? ?}
?? ?cout<<"方式二："<<endl;
}
//方式三
int arr3[2][3]={1,2,3,4,5,6};
for (int i=0;i<2;i++)
{
?? ?for(int j=0;j<3;j++)
?? ?{
?? ??? ?cout<<arr3[i][j]<<endl;
?? ?}
?? ?cout<<"方式三："<<endl;
}
//方式四 不可省略列数
int arr4[][3]={1,2,3,4,5,6};
for (int i=0;i<2;i++)
{
?? ?for(int j=0;j<3;j++)
?? ?{
?? ??? ?cout<<"方式四："<<arr4[i][j]<<endl;
?? ?}
?? ?cout<<endl;
}
?? ??? ?system("pause");
?? ?return 0;
}
---------------------二维数组之数组名
二维数组名称用途

#include<iostream>
using namespace std;
int main(){
?? ?//作用1：可查看占用内存空间大小 sizeof
?? ?int arr[2][3]=
?? ?{
?? ??? ?{1,2,3},
?? ??? ?{4,5,6}
?? ?};
?? ?cout<<"二维数组总占用内存空间为："<<sizeof(arr)<<endl;
?? ?//打印结果为24,6个数字，一个4字节? double则一个为8字节
?? ?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<<"二维数组首地址为："<<(long long)arr<<endl;
?? ?cout<<"二维数组第一行首地址为："<<(long long)arr[0]<<endl;
?? ?cout<<"二维数组第二行首地址为："<<(long long)arr[1]<<endl;
?? ?cout<<"二维数组第一个元素首地址为："<<(long long)&arr[0][0]<<endl;//查看元素的要加&取址符
?? ?cout<<"二维数组第一个元素首地址为："<<(long long)&arr[0][1]<<endl;
?? ??? ?system("pause");
?? ?return 0;
}

---------------------二维数组之考试成绩统计案例
表格如下，求三名学生总成绩
?? ?语文?? ?数学?? ?英语
张三?? ?100?? ?100?? ?100
李四?? ?90?? ?50?? ?100
王五?? ?60?? ?70?? ?80

#include<iostream>
using namespace std;
int main(){
#include<string>
?? ?//创建二维数组
?? ?int score[3][3]=
?? ?{
?? ??? ?{100,100,100},
?? ??? ?{90,50,100},
?? ??? ?{60,70,80}
?? ?};
?? ?string names[3]={"张三","李四","王五"};

?? ?//统计每个人的总和分数
?? ?int sum=0;//统计分数总和变量
?? ?for(int i=0;i<3;i++)
?? ?{
?? ??? ?for(int j=0;j<3;j++)
?? ??? ?{
?? ??? ??? ?sum+=score[i][j];
?? ??? ?//cout<<score[i][j]<<endl;
?? ??? ?}
?? ??? ?cout<<"第"<<i+1<<"个人的总分为："<<sum<<endl;
?? ?//修改为：cout<<names[i]<<"的总分为："<<sum<<endl;
?? ?}
?? ?cout<<endl;
?? ??? ?system("pause");
?? ?return 0;
}

---------------------第六章? 函数之定义
作用：将一段经常使用的代码封装起来，减少重复代码
一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能
定义：一般有五个步骤
返回值类型→函数名→参数列表→函数体语句→return表达式
语法：
返回值类型 函数名（参数列表）
{
函数体语句
return 表达式
}
例：若实现一个加法函数，功能是，传入两个整型数据，计算数据相加的结果并且返回
拆分：
返回值类型：int?? 函数定义中，一个函数可以返回一个值
函数名：add?? 给函数起个名称
参数列表：（int num1,int num2）?? 使用该函数时，传入的数据
函数体语句 int sum=num1+num2;???? 花括号内的代码，函数内需要执行的语句
return 表达式 return sum；??? 和返回值挂钩，函数执行完后，返回相应的数据
组合后：
int add（int num1,int num2）
{
int sum=num1+num2;
return sum；
}

--------------------函数之调用

#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=10;
//a,b称为实际参数，简称实参
//函数调用语法：函数名称（参数）
//在调用函数时，实参的值会传递给形参（a给num1，b给num2）
int c=add(a,b);
cout<<"c="<<c<<endl;
a=100;
b=500;
c=add(a,b);
cout<<"c="<<c<<endl;
?? ??? ?system("pause");
?? ?return 0;
}
--------------------函数之值传递
//定义函数，实现两个数字进行交换函数
//如果函数不需要返回值，声明时可以写void

#include<iostream>
using namespace std;
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;
}
?? ?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;
//?? ?return;不需要返回值时间，可不写return
?? ??? ?system("pause");
?? ?return 0;
}

--------------------函数之常见的样式
常见函数样式有四种
1.无参无返?? 2.有参无返? 3.无参有返? 4.有参有返

#include<iostream>
using namespace std;
//无参无返
void test01()
{
//void a=10;//无类型不可以创建变量，原因无法分配内存
?? ?cout <<"this is test01"<<endl;
//test01();函数调用
}
//有参无返
void test02(int a)
{
?? ?cout <<"this is test02 a="<<a<<endl;
}
//无参有返
int test03()
{
?? ?cout <<"this is test03 "<<endl;
?? ?return 1000;
}
//有参有返
int test04(int a)
{
?? ?cout <<"this is test04 a="<<a<<endl;
?? ?return a;// 或return 1000也可以
}
int main(){
//无参无返函数调用
test01();
//有参无返函数调用
test02(100);
//无参有返函数调用
int num1=test03();//num1来接收返回值
cout<<"num=1"<<num1<<endl;
//有参有返函数调用
int num2=test04(10000);//值先给a再给num2
cout<<"num2="<<num2<<endl;
?? ??? ?system("pause");
?? ?return 0;
}
--------------------函数之声明
作用：在函数定义前，告诉编译器函数名称及如何调用函数
????? 函数的实际主体可以单独定义
函数的声明可以多次，但是函数的定义只能有一次
若定义有多个，函数不知道先执行哪一个
//比较函数，实现两个整型数字进行比较，返回较大的值

#include<iostream>
using namespace std;
//声明
int max(int a,int b);//代码部分写在main后（定义的4行）
int max(int a,int b);//声明可多个
//定义
int max(int a,int b)//定义在main前可不写声明，后必须写
{?? ?
?? ?return a>b?a:b;//三目运算符
}?? ?
int main(){
int a=10;
int b=20;
cout<<max(a,b)<<endl;
?? ??? ?system("pause");
?? ?return 0;
}
--------------------函数之分文件编写
作用：让代码结构更加清晰 ?
一般有四个步骤
1.创建后缀名为.h的头文件
2.创建后缀名为.cpp的源文件
3.在头文件中写函数的声明
4.在源文件中写函数的定义

//swap.h文件，函数的声明
#include<isostream>
using namespace std;
//实现两个数字交换的函数声明
void swap(int a,int b);//函数交换不需要返回值，所有用void
//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;
}
//在自己写的程序内，共三个文件
#include<isostream>
using namespace std;
#include "swap.h"
int main(){
int a=10;
int b=20;
swap(a,b);
.....

第五课 指针

--------------------第七章 指针之定义和使用
指针就是一个地址
作用 可以通过指针间接访问内存
内存编号是从0开始记录的，一般用十六进制数字表示
可以利用指针变量保存地址
定义语法：数据类型*指针变量名；

#include<iostream>
using namespace std;
int main(){
//定义指针
int a=10;//定义整型变量a
int *p; //p=point,可用其他名称也可
//让指针记录变量a的地址
p=&a;//两个链接起来
cout<<"a的地址为："<<&a<<endl;//和p输出的值是一样的
cout<<"指针p为："<<p<<endl;
//使用指针
//可通过解引用的方式来找到指针指向的内存
//指针前加*代表解引用，找到指针指向的内存中
*p=1000;
cout<<"a="<<a<<endl;
cout<<"*p="<<*p<<endl;//通过p找到内存，且*p改变了内存中的数据
?? ??? ?system("pause");
?? ?return 0;
}
--------------------第七章 指针之所占用内存空间
问题：指针也是种数据类型，那么这种数据类型占用多少内存空间？
不论是什么数据类型
32位系统下，指针占用4个字节
64位系统下，指针占用8个字节

#include<iostream>
using namespace std;
int main(){
int a=10;
int * p;
p=&a;//指针指向数据a的地址 ?
//或者上两行直接写为int *p=&a;
cout <<sizeof(p) <<endl;
cout<<"sizeof(int*)=" <<sizeof(int*)? <<endl;
cout <<"sizeof(char*)=" <<sizeof(char*)? <<endl;
cout <<"sizeof(float*)="<<sizeof(float*)? <<endl;
cout <<"sizeof(double*)="<<sizeof(double*)? <<endl;
?? ??? ?system("pause");
?? ?return 0;
}
-------------------- 指针之空指针
定义：指针变量指向内存中编号为0的空间
用途：给指针变量进行初始化
注意：空指针指向的内存是不可以访问的
int * p=NULL;
*p=100; //运行时程序崩溃，0-255之间的内存编号是系统占用，因此不可访问
-------------------- 指针之野指针
定义：指针变量指向非法的内存空间
//指针变量p指向内存地址编号为0x1100的空间
int * p=(int *)0x1100;
//访问野指针报错
cout <<*p<<endl;
//总结：空指针和野指针都不是我们申请的空间，因此不要访问

-------------------- 指针之const修饰指针
三种情况
const修饰指针：常量指针（指针前加一个const）
const修饰常量：*const 变量（变量即为常量）
const既修饰指针，又修饰变量

#include<iostream>
using namespace std;
int main(){
int a=10;
int b=10;
//修饰指针：指针指向可以改，指针指向的值不可以更改
const int *p=&a;
//*p=200错误，值不可以改
p=&b; //正确
//修饰常量，指针指向不可以改，指针指向的值可以改
int *const p2=&a;
*p2=200;//正确
//p2=&b; 错误,指向不可以改
//二者均修饰，指针的指向和值都不可以改
const int * const p3=&a;
//*p3=200;? 错误
//p3=&b; 错误
//技巧，看const右侧紧跟着的是指针还是常量
//????? 指针即为常量指针，是常量则为指针常量
?? ??? ?system("pause");
?? ?return 0;
}
-------------------- 指针之指针和数组
作用：利用指针访问数组中的元素

#include<iostream>
using namespace std;
int main(){
int arr[]={1,2,3,4,5,6,7,8,9,10};
int *p=arr;
cout<<"第一个元素:"<<arr[0]<<endl;
cout<<"指针访问第一个元素"<<*p<<endl;
for(int i=0;i<10;i++)
{
//cout<<arr[i]<<endl;
//利用指针遍历数组
cout <<*p<<endl;
p++;
}
?? ??? ?system("pause");
?? ?return 0;
}
-------------------- 指针之指针和函数
作用：利用指针作函数参数，可以修改实参的值
//值传递 形参改变不了实参

#include<iostream>
using namespace std;

void swap01(int a,int b)
{
int temp=a;
a=b;
b=temp;

cout<<"swap01 a="<<a<<endl;
cout<<"swap01 b="<<b<<endl;
//地址传递 可以修饰实参
}
void swap02(int * p1,int *p2)
{
int temp=*p1;
*p1=*p2;
*p2=temp;? //*p2指向b
}
int main()
{
int a=10;
int b=20;
swap01(a,b);//值
swap02(&a,&b);//地址，跳转函数体，main上面
cout<<" a="<<a<<endl;
cout<<" b="<<b<<endl;

//总结，若不想修改实参，就用值传递
?? ??? ?system("pause");
?? ?return 0;
}

?若想修改实参，就用地址传递
-------------------- 指针之指针配合数组和函数案例
封装一个函数，利用冒泡排序，实现对整型数组的升序排序
例：int arr[10]={4,3,6,9,1,2,10,8,7,5}

#include<iostream>
using namespace std;
#include<iostream>
using namespace std;
//冒泡排序函数 参数1 数组首地址 参数2 数组长度
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++)
?? ??? ?{//若j>j+1的值 则交换数字
?? ??? ??? ?if (arr[j]>arr[j+1])
?? ??? ??? ?{
?? ??? ??? ??? ?int temp =arr[j];
?? ??? ??? ??? ?arr[j]=arr[j+1];
?? ??? ??? ??? ?arr[j+1]=temp;
?? ??? ??? ?}
?? ??? ?}
?? ?}
}
//打印数组? int*接收首地址
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)
?? ?bubbleSort(arr,len); //长度写len，不要写常量
?? ?//3.打印(printArray)排序后的数组
?? ?printArray(arr,len);
?? ?
?? ?system("pause");
?? ?return 0;

?? ??? ?system("pause");
?? ?return 0;
}
-------------------- 第8章 结构体之定义和使用
概念：结构体属于用户自定义的数据类型，允许用户存储不同的数据类型
语法：struct 结构体名{结构体成员列表};
通过结构体创建变量的方式有三种：
1.struct 结构体名 变量名
2.struct 结构体名 变量名={成员1值，成员2值}
3.定义结构体时顺便创建变量

#include<iostream>
#include<string>
using namespace std;
//结构体定义
struct Student//定义结构体时关键字不可省略，
{
//成员列表
string name;//姓名
int age;//年龄
int score;// 分数
}s3;
//2.通过学生类型创建具体学生

int main()
{
//2.1 struct Student s1
?? ?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=22;
?? ?s3.score=20;
?? ?cout<<"姓名："<<s3.name<<" 年龄："<<s3.age<<" 分数："<<s3.score<<endl;
?? ?system("pause");
?? ?return 0;
}
//总结，用方法一，二的时候多，三容易忽视掉main前的s3
定义结构体时关键字struct不可省略

创建结构体变量时，struct可省略

结构体变量利用操作符“.”访问成员

-------------------- 结构体之结构体数组

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

语法：struct 结构提名 数组名[元素个数]={{}，{}，.....{}}

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

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

#include<iostream>
#include<string>
using namespace std;
//结构体定义
struct Student
{
?? ?string name;//姓名
?? ?int age;//年龄
?? ?int score;// 分数
};
int main(){ //下列的 struct可省略
//1.创建学生结构体变量
?? ?struct Student s={"张三",18,100};
//2.通过指针指向结构体变量
?? ?struct Student *p=&s;
//3.通过指针访问结构体变量中的数据
?? ?cout<<"姓名："<<p->name
?? ??? ?<<"年龄："<<p->age?? ?
?? ??? ?<<"分数："<<p->score<<endl;
?? ?system("pause");
?? ?return 0;
}
-------------------- 结构体之结构体嵌套结构体
作用：结构体中的成员可以是另一个结构体

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

#include<iostream>
#include<string>
using namespace std;
//学生结构体定义
struct Student
{
?? ?string name;//姓名
?? ?int age;//年龄
?? ?int score;//分数
};
//老师结构体定义
struct teacher
{
?? ?int id;//编号
?? ?string name;//姓名
?? ?int age;//年龄
?? ?struct Student stu ;//辅导的学生
};
int main(){ //下列的 struct可省略
?//结构体嵌套结构体
?//1.创建老师结构体变量
?? ?teacher t;
?? ?t.id=10000;
?? ?t.name="老王";
?? ?t.age=50;
?? ?t.stu.name="小程";
?? ?t.stu.age=20;
?? ?t.stu.score=60;
?? ?cout<<"老师姓名："<<t.name<<endl
?? ???? <<"老师编号："<<t.id<<endl
?? ??? ?<<"老师年龄："<<t.age<<endl
?? ??? ?<<"老师辅导的学生姓名："<<t.stu.name<<endl
?? ??? ?<<"学生年龄："<<t.stu.age<<endl
?? ??? ?<<"学生的考试分数："<<t.stu.score<<endl;
?? ?system("pause");
?? ?return 0;
}
总结：在结构体中可以定义另一个结构体作为成员，用来解决实际问题
-------------------- 结构体之结构体做函数参数

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

值传递 形参改变不改变实参

地址传递? 形参改变 实参也变

#include<iostream>
?#include<string>
using namespace std;
//学生结构体定义
struct student
{//成员列表
string name;//姓名
int age;//年龄
int score;// 成绩
};
//打印学生信息的函数
//值传递
void printStudent1 (struct student s)
{
?? ?s.age=100; //子函数中为100，主函数中不变
?? ?cout<<"在子函数中,姓名："<<s.name<<endl
?? ??? ?<<"在子函数中,年龄："<<s.age <<endl
?? ??? ?<<"在子函数中,分数："<<s.score <<endl;
}
//地址传递? 用*指针来接收地址
?void printStudent2(struct student *p)
?{
??? ?p->age=200; //子函数2和main主函数均变为200
??? ?cout<<"在子函数2中,姓名："<<p->name<<endl
?? ??? ?<<"在子函数2中,年龄："<<p->age <<endl
?? ??? ?<<"在子函数2中,分数："<<p->score <<endl;
?}
int main()
{
?? ?//将学生传入一个参数中，打印学生信息
?? ? //创建结构体变量
?? ? struct student s;
?? ? s.name="张三";
?? ? s.age=27;
?? ? s.score=66;
?? ? //对应值传递 printStudent1(s);
?? ?printStudent2(&s);//对应地址传递
?? ? cout<<"在main函数中打印的结果,姓名："<<s.name<<endl
?? ? ?? ?<<"在main函数中打印的结果,年龄："<<s.age <<endl
?? ? ?? ?<<"在main函数中打印的结果,分数："<<s.score <<endl;
?? ?system("pause");
?? ?return 0;
}

总结：若不想修改主函数中的数据，用值传递，反之，用地址传递

-------------------- 结构体之结构体const使用场景

作用：防止误操作

#include<iostream>
?#include<string>
using namespace std;
//学生结构体定义
struct student
{//成员列表
string name;//姓名
int age;//年龄
int score;// 成绩
};
//将函数中形参改为指针，可减少内存空间，且不会复制新的副本出来
void printStudents (const struct student *s)//可省略 struct
{
?? ?//s->age=150;
?? ?//有const后上一行错误，表达式必须为可修改的左值，可防止误操作
?? ?cout<<"姓名："<<s->name<<endl
?? ? ?? ?<<"年龄："<<s->age <<endl
?? ? ?? ?<<"分数："<<s->score <<endl;
}
int main(){
?? ?//创建结构体变量
?? ? struct student s={"张三",18,70};
?? ? //通过函数打印结构体变量信息
?? ?? printStudents(&s);

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

-------------------- 结构体之结构体案例1

描述：一个老师带5个学生，共3名老师，需求如下

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

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

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

#include<iostream>
#include <stdlib.h>
?#include<string>
?#include<ctime>
using namespace std;
//学生结构体定义
struct Student
{
?? ?string sName;
?? ?int score;// 成绩 ?? ?
};//老师结构体定义
struct Teacher
{
?? ?string tName;//姓名
?? ?struct Student sArray[5]; //学生数组
};
//给老师和学生赋值的函数
void allocateSpace(struct Teacher tArray[],int len)
{
?? ?string nameSeed="ABCDE";
?? ?//给老师赋值
?? ?for(int i=0;i<len;i++)
?? ?{
?? ??? ?tArray[i].tName = "Teacher_";
?? ??? ?tArray[i].tName += nameSeed[i];
?? ??? ?//通过循环给每名老师所带的学生赋值
?? ??? ?for (int j=0;j<5;j++)
?? ??? ?{
?? ??? ??? ?tArray[i].sArray[j].sName = "Student_";
?? ??? ??? ?tArray[i].sArray[j].sName += nameSeed[j];
?? ??? ??? ?int random = rand() % 61+40;//0-60变为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++)
?? ??? ??? ?{????????????????????? //第i个老师的第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;
}

-------------------- 结构体之结构体案例2

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

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

英雄信息如下

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

#include<iostream>
#include <stdlib.h>
?#include<string>
using namespace std;
//1.创建英雄结构体
struct Hero
{
?? ?string name;
?? ?int age;
?? ?string sex;
};
//冒泡排序实现年龄升序排列
void bubbleSort(struct Hero heroArray[],int len)
{
?? ?for(int i=0;i<len-1;i++)
?? ?{
?? ??? ?for(int j=0;j<len-i-1;j++)
?? ??? ?{
?? ??? ??? ?//若j下标元素年龄大于j+1下标的元素年龄，交换两个元素
?? ??? ??? ?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(){
//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);
cout<<"排序后打印："<<endl;
//4.将排序后结果打印输出
printHero(heroArray,len);
?? ?system("pause");
?? ?return 0;
}

——完——