第一课 数据类型
#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;
}