devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++学习笔记——语法篇_c++固定格式

作者：Monodyee | 2024-06-04 18:50:54

赞

踩

c++固定格式

目录

一、初识C++

1、固定格式

2、第一个程序：hello world

3、注释

4、变量与常量

5、关键字/标识符

二、数据类型

1、整型

2、实型（浮点型）

3、字符型和字符串类型

4、转义字符

5、布尔类型

6、数据的输入

三、运算符

1、算数运算符

2、赋值运算符

3、比较运算符

4、逻辑运算符

四、程序运行结构

1、选择结构：if语句

2、循环结构：while语句、for语句

五、数组

1、一维数组

2、二维数组

六、函数

1、函数的定义

2、函数的调用

3、函数的常见样式

4、函数的声明

七、指针

1、指针的定义和使用

2、指针所占的内存空间

3、空指针和野指针

4、const修饰指针

5、指针和数组、指针和函数

八、结构体

1、结构体的定义和使用

2、结构体数组

3、结构体指针

4、结构体嵌套结构体

5、结构体做函数参数

6、结构体中的const使用场景

7、结构体案例

一、初识C++

1、固定格式

  1. #include <iostream>
  2. using namespace std;
  3. int main()
  4. {  
  5.     // 这里写代码...   
  6.     system ("pause"); 
  7.     return 0;
  8. }

2、第一个程序：hello world

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {
  6.     cout << "hello world" << endl;
  7.     return 0;
  8. }

3、注释

单行注释：//     

多行注释：/* */

4、变量与常量

变量：数据类型 变量名=变量值;

int a = 5;

常量：宏常量、const修饰变量

宏常量：#define 常量名 常量值

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {
  6.     #define day 7
  7.     cout << "一周总共有" << day << "天" << endl;
  8.     return 0;
  9. }

const修饰变量：const 数据类型 常量名=常量值

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {
  6.     const int month = 12;
  7.     cout << "一年有" << month << "个月" << endl;
  8.     return 0;
  9. }

5、关键字/标识符

在定义变量或者常量的时候不要用下面这些关键字。

标识符命名规则：

1、不能是关键字；2、只能由字母、数字、下划线组成；

3、第一个字符必须为字母或下划线；4、字母严格区分大小写。

二、数据类型

1、整型

int 变量名 = 变量值;

数据类型存在的意义：给变量分配合适的内存空间。

sizeof关键字：sizeof(数据类型/变量)

利用sizeof关键字可以统计数据类型所占内存大小。

2、实型（浮点型）

单精度：float

双精度：double

float 变量名 = 变量值;

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

float：占用4字节，7位有效数字。

double：占用8字节，15-16位有效数字。

还有一种小数表示法：科学计数法（少用），float a = 3e2，3e2表示：3*10^2

float a = 3.14f;一般我们会在数字后面加上一个f，否则编译器会默认是双精度类型的。

float默认情况下会在小数点后显示5位。

3、字符型和字符串类型

字符型：char 变量名 = ’一个字符’;

注：只能用单引号，不能用双引号，而且只能有一个字符，不能是字符串。

C和C++中都只占用1个字节。

字符型变量并不是把字符本身放到内存中存储，而是将对应的ASCII编码放入到存储单元。

查看字符的ASCII码：cout << (int)a << endl;

 (int)a：把字符型强制转化成整型，a是97，A是65。

字符串类型：

C语言：char 变量名[] = “字符串值”;

C++：string 变量名 = “字符串值”;

这两种风格在C++中都可以用，记得要用双引号。

4、转义字符

现阶段常用的有：\n、\\、\t

\t一共占8个位置，如果是aaaa\t，那么输出结果为：aaaa+4个空格，如果是aaa\t，输出结果为：aaa+5个空格。

5、布尔类型

bool 变量名 = true/false;

bool型只有两种：true、false，本质上1代表真值，0代表假值，布尔类型只占1个字节大小。

6、数据的输入

cin >> 变量1 >> 变量2 >> 变量3

输入之前记得先声明变量类型。

三、运算符

1、算数运算符

两个整数相除，结果依然是整数，去抹去小数部分。

前置递增++a表示：先让变量+1，然后再进行表达式的运算；

后置递增a++表示：先进行表达式的运算，后让变量+1。

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {
  6.     int a = 10;
  7.     int b = ++a *10;
  8.     int c = 10;
  9.     int d = c++ *10;
  10.  
  11.     cout << "a=" << a << endl;
  12.     cout << "b=" << b << endl;
  13.     cout << "c=" << c << endl;
  14.     cout << "d=" << d << endl;
  15.     // 输出的结果：a=11,b=110,c=11,d=100
  16.  
  17.     return 0;
  18. }

2、赋值运算符

=、+=、-=、*=、/=、%=

3、比较运算符

==相等于，!=不等于

>、<、>=、<=

4、逻辑运算符

四、程序运行结构

程序运行结构：顺序结构、选择结构、循环结构

1、选择结构：if语句

单行：if(条件){条件满足执行的语句}

多行：if(条件){条件满足执行的语句}

           else{条件未满足执行的语句}

多条件：if(条件1){条件1满足执行的代码}

              else if(条件2){条件2满足执行的代码}

               ......

              else{以上条件都不满足执行的代码}

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {
  6.     // 用户输入分数，如果在500-600区间内，恭喜考上本科，如果大于600，恭喜考上重点，否则，复读。
  7.     int score = 0;
  8.     cout << "请输入一个分数：" << endl;
  9.     cin >> score;
  10.  
  11.     if(score>600)
  12.     {
  13.         cout << "考上重点大学！" << endl;
  14.     }
  15.  
  16.     else if(500<=score && score<=600)
  17.     {
  18.         cout << "考上本科！" << endl;
  19.     }
  20.  
  21.     else
  22.     {
  23.         cout << "去复读！" << endl;
  24.     }
  25.  
  26.     return 0;
  27. }

嵌套if语句：if语句中再嵌套if语句

接上面的例子，在大于600分的重点档里，600-630:211，630-680:985，680+：清北。

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {
  6.     int score = 0;
  7.     cout << "请输入一个分数：" << endl;
  8.     cin >> score;
  9.  
  10.     if(score>600)
  11.     {
  12.         if (score > 600 && score <= 630)
  13.         {
  14.             cout << "考上211大学！" << endl;
  15.         }
  16.  
  17.         else if(score > 630 && score <= 680)
  18.         {
  19.             cout << "考上985大学！" << endl;
  20.         }
  21.  
  22.         else
  23.         {
  24.             cout << "考上清北！" << endl;
  25.         }
  26.     }
  27.  
  28.     else if(500<=score && score<=600)
  29.     {
  30.         cout << "考上本科！" << endl;
  31.     }
  32.  
  33.     else
  34.     {
  35.         cout << "去复读！" << endl;
  36.     }
  37.  
  38.     return 0;
  39. }

小练习：三只小猪称体重：分别输入三只小猪的体重，判断哪只最重。

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {
  6.     int a=0,b=0,c=0;
  7.     cin >> a >> b >> c;
  8.  
  9.     if(a>b)
  10.     {
  11.         if(a>c)
  12.         {
  13.             cout << a << endl;
  14.         }
  15.  
  16.         else
  17.         {
  18.             cout << c << endl;
  19.         }
  20.     }
  21.  
  22.     else
  23.     {
  24.         if(b>c)
  25.         {
  26.             cout << b << endl;
  27.         }
  28.  
  29.         else
  30.         {
  31.             cout << c << endl;
  32.         }
  33.     }
  34.  
  35.     return 0;
  36. }

三目运算符和switch语句

三目运算符：条件?条件满足执行的语句:条件不满足执行的语句;

switch语句：

switch(需要判断的变量)

{

  case 常量1 :当变量=常量1时需要执行的语句;break;

  case 常量2 :当变量=常量2时需要执行的语句;break;

  ......

  default:其他情况下执行的语句;break;

}

注意在判断时只能是一个整型或者字符型，不能是一个区间。

优点是结构清晰，执行效率高于if。

练习：给电影打分。

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {  
  6.     int score = 0;  
  7.     cin >> score;
  8.     switch(score)
  9.     {
  10.         case 9:
  11.         cout << "经典佳作！" << endl;
  12.         break;
  13.  
  14.         case 8:
  15.         cout << "不错的电影！" << endl;
  16.         break;
  17.         
  18.         // ...
  19.  
  20.         default:
  21.         cout << "都一般！" << endl;
  22.         break;
  23.     }
  24.  
  25.     return 0;
  26. }

2、循环结构：while语句、for语句

while语句：while(条件){条件满足时执行的语句}

练习：系统随机生成1-100之间的数字，玩家进行猜测，如果猜错，提示玩家数字过大或者过小，如果猜对，恭喜玩家获得胜利，并退出游戏。

生成随机数：rand()%要生成的随机数的区间最大值，如rand()%100，表示生成0-99的随机数。

  1. #include <iostream>
  2. using namespace std;
  3. #include <ctime>
  4.  
  5. int main()
  6. {  
  7.  
  8.     // 添加随机数种子，利用当前系统时间生成随机数，防止每次随机数都一样。
  9.     srand((unsigned int)time(NULL));
  10.     int num = rand()%100+1;
  11.     int guess = 0;
  12.  
  13.     while(1)
  14.     {  
  15.         cin >> guess;
  16.         if(guess>num)
  17.         {
  18.             cout << "猜大了" << endl;
  19.         }
  20.  
  21.         else if(guess<num)
  22.         {
  23.             cout << "猜小了" << endl;
  24.         }
  25.  
  26.         else
  27.         {
  28.             cout << "猜对了" << endl;
  29.             break;
  30.         }
  31.     }
  32.  
  33.     return 0;
  34. }

do...while语句：do(循环语句)while(循环条件)

与while不同的是，它会先执行一次循环语句，再判断循环条件。

练习：水仙花数是指一个3位数，它的每个位上的数字的3次幂之和等于它本身，例如：1^3+5^3+3^3=153，请利用do...while语句，求出所有3位数中的水仙花数。

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {  
  6.     // 1、先获取所有的三位数100-999,；2、在所有的三位数中找到水仙花数。
  7.     int num = 100;
  8.  
  9.     do
  10.     {  
  11.         int a,b,c;
  12.  
  13.         // a:个位，b:十位，c:百位。
  14.         // 如果想拿到一个数字的个位数，只需要对它模以10即可。
  15.         a = num % 10;
  16.         b = num / 10 % 10;
  17.         c = num / 100;    
  18.  
  19.         if(a*a*a + b*b*b + c*c*c == num)
  20.         {
  21.             cout << num << endl;
  22.         }
  23.  
  24.         num++;
  25.     } while (num<1000);
  26.  
  27.     return 0;
  28. }

for语句：for(起始表达式;条件表达式;末尾循环体){满足条件执行的循环语句}

eg:for(inti=1;i<10;i++){cout << i << endl;}

练习：敲桌子游戏：从1开始到数字100，如果数字个位或者十位含有7，或者该数字是7的倍数，敲桌子，其余数字输出。

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {  
  6.     for(int i=1;i<=100;i++)
  7.     {
  8.         if(i%7==0 || i%10==7 || i/10==7)
  9.  
  10.         {
  11.             cout << "敲桌子" << endl;
  12.         }
  13.  
  14.         else
  15.         {
  16.             cout << i << endl;
  17.         }
  18.     }
  19.  
  20.     return 0;
  21. }

嵌套循环：在循环体中再嵌套一层循环。

练习：利用嵌套循环打印下面的乘法口诀表。

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {  
  6.     // 1、列数*行数=结果；2、列数<=当前行数
  7.     for(int i=1;i<=9;i++)
  8.     {
  9.         for(int j=1;j<=i;j++)
  10.         {
  11.             cout << i << "x"  << j << "=" << j*i << " ";
  12.         }
  13.         cout << endl;
  14.     }
  15.  
  16.     return 0;
  17. }

跳转语句：break、continue、goto

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

continue：跳过本次循环中余下未执行的语句，继续执行下一次循环。

goto：可以无条件跳转语句。goto 标记，如果标记的名称存在，则会直接跳转到标记的语句执行。

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {  
  6.     cout << "11111" << endl;
  7.     cout << "22222" << endl;
  8.  
  9.     goto FLAG;
  10.  
  11.     cout << "33333" << endl;
  12.     cout << "44444" << endl;
  13.  
  14.     FLAG:
  15.  
  16.     cout << "55555" << endl;
  17.     return 0;
  18.  
  19. }
  20.  
  21. // 输出结果为：11111 22222 55555

五、数组

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

特点：1、数组中的每个数据元素都是相同的数据类型；2、数组是由连续的内存位置组成的。

从0开始进行索引。

1、一维数组

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

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

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

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

如果规定了数组长度为5，但是只写入3个数，剩下的数会自动用0填充。

定义的时候必须初始化它的长度。

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {  
  6.  
  7.     // 1、数据类型 数组名[数组长度];
  8.     int a[3];
  9.  
  10.     // 给数组中的元素进行赋值：
  11.     a[0] = 10;
  12.     a[1] = 20;
  13.     a[2] = 30;
  14.  
  15.     // 2、数据类型 数组名[数组长度] = {值1,值2,...};
  16.     int b[3] = {10,20,30};
  17.  
  18.     // 3、数据类型 数组名[] = {值1,值2,...};
  19.     int c[] = {10,20,30};
  20.  
  21.     // 访问数组元素：利用循环输出数组元素。
  22.     for(int i=0;i<3;i++)
  23.     {  
  24.         cout << a[i] << endl;
  25.     }
  26.  
  27.     for(int j=0;j<3;j++)
  28.     {    
  29.         cout << b[j] << endl;
  30.     }
  31.  
  32.     for(int s=0;s<3;s++)
  33.     {
  34.         cout << c[s] << endl;
  35.     }
  36.  
  37.     return 0;
  38. }

直接cout<< a << endl;出来的是它的十六进制地址：0x61fe14

一维数组名的用途：

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

2、可以获取数组在内存中的首地址。

注：数组名是一个常量，不可以进行赋值操作。

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {  
  6.  
  7.     int a[5] = {1,2,3,4,5};
  8.  
  9.     // 统计整个数组所占用的内存长度，这个输出为20
  10.     cout << sizeof(a) << endl;
  11.  
  12.     // 统计单个元素所占的内存空间，这个输出为4，可以通过sizeif(a)/ sizeof(a[0])来获取数组长度。
  13.     cout << sizeof(a[0]) << endl;
  14.  
  15.     // 获得整个数组首地址，为了方便查看，可以利用long long把它转成十进制，这个输出为：6422016
  16.     cout << (long long)a << endl;
  17.  
  18.     // 获得某个元素的首地址，因为第一个元素的首地址和整个数组的首地址是一样的，这里演示第二个元素，输出为：6422020
  19.     cout << (long long)&a[1] << endl;
  20.  
  21.     return 0;
  22. }

练习：数组元素逆置。

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {  
  6.     int set[5] = {1,2,3,4,5};
  7.  
  8.     cout << "原数组元素为：" << endl;
  9.     for(int i=0;i<5;i++)
  10.     {
  11.         cout << set[i] << endl;
  12.     }
  13.  
  14.     // 获取起始元素下标位置和末尾元素的下表位置
  15.     int start = 0;
  16.     int end = (sizeof(set)/sizeof(set[0]))-1;
  17.  
  18.     while (start<end)
  19.     {
  20.         // 首尾元素互换
  21.         int temp = set[start];
  22.         set[start] = set[end];
  23.         set[end] = temp;
  24.  
  25.         // 下标更新
  26.         start++;
  27.         end--;
  28.     }
  29.  
  30.     //打印输出逆置后的数组
  31.     cout << "数组元素逆置后为：" << endl;
  32.     for(int j=0;j<5;j++)
  33.     {
  34.         cout << set[j] << endl;
  35.     }
  36.  
  37.     return 0;
  38. }

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

升序排序、降序排序。

练习：对42805719进行升序排列

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

      第一轮对比完成后结果为：240571389

2、找到第一个最大值：9

     这个9就像一个气泡一样冒出来，所以叫它冒泡排序。

3、重复上面的步骤，每次比较次数-1，直到不需要比较。

     第一轮对比8次（元素数-1），第二轮对比7次...

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {  
  6.     int set[9] = {4,2,8,0,5,7,1,3,9};
  7.     cout << "未排序之前的数组为：" << endl;
  8.     for(int i=0;i<9;i++)
  9.     {
  10.         cout << set[i] << endl;
  11.     }
  12.  
  13.     // 开始冒泡排序：总共排序的轮数=元素个数-1
  14.     for(int i=0;i<9-1;i++)
  15.     {
  16.         // 内层循环对比=元素个数-当前轮数-1
  17.         for(int j=0;j<9-i-1;j++)
  18.         {
  19.             // 如果第一个数字比第二个数字大，交换两个数字
  20.             if(set[j] > set[j+1])
  21.             {  
  22.                 // 实现两个元素的交换。
  23.                 int temp = set[j];
  24.                 set[j] = set[j+1];
  25.                 set[j+1] = temp;
  26.             }
  27.         }
  28.     }
  29.  
  30.     cout << "排序后结果为：" << endl;
  31.     for(int s=0;s<9;s++)
  32.     {
  33.         cout << set[s] << endl;
  34.     }
  35.  
  36.     return 0;
  37. }

2、二维数组

二维数组的四种定义方式：

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

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

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

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

推荐第二种，更为直观。

按照以下坐标进行访问：

利用for循环打印二维数组中的每个元素：

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {  
  6.     int set[2][3] = {{1,2,3},{4,5,6}};
  7.  
  8.     for(int i=0;i<2;i++)
  9.     {
  10.         for(int j=0;j<3;j++)
  11.         {
  12.             cout << set[i][j] << endl;
  13.         }
  14.     }
  15.  
  16.     return 0;
  17. }

二维数组名：

1、查看二维数组所占用的内存空间；

2、获取二维数组首地址。

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {  
  6.     int set[2][3] = {{1,2,3},{4,5,6}};
  7.  
  8.     // 1、查看二维数组占用的内存空间大小
  9.     cout << "二维数组占用的内存空间为：" << sizeof(set) << endl; 
  10.     cout << "二维数组第一行占用的内存空间为：" << sizeof(set[0]) << endl;
  11.  
  12.     // 可以利用sizeof求行数：整个/每行；求列数：每行/每个。
  13.     cout << "二维数组的行数为：" << sizeof(set)/sizeof(set[0]) << endl;
  14.     cout << "二维数组的列数为：" << sizeof(set[0])/sizeof(set[0][0]) << endl;
  15.  
  16.   
  17.     // 2、查看二维数组的首地址
  18.     cout << "二维数组的首地址为：" << set <<endl;
  19.     // 转成十进制：
  20.     cout << "二维数组的首地址为：" << (long long)set <<endl;
  21.     cout << "二位数组第一行首地址为：" << (long long)&set[0] <<endl;
  22.     cout << "二位数组第一个元素首地址为：" << (long long)&set[0][0] << endl;
  23.     // 二维数组的首地址=二维数组第一行的首地址=位数组第一个元素的首地址
  24.  
  25.     return 0;
  26. }

练习：考试成绩统计：

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {  
  6.     int grade[3][3] = {{100,100,100},{90,50,100},{60,70,80}};
  7.     for(int i=0;i<3;i++)
  8.     {  
  9.         int sum = 0;
  10.         for(int j=0;j<3;j++)
  11.         {  
  12.             sum += grade[i][j];
  13.             // cout << grade[i][j];
  14.         }
  15.         cout << sum << endl;
  16.     }
  17.  
  18.     return 0;
  19. }

六、函数

1、函数的定义

函数的定义要有以下五个步骤：

返回值类型、函数名、形参列表、函数体语句、return表达式

返回值类型 函数名 (形参列表)

{

   函数体语句;

   return表达式;

}

如：计算两个数相加的函数。

int add(int a,int b)

{

    int sum = a + b;

    return sum;

}

2、函数的调用

函数名(实参)

练习：调用上面的加法函数。

int main()

{  

    int num1 = 10;

    int num2 = 20;

    int s = add(num1,num2);

    cout << s << endl;

    return 0;

}

在函数定义的时候，a和b并没有真实的数据，只是一个形式上的参数，简称形参；后面调用的时候，实参的值会传递给形参。

函数调用时实参将数值传递给形参，这就叫值传递。

3、函数的常见样式

常见四种：无参无返、有参无返、无参有返、有参有返。

无返回值都用void声明返回值类型。

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. // 1、无参无返：void
  5. void test01()
  6. {
  7.     cout << "test01函数" << endl;
  8. }
  9.  
  10. // 2、有参无返：void
  11. void test02(int a)
  12. {
  13.     cout << "test02函数，传入的参数:" << a << endl;
  14. }
  15.  
  16. // 3、无参有返
  17. int test03()
  18. {
  19.     cout << "test03函数" << endl;
  20.     return 3;
  21. }
  22.  
  23. // 4、有参有返
  24. int test04(int b)
  25. {
  26.     cout << "test04函数，传入的参数:" << b << endl;
  27.     return b;
  28. }
  29.  
  30. int main()
  31. {  
  32.     // 调用无参无返函数
  33.     test01();
  34.  
  35.     // 调用有参无返函数
  36.     test02(2);
  37.  
  38.     // 调用无参有返函数，如果有返回值了就需要有变量来接收。
  39.     int s = test03();
  40.     cout << "test03返回值为:" << s << endl;
  41.  
  42.     // 调用有参有返函数
  43.     int t = test04(4);
  44.     cout << "test04返回值为:" << t << endl;
  45.  
  46.     return 0;
  47. }

4、函数的声明

告诉编译器函数名称及如何调用函数，函数的实际主体可以单独定义。

为什么要写函数的声明？——之前只能在main函数体前写函数，这样程序才会执行，但是如果想把函数写在main函数体后面，需要先告诉编译器函数的存在，这就需要利用函数的声明。

声明可以写多次，但是定义函数只有一次。

练习：比较函数，两个整形数字进行比较，返回较大的值。

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. // 声明比较函数max的存在
  5. int max(int a,int b);
  6.  
  7. int main()
  8. {  
  9.     int a = 10;
  10.     int b = 20;
  11.     cout << max(a,b) << endl;
  12.     return 0;
  13. }
  14.  
  15. // 定义比较函数max
  16. int max(int a,int b)
  17. {
  18.     return a>b?a:b;
  19. }

七、指针

1、指针的定义和使用

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

内存编号是从0开始记录的，一般用十六进制数字表示，可以用指针变量保存地址。

指针的定义：

数据类型 变量名 = 变量值;

数据类型 * 指针变量名;

指针变量名 = &变量名;

或者直接：数据类型 * 指针变量名 = &变量名

指针的使用：

通过解引用的方式来找到指针指向的内存。

* 指针变量名

&取地址，*取值。

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {
  6.     int a = 10;
  7.  
  8.     // 定义指针
  9.     int* p;
  10.     p = &a;
  11.     // 或者直接：int* p = &a;其中，p就是指针（地址）。
  12.  
  13.     // 获取指针中存放的地址：
  14.     cout << "指针中存放的地址编号为：" << p << endl;
  15.     // 输出结果为：指针中存放的地址编号为：0x61fe14
  16.  
  17.     // 获取指针中存放的地址中存放的数据：解引用，在指针前加一个*就是解引用，可以找到指针指向的内存中的数据。
  18.     cout << "指针中地址编号中存放的数据为：" << *p << endl;
  19.     // 输出结果为：指针中地址编号中存放的数据为：10
  20.  
  21.     return 0;
  22. }

2、指针所占的内存空间

指针也是一种数据类型，一般来说，在32位操作系统下占4个字节，64位下占8个字节。

3、空指针和野指针

空指针：指针变量指向内存为0的空间，用于初始化指针变量。

空指针指向的内存是不可以访问的。

如果一开始不知道指针指向哪里合适，可以用空指针。

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {
  6.     // 1、空指针用于初始化指针变量
  7.     int* p = NULL;
  8.  
  9.     // 2、空指针不可访问
  10.     *p = 100;
  11.     // 这个运行会报错！
  12.  
  13.     return 0;
  14. }

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

在程序中要尽量避免出现。

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {
  6.     // 野指针：我们随便编了一个内存地址
  7.     int* p = (int*)0x1100;
  8.     // 这个运行会报错！
  9.  
  10.     return 0;
  11. }

4、const修饰指针

①const修饰指针：常量指针——指针指向可以修改，指针指向的值不能修改。

const int * p = & a;

②const修饰常量：指针常量——指针指向的值能修改，指针指向不能修改。

int * const p = & a;

③const既修饰指针，又修饰常量——指针指向和指针指向的值都不能修改。

小技巧：可以把const译成常量，*译成指针，const *就是常量指针，*const就是指针常量。

5、指针和数组、指针和函数

1、指针和数组：利用指针访问数组中的元素。

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {
  6.     int arr[10] = {1,2,3,4,5,6,7,8,9,10};
  7.     int *p = arr;
  8.  
  9.     // 数组名就是地址，数组名是第一个元素的地址，和数组地址虽然值一样，但指向大小不一样。
  10.     cout << "利用指针来访问第一个元素：" << *p << endl;
  11.  
  12.     // 让指针往后移4个字节即可（一个整型 元素占4个字节）
  13.     p++;
  14.     cout << "利用指针来访问第二个元素：" << *p << endl;
  15.  
  16.     return 0;
  17. }

还可以直接p[i]，下标从0开始

2、指针和函数：利用指针作函数参数，可以修改实参的值。

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. // 函数：两个数字进行交换
  5. // 1、值传递
  6. void swap01(int a,int b)
  7. {
  8.     int temp = a;
  9.     a = b;
  10.     b = temp;
  11.     cout << "swap01中的a=" << a << endl;
  12.     cout << "swap01中的b=" << b << endl;
  13. }
  14.  
  15. // 2、地址传递：如果我们想在函数体中真的修改外部的a、b的数据，就用这个
  16. void swap02(int *p1,int *p2)
  17. {
  18.     int temp = *p1;
  19.     *p1 = *p2;
  20.     *p2 = temp;
  21.     cout << "swap02中的a=" << *p1 << endl;
  22.     cout << "swap02中的b=" << *p2 << endl;
  23. }
  24.  
  25. int main()
  26. {
  27.     int a = 10;
  28.     int b = 20;
  29.  
  30.     // 1、值传递
  31.     swap01(a,b);
  32.     cout << "运行swap01后外部的a=" << a << endl;
  33.     cout << "运行swap01后外部的b=" << b << endl;
  34.  
  35.     // 2、地址传递
  36.     swap02(&a,&b);
  37.     cout << "运行swap02后外部的a=" << a << endl;
  38.     cout << "运行swap02后外部的b=" << b << endl;
  39.  
  40.     return 0;
  41. }

原因：地址传递是直接改了地址，地址交换了，里面存储的数据自然也就交换了。

3、指针配合函数、数组的案例：

案例：封装一个函数，利用冒泡排序，实现对整型数组的升序排序。

例如一个数组：int arr[10] = {4,3,6,9,1,2,10,8,7,5};

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. // 冒泡排序函数：参数1：数组地址，参数2：数组长度
  5. void bubble(int *arr,int len)
  6. {
  7.     for(int i=0;i<len-1;i++)
  8.     {
  9.         for(int j=0;j<len-i-1;j++)
  10.         {
  11.             if(arr[j]>arr[j+1])
  12.             {
  13.                 int temp = arr[j];
  14.                 arr[j] = arr[j+1];
  15.                 arr[j+1] = temp;
  16.             }
  17.         }
  18.     }
  19. }
  20.  
  21. // 打印数组的函数：
  22. void printarr(int *arr,int len)
  23. {
  24.     for(int i=0;i<len;i++)
  25.     {
  26.         cout << arr[i] << endl;
  27.     }
  28. }
  29.  
  30. int main()
  31. {
  32.     int arr[10] = {4,3,6,9,1,2,10,8,7,5};
  33.     int len = sizeof(arr)/sizeof(arr[0]);
  34.  
  35.      // 一般来说，需要传入数组、数组的长度。
  36.     bubble(arr,len);
  37.     printarr(arr,len);
  38.  
  39.     return 0;
  40. }

核心：

如何把一个数组传入一个函数中？——用指针接收首地址；

熟练运用冒泡排序；

在函数中使用数组，最好还要传入它的长度。

八、结构体

结构体属于用户自定义的数据类型，允许用户储存不同的数据类型。

整型、字符型等，这些数据类型都属于内置的数据类型。

如果要写一个动物的数据类型？——结构体可以实现。

1、结构体的定义和使用

定义结构体：struct 结构体名 {结构体成员列表};

使用结构体的三种方式：

1、struct 结构体名 变量名

2、struct 结构体名 变量名 = {成员1值,成员2值...}

3、定义结构体时顺便创建变量

  1. #include <iostream>
  2. using namespace std;
  3. #include <string>
  4.  
  5. // 创建学生数据类型，学生包括：姓名、年龄、分数
  6. // 自定义数据类型就是一些内置数据类型的集合。
  7. struct Student
  8. {  
  9.     // 成员列表：姓名、年龄、分数
  10.     string name;
  11.     int age;
  12.     int score;
  13. }s3; // 方法三：定义结构体的时候顺便创建变量
  14.  
  15. int main()
  16. {  
  17.     // 方法一：struct 结构体名 变量名
  18.     struct Student s1;
  19.     // 给s1属性赋值，通过.访问结构体变量中的属性
  20.     s1.name = "张三";
  21.     s1.age = 18;
  22.     s1.score = 100;
  23.     cout << "姓名：" << s1.name << endl << "年龄：" << s1.age << endl << "分数：" << s1.score << endl;
  24.  
  25.     // 方法二：struct 结构体名 变量名 = {值1,值2...};注意按顺序
  26.     struct Student s2 = {"李四",19,80};
  27.     cout << "姓名：" << s2.name << endl << "年龄：" << s2.age << endl << "分数：" << s2.score << endl;
  28.  
  29.  
  30.     // 方法三：定义结构体的时候顺便创建变量
  31.     s3.name = "王五";
  32.     s3.age = 20;
  33.     s3.score = 90;
  34.     cout << "姓名：" << s3.name << endl << "年龄：" << s3.age << endl << "分数：" << s3.score << endl;
  35.  
  36.     return 0;
  37. }

一般来说用第一种、第二种比较多，第三种少一点。

定义的时候struct关键字不可以省略，创建的时候可以省略。

利用.访问它的成员。

2、结构体数组

struct 结构体名 数组名[元素个数] = {{},{},...{}}

  1. #include <iostream>
  2. using namespace std;
  3. #include <string>
  4.  
  5. // 1、定义学生结构体，包括：姓名、年龄、分数
  6. struct Student
  7. {  
  8.     string name;
  9.     int age;
  10.     int score;
  11. };
  12.  
  13. int main()
  14. {  
  15.     // 2、创建结构体数组，给结构体数组中的元素赋值
  16.     struct Student stu_arr[3] = {{"张三",18,100},{"李四",19,80},{"王五",20,90}};
  17.  
  18.     // 3、修改结构体数组中的元素值
  19.     stu_arr[2].name = "尼古拉斯·赵四";
  20.  
  21.     // 4、遍历结构体数组并输出
  22.     for(int i=0;i<3;i++)
  23.     {
  24.         cout << "姓名：" << stu_arr[i].name << endl;
  25.         cout << "年龄：" << stu_arr[i].age << endl;
  26.         cout << "分数：" << stu_arr[i].score << endl;
  27.     }
  28.  
  29.     return 0;
  30. }

3、结构体指针

  1. #include <iostream>
  2. using namespace std;
  3. #include <string>
  4.  
  5. // 1、定义学生结构体，包括：姓名、年龄、分数。
  6. struct Student
  7. {  
  8.     string name;
  9.     int age;
  10.     int score;
  11. };
  12.  
  13. int main()
  14. {  
  15.     // 2、创建学生结构体变量。
  16.     struct Student s = {"张三",18,100};
  17.  
  18.     // 3、通过指针指向结构体变量。
  19.     struct Student* p = &s;
  20.    
  21.     // 4、通过指针访问结构体变量数据，需要利用符号->，也可以用(*p).访问。
  22.     cout << "姓名：" << p->name << endl << "年龄：" << p->age << endl << "分数：" << p->score << endl;
  23.  
  24.     return 0;
  25. }

4、结构体嵌套结构体

结构体中的成员可以是另一个结构体，如老师辅导学员，一个老师的结构体中记录一个学生的结构体。

  1. #include <iostream>
  2. using namespace std;
  3. #include <string>
  4.  
  5. // 定义学生结构体（要先于老师），包括：姓名、年龄、分数
  6. struct Student
  7. {  
  8.     string name;
  9.     int age;
  10.     int score;
  11. };
  12.  
  13. // 定义老师结构体：工号、姓名、年龄、学生结构体
  14. struct Teacher
  15. {
  16.     int id;
  17.     string name;
  18.     int age;
  19.     struct Student stu;    
  20. };
  21.  
  22. int main()
  23. {  
  24.     struct Teacher tea;
  25.     tea.id = 1010;
  26.     tea.name = "孙老师";
  27.     tea.age = 32;
  28.  
  29.     tea.stu.name = "张三";
  30.     tea.stu.age = 18;
  31.     tea.stu.score = 100;
  32.  
  33.     cout << "老师工号：" << tea.id << endl << "老师姓名：" << tea.name << endl << "老师年龄" << tea.age << endl << "老师带的学生：" << tea.stu.name << endl << "学生年龄：" << tea.stu.age << endl << "学生分数：" << tea.stu.score << endl;
  34.  
  35.     return 0;
  36. }

5、结构体做函数参数

将结构体作为参数向函数中传递，传递方式有两种：值传递和地址传递。

  1. #include <iostream>
  2. using namespace std;
  3. #include <string>
  4.  
  5. // 定义学生结构体，包括：姓名、年龄、分数
  6. struct Student
  7. {  
  8.     string name;
  9.     int age;
  10.     int score;
  11. };
  12.  
  13. // 1、值传递
  14. void print01(struct Student s1)
  15. {  
  16.     s1.age = 20;
  17.     cout << "值传递中打印的s1信息为：" << endl << "姓名：" << s1.name << endl << "年龄：" << s1.age << endl << "分数：" << s1.score << endl;
  18. }
  19.  
  20. // 2、地址传递
  21. void print02(struct Student * p)
  22. {
  23.     p->age = 20;
  24.     cout << "地址传递中打印的s2信息为：" << endl << "姓名：" << p->name << endl << "年龄：" << p->age << endl << "分数：" << p->score << endl;
  25. }
  26.  
  27. int main()
  28. {  
  29.     struct Student s1;
  30.     s1.name = "张三";
  31.     s1.age = 18;
  32.     s1.score = 100;
  33.     print01(s1);
  34.     cout << "值传递后打印的s1信息为：" << endl << "姓名：" << s1.name << endl << "年龄：" << s1.age << endl << "分数：" << s1.score << endl;
  35.  
  36.     struct Student s2;
  37.     s2.name = "李四";
  38.     s2.age = 19;
  39.     s2.score = 80;
  40.     print02(&s2);
  41.     cout << "地址传递后打印的s2信息为：" << endl << "姓名：" << s2.name << endl << "年龄：" << s2.age << endl << "分数：" << s2.score << endl;
  42.  
  43.     return 0;
  44. }

 地址传递会真正改变实参，值传递不会。

6、结构体中的const使用场景

用const来防止误操作。

  1. #include <iostream>
  2. using namespace std;
  3. #include <string>
  4.  
  5. struct Student
  6. {  
  7.     string name;
  8.     int age;
  9.     int score;
  10. };
  11.  
  12. // 打印函数。
  13. // 如果用值传递，当数据量过大时，值传递要拷贝的数据就很多了，为了节省空间，通常会用地址传递（指针），指针只占4个字节，而且还不会多余复制一份数据副本。
  14. void print(const struct Student *p)
  15. {  
  16.     // 在这种地址传递的函数中，有可能会误更改数据比如：p->age=20;这样就会修改全局变量，为了防止这种情况发生，就会在前面加上const。
  17.     cout << "姓名：" << p->name << endl << "年龄：" << p->age << endl << "分数：" << p->score << endl;
  18. }
  19.  
  20. int main()
  21. {  
  22.     struct Student s = {"张三",18,100};
  23.     print(&s);
  24.  
  25.     return 0;
  26. }

7、结构体案例

案例1：每名老师带5个学生，共有3名老师。设计学生和老师结构体，其中在老师结构体中，有姓名和一个存放5名学生的数组。学生结构体有姓名、考试分数。

创建数组存放3名老师，通过函数给每个老师及学生赋值，最终打印出所有数据。

  1. #include <iostream>
  2. using namespace std;
  3. #include <string>
  4. #include <Ctime>
  5.  
  6. struct Student
  7. {
  8.     string name;
  9.     int score;
  10. };
  11.  
  12. struct Teacher
  13. {
  14.     string name;
  15.     struct Student stu_arr[5];
  16. };
  17.  
  18. // 给老师和学生赋值的函数，函数接收数组有两种方法：一种是指针，一种是下面这种
  19. void assignment(struct Teacher tea_arr[],int len)
  20. {
  21.     // 给老师赋值
  22.     string name_tealist = "ABC";
  23.     for(int i=0;i<len;i++)
  24.     {  
  25.         // 做一个拼接字符串的操作：
  26.         tea_arr[i].name = "teacher_";
  27.         tea_arr[i].name += name_tealist[i];
  28.  
  29.         // 给每名老师带的学生赋值
  30.         for(int j=0;j<5;j++)
  31.         {  
  32.             // 学生姓名
  33.             string name_stulist = "ABCDE";
  34.             tea_arr[i].stu_arr[j].name = "student_";
  35.             tea_arr[i].stu_arr[j].name += name_stulist[j];
  36.  
  37.             // 学生成绩，随机数，后面的51表示0-50之间的一个数。
  38.             int random = rand()%51 +50;
  39.             tea_arr[i].stu_arr[j].score = random;
  40.         }
  41.     }
  42. }
  43.  
  44. void print(struct Teacher tea_arr[],int len)
  45. {
  46.     for(int i=0;i<len;i++)
  47.     {
  48.         cout << "老师姓名：" << tea_arr[i].name << endl;
  49.         for(int j=0;j<5;j++)
  50.         {
  51.             cout << "所带学生姓名：" << tea_arr[i].stu_arr[j].name << "，分数：" << tea_arr[i].stu_arr[j].score << endl;
  52.         }
  53.     }
  54. }
  55.  
  56. int main()
  57. {    
  58.     // 随机数种子
  59.     srand((unsigned int) time(NULL));
  60.  
  61.     // 1、创建3名老师的数组
  62.     struct Teacher tea_arr[3];
  63.  
  64.     ///2、通过函数给3名老师赋值，并给老师带的学生赋值
  65.     int len = sizeof(tea_arr)/sizeof(tea_arr[0]);
  66.     assignment(tea_arr,len);
  67.  
  68.     // 3、打印输出所有的老师及学生信息
  69.     print(tea_arr,len);
  70.  
  71.     return 0;
  72. }

案例2：设计一个英雄的结构体，包括：姓名、年龄、性别。

创建结构体数组，数组中存放5名英雄（自己定义）。

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

  1. #include <iostream>
  2. using namespace std;
  3. #include <string>
  4.  
  5. struct Hero
  6. {
  7.     string name;
  8.     int age;
  9.     string gender;
  10. };
  11.  
  12. void bubble(struct Hero hero[],int len)
  13. {
  14.     for(int i=0;i<len-1;i++)
  15.     {
  16.         for(int j=0;j<len-i-1;j++)
  17.         {
  18.             if(hero[j].age > hero[j+1].age)
  19.             {
  20.                 struct Hero temp = hero[j];
  21.                 hero[j] = hero[j+1];
  22.                 hero[j+1] = temp;
  23.             }
  24.         }
  25.     }
  26. }
  27.  
  28. void print(struct Hero hero[],int len)
  29. {
  30.     for(int s=0;s<len;s++)
  31.     {
  32.         cout << "姓名：" << hero[s].name << "，年龄：" << hero[s].age << "，性别：" << hero[s].gender << endl;
  33.     }
  34. }
  35.  
  36. int main()
  37. {    
  38.     struct Hero hero[5] = {{"刘备",23,"男"},{"关羽",22,"男"},{"张飞",20,"男"},{"赵云",21,"男"},{"貂蝉",19,"女"}};
  39.     int len = sizeof(hero)/sizeof(hero[0]);
  40.     bubble(hero,len);
  41.     print(hero,len);
  42.  
  43.     return 0;
  44. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/673064
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号