• C++学习笔记（十）

    一、链表

    1. 链表的概述

    数组和链表的优缺点

    静态数组：int arr [5]; 必须事先确定数组元素的个数，过多浪费，过小容易溢出，删除插入数据效率低（需要移动大量的数据）

    动态数组：不需要事先知道元素的个数，在使用中动态申请，删除插入效率低（需要移动大量的数据）

            （数组优点：遍历元素效率高）

    链表：不需要事先知道数据的个数，在使用中动态申请，插入删除不需要移动数据

            （链表缺点：遍历元素效率低）

    概述

    链表是由一个个节点组成，节点没有名字，每个节点从堆区动态申请，节点间物理上是非连续的，但是每个节点通过指针域保存下一个节点的位置达到逻辑上的连续

    2. 静态链表

    1. #include
    2.  
    3. using namespace std;
    4.  
    5. struct Stu
    6. {
    7.     // 数据域
    8.     int num;
    9.     char name[32];
    10.  
    11.     // 指针域
    12.     struct Stu *next;
    13. };
    14.  
    15. int main(int argc, char *argv[])
    16. {
    17.     struct Stu node1 = {101,"lucy",NULL};
    18.     struct Stu node2 = {102,"bob",NULL};
    19.     struct Stu node3 = {103,"jenny",NULL};
    20.     struct Stu node4 = {104,"danny",NULL};
    21.     struct Stu node5 = {105,"tom",NULL};
    22.  
    23.     // 定义链表头
    24.     struct Stu *head = &node1;
    25.     node1.next = &node2;
    26.     node2.next = &node3;
    27.     node3.next = &node4;
    28.     node4.next = &node5;
    29.     node5.next = NULL;
    30.  
    31.     // 遍历
    32.     struct Stu *pb = head;
    33.     while(pb!=NULL)
    34.     {
    35.         // 访问数据
    36.         cout << pb->num << " " << pb->name << endl;
    37.  
    38.         // pb移动到下一个节点位置
    39.         pb = pb->next;
    40.     }
    41.     return 0;
    42. }

    3. 动态链表

    以学生管理系统案例，完成动态链表的学习

    新建link.cpp，link.h，link.cpp编写功能函数

    ①. main函数设计

    main.cpp

    1. #include 
    2. #include "link.h"
    3. #include 
    4. #include 
    5.  
    6. using namespace std;
    7.  
    8. Stu *head = NULL;
    9.  
    10. int main(int argc, char *argv[])
    11. {
    12.     help();
    13.     while(1)
    14.     {
    15.         char cmd[64] = "";
    16.         cout << "请输入指令:";
    17.         cin >> cmd;
    18.         if(strcmp(cmd,"help")==0)
    19.         {
    20.             help();
    21.         }
    22.         else if(strcmp(cmd,"insert")==0)
    23.         {
    24.             cout << "请输入要插入学生的学号和姓名:";
    25.             Stu temp;
    26.             cin >> temp.num >> temp.name;
    27.  
    28.             head = insertLink(head,temp);
    29.         }
    30.         else if(strcmp(cmd,"print")==0)
    31.         {
    32.             printLink(head);
    33.         }
    34.         else if(strcmp(cmd,"search")==0)
    35.         {
    36.             char stuname[32] = "";
    37.             cout << "请输入要查询的学生姓名:";
    38.             cin >> stuname;
    39.  
    40.             Stu *ret = NULL;
    41.             ret = searchLink(head,stuname);
    42.             if(ret != NULL)
    43.             {
    44.                 cout << "查询结果如下:" << endl;
    45.                 cout << "学号:" << ret->num << " " << "姓名:" << ret->name << endl;
    46.             }
    47.             else
    48.             {
    49.                 cout << "未查询到相关学生信息 ... ..." << endl;
    50.             }
    51.         }
    52.         else if(strcmp(cmd,"delete")==0)
    53.         {
    54.             int stunum = 0;
    55.             cout << "请输入要删除的学生学号:";
    56.             cin >> stunum;
    57.  
    58.             head = deleteLink(head, stunum);
    59.         }
    60.         else if(strcmp(cmd,"free")==0)
    61.         {
    62.             head = freeLink(head);
    63.         }
    64.         else if(strcmp(cmd,"cls")==0)
    65.         {
    66.             system("cls");
    67.         }
    68.         else if(strcmp(cmd,"quit")==0)
    69.         {
    70.             cout << "正在退出 ... ..." << endl;
    71.             Sleep(2000);
    72.             cout << "退出成功 ... ..." << endl;
    73.             return 0;
    74.         }
    75.         else
    76.         {
    77.             cout << "请输入正确的指令 ... ..." << endl;
    78.             help();
    79.         }
    80.     }
    81. }

    ②. link函数设计

    link.cpp

    1. #include "link.h"
    2.  
    3. void help(void)
    4. {
    5.     cout << "-----------------------------" << endl;
    6.     cout << "|  help:帮助信息            |" << endl;
    7.     cout << "|  insert:插入链表节点      |" << endl;
    8.     cout << "|  print:遍历链表           |" << endl;
    9.     cout << "|  search:查询链表某个节点  |" << endl;
    10.     cout << "|  delete:删除链表某个节点  |" << endl;
    11.     cout << "|  free:释放整个链表        |" << endl;
    12.     cout << "|  cls:清空屏幕             |" << endl;
    13.     cout << "|  quit:退出程序            |" << endl;
    14.     cout << "-----------------------------" << endl;
    15. }
    16.  
    17. // 插入:头部插入
    18. #if 0
    19. Stu *insertLink(Stu *head, Stu temp)
    20. {
    21.     // 从堆区申请待插入的节点空间
    22.     Stu *pi = new Stu;
    23.     // 给空间赋值
    24.     *pi = temp;
    25.     pi->next = NULL;
    26.  
    27.     // 判断链表是否存在
    28.     if(head == NULL)//不存在
    29.     {
    30.         head = pi;
    31.     }
    32.     else//链表存在
    33.     {
    34.         pi->next = head;
    35.         head = pi;
    36.     }
    37.     return head;
    38. }
    39. #endif
    40.  
    41. // 插入:尾部插入
    42. #if 0
    43. Stu *insertLink(Stu *head, Stu temp)
    44. {
    45.     // 从堆区申请待插入的节点空间
    46.     Stu *pi = new Stu;
    47.     // 给空间赋值
    48.     *pi = temp;
    49.     pi->next = NULL;
    50.  
    51.     // 判断链表是否存在
    52.     if(head == NULL)//不存在
    53.     {
    54.         head = pi;
    55.     }
    56.     else//链表存在
    57.     {
    58.         // 寻找尾节点
    59.         Stu *pb = head;
    60.         while(pb->next!=NULL)
    61.         {
    62.             pb = pb->next;
    63.         }
    64.         // 在尾节点插入pi
    65.         pb->next = pi;
    66.     }
    67.     return head;
    68. }
    69. #endif
    70.  
    71. // 插入:有序插入
    72. #if 1
    73. Stu *insertLink(Stu *head, Stu temp)
    74. {
    75.     // 从堆区申请待插入的节点空间
    76.     Stu *pi = new Stu;
    77.     // 给空间赋值
    78.     *pi = temp;
    79.     pi->next = NULL;
    80.  
    81.     // 判断链表是否存在
    82.     if(head == NULL)//不存在
    83.     {
    84.         head = pi;
    85.     }
    86.     else//链表存在
    87.     {
    88.         // 寻找插入点
    89.         Stu *pb=head, *pf=head;
    90.         while((pb->num < pi->num) && (pb->next != NULL))
    91.         {
    92.             // pf保存pb的位置
    93.             pf = pb;
    94.             // pb移动到下一个节点
    95.             pb = pb->next;
    96.         }
    97.  
    98.         //判断插入点位置
    99.         if(pb->num >= pi->num)// 头部、中部插入
    100.         {
    101.             if(pb == head)// 头部插入
    102.             {
    103.                 pi->next = head;
    104.                 head = pi;
    105.             }
    106.             else// 中部插入
    107.             {
    108.                 pf->next = pi;
    109.                 pi->next = pb;
    110.             }
    111.         }
    112.         else// 尾部插入
    113.         {
    114.             pb->next = pi;
    115.         }
    116.     }
    117.     return head;
    118. }
    119. #endif
    120.  
    121. // 遍历链表
    122. void printLink(Stu *head)
    123. {
    124.     // 判断链表是否为空
    125.     if(head == NULL)
    126.     {
    127.         cout << "link not exist ... ..." << endl;
    128.     }
    129.     Stu *pb = head;
    130.     while(pb != NULL)
    131.     {
    132.         cout << "学号:" << pb->num << " " << "姓名:" << pb->name << endl;
    133.         pb = pb -> next;
    134.     }
    135. }
    136.  
    137. // 查询链表某个节点
    138. Stu *searchLink(Stu *head, char *stuname)
    139. {
    140.     // 判断链表是否存在
    141.     if(head == NULL)
    142.     {
    143.         cout << "link not exist ... ..." << endl;
    144.     }
    145.  
    146.     // 逐个节点查询
    147.     Stu *pb = head;
    148.     while((strcmp(pb->name,stuname) != 0) && (pb->next != NULL))
    149.     {
    150.         pb = pb->next;
    151.     }
    152.  
    153.     if(strcmp(pb->name,stuname) == 0)
    154.     {
    155.         return pb;
    156.     }
    157.     return NULL;
    158. }
    159.  
    160. // 删除链表某个节点
    161. Stu *deleteLink(Stu *head, int stunum)
    162. {
    163.     // 判断链表是否存在
    164.     if(head == NULL)
    165.     {
    166.         cout << "link not exist ... ..." << endl;
    167.     }
    168.  
    169.     // 逐个节点比较,寻找删除点
    170.     Stu *pb = head, *pf = head;
    171.     while((pb->num != stunum) && (pb->next != NULL))
    172.     {
    173.         pf = pb;
    174.         pb = pb->next;
    175.     }
    176.  
    177.     if(pb->num == stunum)
    178.     {
    179.         if(pb == head)// 头节点删除
    180.         {
    181.             head = head->next;
    182.         }
    183.         else// 中尾部删除节点
    184.         {
    185.             pf->next = pb->next;
    186.         }
    187.         delete pb;
    188.         cout << "相关学生信息删除成功 .. ..." << endl;
    189.     }
    190.     else
    191.     {
    192.         cout << "未找到到要删除的学生信息 ... ..." << endl;
    193.     }
    194.     return head;
    195. }
    196.  
    197. // 释放整个链表
    198. Stu *freeLink(Stu *head)
    199. {
    200.     // 判断链表是否存在
    201.     if(head == NULL)
    202.     {
    203.         cout << "link not exist ... ..." << endl;
    204.         return head;
    205.     }
    206.     else
    207.     {
    208.         cout << "正在释放链表 ... ..." << endl;
    209.     }
    210.  
    211.     // 逐个节点释放
    212.     Stu *pb = head;
    213.     while(pb != NULL)
    214.     {
    215.         head = head->next;
    216.         delete pb;
    217.         pb = head;
    218.     }
    219.     cout << "链表释放成功 ... ..." << endl;
    220.     return head;
    221. }

    ③. link.h

    1. #ifndef LINK_H
    2. #define LINK_H
    3. #include 
    4. #include 
    5.  
    6. using namespace std;
    7.  
    8. // 定义链表节点
    9. struct Stu
    10. {
    11.     // 数据域
    12.     int num;
    13.     char name[32];
    14.  
    15.     // 指针域
    16.     Stu *next;
    17. };
    18.  
    19. extern void help(void);
    20. extern Stu *insertLink(Stu *head, Stu temp);
    21. extern void printLink(Stu *head);
    22. extern Stu *searchLink(Stu *head, char *stuname);
    23. extern Stu *deleteLink(Stu *head, int stunum);
    24. extern Stu *freeLink(Stu *head);
    25.  
    26. #endif // LINK_H

    二、C++对C的扩展

    1. 面向对象编程概述

    ①. 面向过程

    面向过程是一种以过程为中心的编程思想。通过分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。面向过程编程思想的核心：功能分解，自顶向下，逐层细化（程序=数据结构+算法）。面向过程编程语言存在的主要缺点是不符合人的思维习惯，而是要用计算机的思维方式去处理问题，而且面向过程编程语言重用性低，维护困难。

    ②. 面向对象

    面向对象编程（Object—Oriented Programming）简称OOP技术，是计算机应用程序的一种新方法、新思想。过去的面向过程编程常常会导致所有的代码都包含在几个模块中，使程序难以阅读和维护。在做一些修改时常常牵一动百，使以后的开发和维护难以为继。而使用OOP技术，常常要使用许多代码模块，每个模块都只提供特定的功能，他们是彼此独立的，这样就增大了代码重用的几率，更加有利于软件的开发、维护和升级。

    在面向对象中，算法与数据结构被看作是一个整体，称作对象，现实世界中任何类的对象都具有一定的属性和操作，也总能用数据结构与算法两者合一地来描述，所以可以用下面的等式来定义对象和程序：对象 = 算法 + 数据结构，程序 = 对象 + 对象 + 对象 + ......

    从上面的等式可以看出，程序就是许多对象在计算机中相继表现自己，而对象则是一个个程序实体。面向对象编程思想的核心：应对变化，提高复用。

    ③. 面向对象的三大特点

    封装：把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。类将成员变量和成员函数封装在类的内部，根据需要设置访问权限，通过成员函数管理内部状态。

    继承：继承所表达的是类之间相关的关系，这种关系使得对象可以继承另外一类对象的特征和能力。继承的作用：避免公用代码的重复开发，减少代码和数据冗余

    多态：多态性可以简单地概括为 “一个接口，多种方法”，字面意思为多种形态。程序在运行时才决定调用地函数，它是面向对象编程领域的核心概念。

    2. 作用域运算符 ::

    :: 解决归属问题（谁是谁的谁）

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. // 定义全局变量a
    6. int a = 10;
    7.  
    8. int main(int argc, char *argv[])
    9. {
    10.     // 定义局部变量a
    11.     int a = 20;
    12.  
    13.     cout << "全局变量a = " << ::a << endl; // 10
    14.     cout << "局部变量a = " << a << endl; // 20
    15.  
    16.     return 0;
    17. }

    3. 命名空间 namespace

    创建名字是程序设计过程中一项最基本的活动，当一个项目很大时，它会不可避免地包含大量名字。C++允许我们对名字的产生和名字地可见性进行控制。C语言可以通过static关键字来使得名字只在本编译单元内可见，在C++中通过一种命名空间来控制对名字的访问。

    ①. C++命名空间（namespace）

    在C++中，名称（name）可以是符号常量、变量、函数、结构、枚举、类和对象等等。工程越大，名称互相冲突的可能性越大。另外使用多个厂商的类库时，也可能导致名称冲突。为了避免在大规模程序设计中，以及程序员使用各种各样的C++库时，这些标识符的名称发生冲突，标准C++引入关键字namespace（命名空间/名字空间/名称空间），可以更好地控制标识符的作用域。

    ②. 命名空间使用语法

    1）创建命名空间

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. namespace A {
    6.     int a = 10;
    7. }
    8.  
    9. namespace B {
    10.     int a = 20;
    11. }
    12.  
    13. int main(int argc, char *argv[])
    14. {
    15.     // 定义局部变量a
    16.     int a = 30;
    17.  
    18.     cout << "A::a = " << A::a << endl; // 10
    19.     cout << "B::a = " << B::a << endl; // 20
    20.     cout << "局部变量a = " << a << endl; // 30
    21.  
    22.     return 0;
    23. }

    2）命名空间只能全局范围内定义（以下错误写法）

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5.  
    6. int main(int argc, char *argv[])
    7. {
    8.     namespace A {
    9.         int a = 10;
    10.     }
    11.  
    12.     namespace B {
    13.         int a = 20;
    14.     }
    15.  
    16.     return 0;
    17. }

    3）命名空间可嵌套命名空间

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. namespace A {
    6.     int a = 10;
    7.     namespace C {
    8.         int a = 40;
    9.     }
    10. }
    11.  
    12. namespace B {
    13.     int a = 20;
    14. }
    15.  
    16. int main(int argc, char *argv[])
    17. {
    18.     // 定义局部变量a
    19.     int a = 30;
    20.  
    21.     cout << "A::a = " << A::a << endl; // 10
    22.     cout << "A::C::a = " << A::C::a << endl; // 40
    23.     cout << "B::a = " << B::a << endl; // 20
    24.     cout << "局部变量a = " << a << endl; // 30
    25.  
    26.     return 0;
    27. }

    4）命名空间是开放的，即可以随时把新的成员加入已有的命名空间中

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. namespace A {
    6.     int a = 10;
    7. }
    8.  
    9. namespace A {
    10.     void func()
    11.     {
    12.         cout << "namespace A is here ... ..." << endl;
    13.     }
    14. }
    15.  
    16. int main(int argc, char *argv[])
    17. {
    18.     cout << "A::a = " << A::a << endl; // 10
    19.     A::func(); // namespace A is here ... ...
    20.  
    21.     return 0;
    22. }

    5）声明和实现可分离

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. namespace MySpace {
    6.     void func1();
    7.     void func2(int param);
    8. }
    9.  
    10. void MySpace::func1(){
    11.     cout << "MySpace::func1" << endl;
    12. }
    13.  
    14. void MySpace::func2(int param){
    15.     cout << "MySpace::func2:" << param << endl;
    16. }
    17.  
    18. int main(int argc, char *argv[])
    19. {
    20.     MySpace::func1(); // MySpace::func1
    21.     MySpace::func2(10); // MySpace::func2:10
    22.  
    23.     return 0;
    24. }

    6）无名命名空间

    意味着命名空间中的标识符只能在本文件内访问，相当于这个标识符加上了static，使其可以作为内部链接

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. namespace{
    6.     int a = 10;
    7.     void func1(int param){
    8.         cout << "func1:" << param << endl;
    9.     }
    10. }
    11.  
    12. int main(int argc, char *argv[])
    13. {
    14.     cout << "a:" << a << endl; // 10
    15.     func1(20); // func1:20
    16.  
    17.     return 0;
    18. }

    7）命名空间的别名

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. namespace veryLongNamespace{
    6.     int a = 10;
    7.     void func1(int param){
    8.         cout << "func1:" << param << endl;
    9.     }
    10. }
    11.  
    12. int main(int argc, char *argv[])
    13. {
    14.     namespace VLNS = veryLongNamespace;
    15.     cout << "veryLongNamespace:a:" << veryLongNamespace::a << endl; // 10
    16.     cout << "veryLongNamespace:a:" << VLNS::a << endl; // 10
    17.     veryLongNamespace::func1(20); // func1:20
    18.     VLNS::func1(20); // func1:20
    19.  
    20.     return 0;
    21. }

    ③. using声明 命名空间中的成员可用

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. namespace A{
    6.     int paramA = 20;
    7.     int paramB = 30;
    8.     void funcA(){cout << "this is funcA ... ... " << endl;}
    9.     void funcB(){cout << "this is funcB ... ... " << endl;}
    10. }
    11.  
    12. int main(int argc, char *argv[])
    13. {
    14.     // 1. 通过命名空间域运算符（推荐）
    15.     cout << A::paramA <<
    16.     cout << A::paramB << endl;
    17.     A::funcA();
    18.     A::funcB();
    19.  
    20.     // 2. using声明成员可用
    21.     using A::paramA;
    22.     using A::funcA;
    23.     cout << paramA << endl;
    24.     // cout << paramB << endl; 不可以直接访问
    25.     funcA();
    26.     // funcB(); 不可以直接访问
    27.  
    28.     // 3. 同名冲突
    29.     // int param = 20; 相同作用域注意同名冲突
    30.  
    31.     return 0;
    32. }

    using 声明成员碰到函数重载

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. namespace A{
    6.     void func(){cout << "this is void func ... ..." << endl;}
    7.     void func(int x){cout << "this is void func(int x) ... ..." << x << endl;}
    8.     int func(int x, int y){cout << "this is int func(int x) ... ..." << x+y << endl;}
    9. }
    10.  
    11. int main(int argc, char *argv[])
    12. {
    13.     using A::func;
    14.     func();
    15.     func(10);
    16.     func(10,20);
    17.     return 0;
    18. }

    如果命名空间包含一组相同名字重载的函数，using声明就声明了这个重载函数的所有集合

    ④. using声明 整个命名空间可用

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. namespace A{
    6.     int paramA = 20;
    7.     int paramB = 30;
    8.     void funcA(){cout << "this is funcA ... ..." << endl;}
    9.     void funcB(){cout << "this is funcB ... ..." << endl;}
    10. }
    11.  
    12. int main(int argc, char *argv[])
    13. {
    14.     using namespace A;
    15.     cout << paramA << endl; // 20
    16.     cout << paramB << endl; // 30
    17.     funcA();
    18.     funcB();
    19.  
    20.     // 不会产生二义性（优先寻找局部变量）
    21.     int paramA = 100;
    22.     cout << paramA << endl; // 100
    23.     return 0;
    24. }
    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. namespace A{
    6.     int paramA = 20;
    7.     int paramB = 30;
    8.     void funcA(){cout << "this is funcA ... ..." << endl;}
    9.     void funcB(){cout << "this is funcB ... ..." << endl;}
    10. }
    11.  
    12. namespace B{
    13.     int paramA = 200;
    14.     int paramB = 300;
    15.     void funcA(){cout << "this is funcA ... ..." << endl;}
    16.     void funcB(){cout << "this is funcB ... ..." << endl;}
    17. }
    18.  
    19. int main(int argc, char *argv[])
    20. {
    21.     using namespace A;
    22.     using namespace B;
    23.     // 二义性产生，不知道调用A还是B的paramA
    24.     cout << paramA << endl; 
    25.     
    26.     return 0;
    27. }

    注意：使用using声明或using编译指令会增加命名冲突的可能性，也就是说，如果有名称空间，并在代码中使用作用域解析预算符，则不会出现二义性

    4. struct类型增强

    C中定义结构体变量需要加上struct关键字，C++不需要。C中的结构体只能定义成员变量，不能定义成员函数。C++即可以定义成员变量，也可以定义成员函数。

    ①. 结构体中既可以定义成员变量，也可以定义成员函数

    1. struct Student
    2. {
    3.     string mName;
    4.     int mAge;
    5.     void setName(string name){mName = name;}
    6.     void setAge(int age){mAge = age;}
    7.     void showStudent(){
    8.         cout << "Name:" << mName << "  " << "Age:" << mAge << endl;
    9.     }
    10. };

    ②. C++中定义结构体变量不需要加struct关键字

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. struct Student
    6. {
    7.     string mName;
    8.     int mAge;
    9.     void setName(string name){mName = name;}
    10.     void setAge(int age){mAge = age;}
    11.     void showStudent(){
    12.         cout << "Name:" << mName << "  " << "Age:" << mAge << endl;
    13.     }
    14. };
    15.  
    16. int main(int argc, char *argv[])
    17. {
    18.     Student student;
    19.     student.setName("Bob");
    20.     student.setAge(20);
    21.     student.showStudent(); // Name:Bob  Age:20
    22.  
    23.     return 0;
    24. }

    5. bool类型关键字

    标准C++的bool类型有两种内建的常量true（转换为整数1）和false（转换为整数0）表示状态。这三个名字都是关键字。bool类型只有两个值，true（1值）和false（0值），bool类型占1字节大小，给bool类型赋值时，非0值会自动转换为true（1），0值会自动转换为false（0）

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. int main(int argc, char *argv[])
    7. {
    8.     cout << sizeof(true) << endl; // 1,bool类型占一个字节大小
    9.     cout << sizeof(false) << endl; // 1
    10.  
    11.     bool flag1 = true;
    12.     cout << flag1 << endl; // 1
    13.     flag1 = 10;
    14.     cout << flag1 << endl; // 1,非0自动转换为true(1)
    15.  
    16.     bool flag2 = false;
    17.     cout << flag2 << endl; // 0
    18.  
    19.     return 0;
    20. }

    6. reference 引用

    在C/C++中指针的作用基本都是一样的，但是C++增加了另外一种给函数传递地址的途径，这就是按引用传递（pass-by-reference）。变量名实质上是一段连续内存空间的别名，是一个标号（门牌号），程序中通过变量来申请并命名内存空间通过变量的名字可以使用存储空间

    对一段连续的内存空间只能取一个别名吗？C++中新增了引用的概念，引用可以作为一个已定义变量的别名。

    ①. 引用的定义

    引用的本质：就是给变量名取个别名

    引用的步骤：

    1. &别名

    2. 给哪个变量取别名，就定义该变量

    3. 从上往下整体替换

    ②. 普通变量的引用

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. int main(int argc, char *argv[])
    7. {
    8.     int a =10;
    9.     // 需求:给变量a 取个别名b
    10.     // 定义的时候 &修饰变量为引用 b就是a的别名(引用)
    11.     // 系统不会为引用开辟空间
    12.     int &b = a; // 引用必须初始化
    13.     
    14.     // a和b代表同一空间内容
    15.     cout << a << endl; // 10
    16.     cout << b << endl; // 10
    17.     cout << &a << endl; // 0x61fe88
    18.     cout << &b << endl; // 0x61fe88
    19.     
    20.     // 操作b等于操作a
    21.     b = 100;
    22.     cout << a << endl; // 100
    23.     cout << b << endl; // 100
    24.  
    25.     return 0;
    26. }

    ③. 数组的引用

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. int main(int argc, char *argv[])
    7. {
    8.     int arr[5] = {1,2,3,4,5};
    9.     int n = sizeof(arr)/sizeof(arr[0]);
    10.  
    11.     int (&myArr)[5] = arr;
    12.  
    13.     for(int i=0;i
    14.     {
    15.         cout << myArr[i] << " ";
    16.     }
    17.     cout << endl;
    18.     return 0;
    19. }

    ④. 指针变量的引用

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. int main(int argc, char *argv[])
    7. {
    8.     int num = 10;
    9.     int *p = #
    10.     int *(&myp) = p;
    11.  
    12.     cout << *p << endl; // 10
    13.     cout << *myp << endl; // 10
    14.     return 0;
    15. }

    ⑤. 函数的引用

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. void func()
    7. {
    8.     cout << "this is func ... ..." << endl;
    9. }
    10.  
    11. void (&myfunc)() = func;
    12.  
    13. int main(int argc, char *argv[])
    14. {
    15.     func(); // this is func ... ...
    16.     myfunc(); // this is func ... ...
    17.     return 0;
    18. }

    ⑥. 引用作为函数的参数

    函数内部可以通过引用操作外部变量

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. // 指针实现交换函数
    7. void swap1(int *p1, int *p2)
    8. {
    9.     int temp = *p1;
    10.     *p1 = *p2;
    11.     *p2 = temp;
    12. }
    13.  
    14. // 引用实现交换函数
    15. void swap2(int &x, int &y)
    16. {
    17.     int temp = x;
    18.     x = y;
    19.     y = temp;
    20. }
    21.  
    22. int main(int argc, char *argv[])
    23. {
    24.     int a = 10;
    25.     int b = 20;
    26.     cout << "未交换前:a = " << a << " " << "b = " << b << endl;
    27.     swap1(&a,&b);
    28.     cout << "经过swap1第一次交换后: a = " << a << " " << "b = " << b << endl;
    29.     swap2(a,b);
    30.     cout << "经过swap2第二次交换后: a = " << a << " " << "b = " << b << endl;
    31.     return 0;
    32. }

    引用的语法更清楚简单：

    1）函数调用时传递的实参不必加 & 符

    2）在被调函数中不必在参数前面加 * 符，引用作为其他变量的别名而存在，因此在一些场合可以替代指针。

    3）C++主张用引用传递取代地址传递的方式，因为引用语法容易且不易出错

    ⑦. 引用作为函数的返回值

    1）不要返回普通局部变量的引用

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. int &getData()
    7. {
    8.     int num = 10;
    9.  
    10.     // 不要返回局部变量的引用
    11.     return num; // 返回num 函数调用的结果就是num的别名
    12. }
    13.  
    14. int main(int argc, char *argv[])
    15. {
    16.     // b就是num的别名
    17.     int &b = getData();
    18.     cout << b << endl; // 无输出,num在函数调用完成后已经被释放
    19.     return 0;
    20. }

    2）返回值类型为引用可以完成链式操作

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. struct Stu
    7. {
    8.     Stu &printStu(Stu &ob, int value)
    9.     {
    10.         cout << value << " ";
    11.         return ob;
    12.     }
    13. };
    14.  
    15. int main(int argc, char *argv[])
    16. {
    17.     Stu ob1;
    18.     ob1.printStu(ob1, 100).printStu(ob1, 200).printStu(ob1, 300); // 100 200 300
    19.     cout << endl;
    20.     return 0;
    21. }

    ⑧. 常引用

    1）给常量取别名，不能通过常饮用修改内容

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. int main(int argc, char *argv[])
    7. {
    8.     // int &a = 10; erro
    9.     const int &a = 10; // a就是10的别名
    10.     // a = 100; erro
    11.     cout << a << endl;
    12.     return 0;
    13. }

    2）常引用作为函数的参数：防止函数内部修改外部的值

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. void printInt(const int &a)
    7. {
    8.     // a = 200; erro
    9.     cout << "a = " << a << endl;
    10. }
    11.  
    12. int main(int argc, char *argv[])
    13. {
    14.     int num = 100;
    15.     printInt(num); // a = 100
    16.     return 0;
    17. }

    7. 内联函数

    ①. 声明内联函数

    内联函数必须在定义的时候使用关键字 inline 修饰，不能再声明的时候使用 inline

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. // 函数声明的时候不能使用inline
    7. int my_add(int x, int y);
    8.  
    9. int main(int argc, char *argv[])
    10. {
    11.     cout << my_add(100,200) << endl;
    12.     return 0;
    13. }
    14.  
    15. // 内联函数在定义的时候使用inline
    16. inline int my_add(int x, int y)
    17. {
    18.     return x+y;
    19. }

    内联函数：在编译阶段，将内联函数中的函数体替换函数调用出。避免函数调用时的开销。

    ②. 宏函数和内联函数的区别

    宏函数和内联函数都会在适当的位置进行展开，避免函数调用开销

    宏函数的参数没有类型，不能保证参数的完整性；内联函数的参数有类型，能保证参数的完整性

    宏函数在预处理阶段展开；内联函数在编译阶段展开

    宏函数没有作用域的限制，不能作为命名空间、结构体、类的成员；内联函数有作用域的限制，能作为命名空间、结构体、类的成员

    ③. 内联函数的注意事项

    在内联函数定义的时候加 inline 修饰

    类中的成员函数默认都是内联函数（不加 inline 也是内联函数）

    有时候加上 inline 也不一定是内联函数（内联函数的条件）

            1）不能存在任何形式的循环语句

            2）不能存在过多的条件判断语句

            3）函数体不能过于庞大

            4）不能对函数取地址

    有时候不加 inline 修饰也可能是内联函数

    内不内联由编译器决定

    8. 函数重载

    ①. 函数重载的概述

    能使名字方便使用，是任何程序设计语言的一个重要特征

    现实生活中经常会碰到一些字在不同的场景下具有不同的意思，我们需要根据上下文判断其意思。同样一个字在不同的场景下具有不同的含义。在C++中也有一种类似的现象出现，同一个函数名在不同的场景下具有不同的含义。

    函数重载是C++的多态的特性（静态多态）

    函数重载：用同一个函数名代表不同的函数功能

    ②. 函数重载的条件

    同一作用域，函数的参数类型、个数、顺序不同，都可以重载。（返回值类型不能作为重载的条件）

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. void printFun(int a)
    7. {
    8.     cout << "int" << endl;
    9. }
    10.  
    11. void printFun(int a, char b)
    12. {
    13.     cout << "int char" << endl;
    14. }
    15.  
    16. void printFun(char a, int b)
    17. {
    18.     cout << "char int" << endl;
    19. }
    20.  
    21. void printFun(char a)
    22. {
    23.     cout << "char" << endl;
    24. }
    25.  
    26. int main(int argc, char *argv[])
    27. {
    28.     printFun(10); // int
    29.     printFun(10,'a'); // int char
    30.     printFun('a',10); // char int
    31.     printFun('a'); // char
    32.     return 0;
    33. }
    34.

    思考：为什么函数返回值不能作为重载条件呢？

    当编译器能从上下文中确认唯一的函数时，如 int ret = func() ，这个当时是没有问题的。然而，我们在编写程序过程中可以忽略他的返回值。那么这个时候，一个函数为 void func(int x) ; 另一个函数为 int func(int x) ；当我们直接调用 func(10) ，这个时候编译器就不能确定调用哪个函数。所以在C++中禁止使用返回值作为重载的条件

    ③. 函数重载的底层实现原理

    1. void func(){}
    2. void func(int x){}
    3. void func(int x, char y){}

    以上三个函数在linux下生成的编译之后的函数名为

    1. _z4funcv // v 代表void,无参数
    2. _z4funci // i 代表参数为int类型
    3. _z4funcic // i 代表第一个参数为int类型,第二个参数为char类型

    不同编译器可能会产生不同的内部名，此处仅举例说明

    9. 函数的默认参数

    C++在声明函数原型时可以为一个或者多个参数指定默认（缺省）参数值，当函数调用的时候没有指定这个值，编译器会自动用默认值代替

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. void Func1(int a=10, int b=20)
    7. {
    8.     cout << "a + b = " << a+b << endl;
    9. }
    10.  
    11. // 注意点:
    12. // 1. 形参b设置默认参数值，那么后面位置的形参c也需要设置默认参数值
    13. void Func2(int a, int b=10, int c=20){}
    14. // 2. 如果函数声明和函数定义分开，函数声明设置了默认参数，函数定义不能在设置默认参数
    15. void Func3(int a=0, int b=0);
    16. void Func3(int a, int b){}
    17.  
    18. int main(int argc, char *argv[])
    19. {
    20.     // 1. 如果没有传参数,那么使用默认参数
    21.     Func1(); // 30
    22.     // 2. 如果传一个参数,那么第二个参数使用默认参数
    23.     Func1(100); // 120
    24.     // 3. 如果传入两个参数,那么两个参数都是传入的参数
    25.     Func1(100,200); // 300
    26.  
    27.     return 0;
    28. }
    29.

    默认参数和函数重载同时出现一定要注意二义性

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. void Func(int x)
    7. {
    8.     cout << "A:int x = " << x << endl;
    9. }
    10.  
    11. void Func(int x, int y=10)
    12. {
    13.     cout << "B:int x = " << x << " " << "y = " << y << endl;
    14. }
    15.  
    16. int main(int argc, char *argv[])
    17. {
    18.     Func(10,20); // ok
    19.     // Func(10); // erro 产生二义性
    20.  
    21.     return 0;
    22. }

    10. 占位参数

    C++在声明函数时，可以设置占位参数。占位参数只有参数类型声明，而没有参数名声明。一般情况下，在函数体内部无法使用占位参数

    1. #include 
    2. #include
    3.  
    4. using namespace std;
    5.  
    6. void Func1(int a, int b, int)
    7. {
    8.     // 函数内部无法使用占位参数
    9.     cout << "a + b = " << a+b << endl;
    10. }
    11.  
    12. // 占位参数也可以设置默认值
    13. void Func2(int a, int b, int = 10)
    14. {
    15.     // 函数内部依然无法使用占位参数
    16.     cout << "a + b = " << a+b << endl;
    17. }
    18.  
    19. int main(int argc, char *argv[])
    20. {
    21.     // 错误调用，占位参数也是参数，必须传参数
    22.     // Func1(10,20)
    23.     // 正确调用
    24.     Func1(10,20,30);
    25.     // 正确调用
    26.     Func2(10,20);
    27.     // 正确调用
    28.     Func2(10,20,30);
    29.  
    30.     return 0;
    31. }

    什么时候用，在后面操作符重载的后置++要用到这个

    11. extern “C”浅析

    以下在Linux下测试：C函数：void MyFunc( ){ }，被编译成函数：MyFunc

    C++函数：void MyFunc( ){ }，被编译成函数：_Z6MyFuncv

    通过这个测试，由于C++中需要支持函数重载，所以C和C++中对同一个函数经过编译后生成的函数名时不相同的，这就导致了一个问题，如果C++中调用一个使用C语言编写模块中的某个函数，那么C++是根据C++的名称修饰方式来查找冰链接这个函数，那么就会发生链接错误，以上例，C++中调用MyFunc函数，在链接阶段会去找_Z6MyFuncv，结果是没有找到的，因为这个MyFunc函数是C语言编写的，生成的符号是MyFunc。那么如果想在C++调用C的函数怎么办？extern "C" 的主要作用就是为了实现C++代码能够调用其他C语言代码。加上extern “C”后，这部分代码编译器按C语言方式进行编译和链接，而不是按C++的方式。

    fun.h

    1. #ifndef MYMODULE_H
    2. #define MYMODULE_H
    3. #include
    4.  
    5. // 第一部分
    6. #if __cplusplus
    7. extern "C"{
    8. #endif
    9.     // 第二部分
    10.     extern void func1();
    11.     extern int func2(int a, int b);
    12. // 第三部分
    13. #if __cplusplus
    14. }
    15. #endif
    16.  
    17. #endif

    fun.c

    1. #include 
    2. #include "fun.h"
    3.  
    4. void func1()
    5. {
    6.     printf("hello world!");
    7. }
    8.  
    9. int func2(int a, int b)
    10. {
    11.     return a+b;
    12. }

    main.cpp

    1. # include 
    2. # include "fun.h"
    3.  
    4. using namespace std;
    5.  
    6. int main()
    7. {
    8.     func1();
    9.     cout << func2(10,20) << endl;
    10.     return 0;
    11. }
  • 相关阅读:
    域名一定需要备案吗？什么情况下不用备案？
    杰理之开了多种解码格式插卡到播放等待的时间长【篇】
    C语言 操作符
    后台系统权限管理设计实战，整合SpringSecurity和JWT（赶紧收藏~）
    老鼠出迷宫
    【java表达式引擎】一、汇总目前开源的公式计算开源库
    VMware Explore | 联想与VMware扩大合作带来生成式AI和多云解决方案
    看看GPT-4V是怎么开车的，必须围观，大模型真的大有作为 | 万字长文
    【Java SE】基本数据类型
    Java 基础常见知识点&面试题总结(下)，2022 最新版！
  • 原文地址：https://blog.csdn.net/zh20001109zh/article/details/127861096