C++零基础自学笔记

第一课 数据类型

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

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

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

    system("pause");
    return 0;
}

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

#include
using namespace std;


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

      cout << sum <
    system("pause");
    return 0;
}

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

short 短整型 2字节

int      整型    4字节

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

long long  长长整型   8字节

#include
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 <     cout << "num2=" << num2 <     cout << "num3=" << num3 <     cout << "num4=" << num4 <     //sizeof     求数据类型占用内存大小
    cout << "short占用内存空间为：" << sizeof (num1) <     cout << "short占用内存空间为：" << sizeof (short) <     cout << "int占用内存空间为：" << sizeof (num2) < cout << "long占用内存空间为：" << sizeof (num3) < cout << "long long占用内存空间为：" << sizeof (num4) <     system("pause");
    return 0;
}

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

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

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

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

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

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

第二课 运算符

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

现阶段常用  \n \\  \t

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

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

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

\\  一个反斜线字符\

#include
using namespace std;

int main(){
cout << "hello word\n";      //5.6行功能一致 结果一致
cout << "hello word"  < cout << "\\"  < cout << "aaa\thelloword"  < cout << "a\thelloword"  < cout << "aa\thelloword"  < cout << "aaaaaa\thelloword"  <     system("pause");
    return 0;
}

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

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

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

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

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

布尔两个值  true 1  和false  0

#include
using namespace std;
int main(){
bool flag=true;
cout << flag< flag=false;
cout< cout << "size of bool="<< sizeof(bool)<     system("pause");
    return 0;
}

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

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

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

#include
using namespace std;
int main(){
//加减乘除运算
int a1=10;
int b1=3;
cout< cout< cout< cout< int a2=10;
int b2=20;
cout< int a3=10;
int b3=0;
 //cout< double  d1=0.5;
double d2=0.25;
cout< double  d3=0.5;
double d4=0.23;
cout<     system("pause");
    return 0;
}

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

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

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

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

int a3=10;
int b3=a3++*10;
cout <<"a3=" < cout<<"b3="<     system("pause");
    return 0;
}

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

#include
using namespace std;
int main(){
//=
int a=10;
a=100;
cout<<"a="< //+=
a=10;
a+=2;
cout<<"a="< //-=
a=10;
a-=2;
cout<<"a="< //*=
a=10;
a*=2;
cout<<"a="< ///=
a=10;
a/=2;
cout<<"a="< //%=
a=10;
a%=2;
cout<<"a="<     system("pause");
    return 0;
}

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

#include
using namespace std;
int main(){

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

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

#include
using namespace std;
int main(){
//逻辑运算非！
int a=10;
cout< cout< //逻辑运算与&&  有 0则0
int a0=10;
int b=10;
cout<<(a0&&b)< int a1=0;
int b1=10;
cout<<(a1&&b1)< int a2=0;
int b2=0;
cout<<(a2&&b2)< // 逻辑运算或|| 有1则1
int a3=10;
int b3=10;
cout<<(a3||b3)< a=0;
b=10;
cout<<(a||b)< a=0;
b=0;
cout<<(a||b)<     system("pause");
    return 0;
}

第三课 流程结构

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

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

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

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

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

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

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

#include
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 <<"请输入一个分数：" < cin>>score;
cout <<"您输入得分数为：" < if (score>600)
{               
    cout<<"恭喜您考上了一本大学"<     if(score>700)
    {
        cout<<"您能考入北京大学"<     }
    else if(score>650)
    {
        cout<<"您能考入清华大学"<      }
     else
     {
         cout<<"您能考入人民大学"<      }
}
else if(score>500)
{
    cout<<"恭喜您考上了二本大学"< }
else if(score>400)
{
    cout<<"恭喜您考上了三本大学"< }
 else
 {
    cout<<"很抱歉您未考上大学"< }
    system("pause");
    return 0;
}

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

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

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

#include
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++中三目运算符返回的是变量，可以继续赋值
(a cout<<"a="< cout<<"b="<     system("pause");
    return 0;
}

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

语法：
switch(表达式)
{
    case 结果1：执行语句；break；
    case 结果2：执行语句；break；
    ....
    default：执行语句；break；      若前面都为出现，则执行这一句
}
 #include
using namespace std;
int main(){
//switch :执行多条件分支语句
//给电影打分（10分制）10-9经典 8-7很好6-5一般<5烂片
//1.提示用户给电影评分
cout<<"请给电影进行打分"< //2.用户开始打分
int score=0;
cin>>score;
cout<<"您打的分数为："< //3.根据用户输入的分数来提示用户最后的结果
 switch(score)
 {
case 10:
cout<<"您认为是经典电影"< break;//若没有，则下面的全部输出
case 9:
cout<<"您认为是经典电影"< break;
case 8:
cout<<"您认为电影非常好"< break;
case 7:
cout<<"您认为电影非常好"< break;
case 6:
cout<<"您认为电影一般"< break;
case 5:
cout<<"您认为电影一般"< break;
default:
cout<<"您认为这是个烂片"< break; 
  }
 //if和 switch的区别 ？
 /*
 switch缺点：在判断的时候只能是整型或是字符型
 不可以是一个区间（if可以）
 switch优点：结构清晰，执行效率高
 */
    system("pause");
    return 0;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#include
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++;
}while(num<1000);

    system("pause");
    return 0;
}

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

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

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

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

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

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

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

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

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

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

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

#include
using namespace std;
int main(){
for (int i=1;i<=9;i++)
{
    //cout<     for (int j=1;j<=i;j++) //j     {
        cout<     }
    cout<  }
    system("pause");
    return 0;
}

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

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

break使用时机：

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

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

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

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

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

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

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

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

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

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

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

语法：goto 标记;

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

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

第四课 数组

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

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

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

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

定义方式：

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

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

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

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

#include
using namespace std;
int main(){
//定义方式1数据类型 数组名[数组长度]；
int score[3];
score[0]=100;
score[1]=12;
score[2]=48;
cout< cout<<"----------------------"< //定义方式2.数据类型 数组名[数组长度]={值1，值2，...}；
int score1[5]={100,20,30};//5个数只赋值三个，剩下的补0
for (int i=0;i<5;i++)//利用循环，输出数组中的元素
{
    cout<  }
 cout<<"----------------------"< //定义方式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<  }
        system("pause");
    return 0;
}

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

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

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

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

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

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

#include
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<<"最重的小猪体重为："<         system("pause");
    return 0;
}

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

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

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

        system("pause");
    return 0;
}

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

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

1.比较相邻的元素，如果第一个比第二个大，就交换他们两个

2.对每一对相邻元素做同样的工作，执行完毕后，找到一个最大值

3.重复以上步骤，每次比较次数-1.直到不需要比较

#include
using namespace std;
int main(){
//利用冒泡排序实现升序序列
    int arr[9]={4,2,8,0,5,7,1,3,9};
    cout <<"排序前："<     for(int i=0;i<9;i++)
        {
             cout<         }
            cout< //开始冒泡
//排序总轮数=总元素个数-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 <<"排序后："<     for(int i=0;i<9;i++)
    {
         cout<     }
        cout<         system("pause");
    return 0;
}

---------------------二维数组之定义方式
概念：在一维数组上，多加一个维度
定义的四种方式,建议使用第二种，更加直观，提高代码可读性
定义时，如果初始化了数据，可以省略行数
方式1：数据类型 数组名[行数][列数];
方式2：数据类型 数组名[行数][列数]={{数据1，数据2}，{数据3，数据4}};
方式3：数据类型 数组名[行数][列数]={数据1，数据2，数据3，数据4};
方式4：数据类型 数组名[  ][列数];={数据1，数据2，数据3，数据4};

#include
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< cout< cout< cout< cout< cout< for (int i=0;i<2;i++)
{
    for(int j=0;j<3;j++)
    {
        cout<<"方式一："<     }
}
//方式二 可读性更强
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<     }
    cout<<"方式二："< }
//方式三
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<     }
    cout<<"方式三："< }
//方式四 不可省略列数
int arr4[][3]={1,2,3,4,5,6};
for (int i=0;i<2;i++)
{
    for(int j=0;j<3;j++)
    {
        cout<<"方式四："<     }
    cout< }
        system("pause");
    return 0;
}
---------------------二维数组之数组名
二维数组名称用途

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

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

#include
using namespace std;
int main(){
#include
    //创建二维数组
    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<         }
        cout<<"第"<     //修改为：cout<     }
    cout<         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
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="< a=100;
b=500;
c=add(a,b);
cout<<"c="<         system("pause");
    return 0;
}
--------------------函数之值传递
//定义函数，实现两个数字进行交换函数
//如果函数不需要返回值，声明时可以写void

#include
using namespace std;
void swap(int num1,int num2)
{
    cout<<"交换前"<     cout<<"num1="<     cout<<"num2="<     int temp=num1;
    num1=num2;
    num2=temp;
    cout<<"交换后"<     cout<<"num1="<     cout<<"num2="< }
    int main(){
    int a=10;
    int b=20;
    cout<<"a="<     cout<<"b="< //当我们做值传递时，函数形参发生改变，并不会影响实参
    swap(a,b);
    cout<<"a="<     cout<<"b="< //    return;不需要返回值时间，可不写return
        system("pause");
    return 0;
}

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

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

#include
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<         system("pause");
    return 0;
}
--------------------函数之分文件编写
作用：让代码结构更加清晰  
一般有四个步骤
1.创建后缀名为.h的头文件
2.创建后缀名为.cpp的源文件
3.在头文件中写函数的声明
4.在源文件中写函数的定义

//swap.h文件，函数的声明
#include
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="< cout<<"b="< }
//在自己写的程序内，共三个文件
#include
using namespace std;
#include "swap.h"
int main(){
int a=10;
int b=20;
swap(a,b);
.....

第五课 指针

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

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

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

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

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

#include
using namespace std;

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

cout<<"swap01 a="< cout<<"swap01 b="< //地址传递 可以修饰实参
}
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="< cout<<" b="<
//总结，若不想修改实参，就用值传递
        system("pause");
    return 0;
}

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

#include
using namespace std;
#include
using namespace std;
//冒泡排序函数 参数1 数组首地址 参数2 数组长度
void bubbleSort(int *arr,int len) //int *arr 也可以写为int arr[]
{
    for (int i=0;i      {
        for(int j=0;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     {
        cout<     }
}
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
#include
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<<"姓名："< //2.2 struct Student s2={....}
    struct Student s2={"李四",19,80};
    cout<<"姓名："< //2.3 在定义结构体时顺便创建结构体变量
    s3.name="王五";
    s3.age=22;
    s3.score=20;
    cout<<"姓名："<     system("pause");
    return 0;
}
//总结，用方法一，二的时候多，三容易忽视掉main前的s3
定义结构体时关键字struct不可省略

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

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

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

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

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

#include
#include
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<<"姓名："<             <<"年龄："<             <<"分数："<     }
    system("pause");
    return 0;
}
-------------------- 结构体之结构体指针
作用：通过指针访问结构体中的成员

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

#include
#include
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<<"姓名："<name
        <<"年龄："<age    
        <<"分数："<score<     system("pause");
    return 0;
}
-------------------- 结构体之结构体嵌套结构体
作用：结构体中的成员可以是另一个结构体

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

#include
#include
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<<"老师姓名："<         <<"老师编号："<         <<"老师年龄："<         <<"老师辅导的学生姓名："<         <<"学生年龄："<         <<"学生的考试分数："<     system("pause");
    return 0;
}
总结：在结构体中可以定义另一个结构体作为成员，用来解决实际问题
-------------------- 结构体之结构体做函数参数

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

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

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

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

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

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

作用：防止误操作

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

    system("pause");
    return 0;
}

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

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

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

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

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

#include
#include
 #include
 #include
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     {
        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     {
            cout<<"老师姓名："<             for(int j=0;j<5;j++)
            {                      //第i个老师的第j个学生的姓名
                cout<<"\t学生姓名："<< tArray[i].sArray[j].sName
                    <<" 考试分数："<< tArray[i].sArray[j].score<             } 
    }
 }
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
#include
 #include
using namespace std;
//1.创建英雄结构体
struct Hero
{
    string name;
    int age;
    string sex;
};
//冒泡排序实现年龄升序排列
void bubbleSort(struct Hero heroArray[],int len)
{
    for(int i=0;i     {
        for(int j=0;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     {
        cout<<"姓名："<             <<"年龄："<             <<"性别："<     }
 }
int main(){
//2.创建数组存放5名英雄
struct Hero heroArray[5]=
{
    {"刘备",23,"男"},
    {"关羽",22,"男"},
    {"张飞",20,"男"},
    {"赵云",21,"男"},
    {"貂蝉",19,"女"},
};
    int len=sizeof(heroArray)/sizeof(heroArray[0]);
    cout<<"排序前打印："<     for(int i=0;i         {
        cout<<"姓名："<             <<"年龄："<             <<"性别："<     }/
//3.对数组进行排序，按照年龄进行升序排序
bubbleSort(heroArray,len);
cout<<"排序后打印："< //4.将排序后结果打印输出
printHero(heroArray,len);
    system("pause");
    return 0;
}

——完——