C++ 的第一个步伐

目次

一 . C++的第一个步伐
 二 . 定名空间
2.1 namespace的代价
2.1 namespace 的界说
7.3 定名空间的利用
三 . C++输入&输出
四 . 缺省参数
五 . 函数重载
六 . 引用
6.1 引用的概念和界说
 6.2 引用的特性
 6.3 引用的利用
6.4 const 引用
6.5 指针和引用的关系（笔试常考)

---

一 . C++的第一个步伐

   C++兼容C语言绝大多数的语法，以是C语言实现的 Hello World! 仍然可以运行 ， C++中必要把界说文件代码后缀改为 .cpp ， vs 编译器看到的是 .cpp 就会调用C++编译器编译，linux下要用g++编译，不再是gcc 
  

1. #include <stdio.h>
2. int main()
3. {
4.         printf("Hello World!");
5.         return 0;
6. }

复制代码

固然 ， c++也有自己的一套输入输出 ， 代码如下 :

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

复制代码

 二 . 定名空间

2.1 namespace的代价

在c++中，变量 、函数 和后续必要学到的类都是大量存在的 ， 这些变量 、函数和类的名称都存在于全局作用域中 ， 大概会导致许多辩说 。利用定名空间的目的是对标识符的名称举行当地化 ， 以克订定名辩说和名字污染 ， namespace 关键字的出现就是针对这种题目的 。
c语言项目类似下面步伐如许，出现了定名辩说的题目 ， c++ 引入namespace 就是为了更好的办理这类题目 ！

    全局变量 rand 与 头文件 stdlib.h中 的函数rand 名字发生辩说 ， namespace的引入是为了更好的办理这一个题目 。
  2.1 namespace 的界说

•  界说定名空间 ， 必要利用到namespace 关键字 ， 背面跟定名空间的名字 ， 然后利用花括号 { } 即可 ， { } 里即为定名空间成员。定名空间中可以界说变量/函数/范例等 。
  
•  namespace 本质是界说出一个域 ， 这个域跟全局域各自独立 ， 差别的域可以界说同名变量 ，以是 上述代码 的rand 不再辩说了 。
  

1. #include <stdio.h>
2. #include <stdlib.h>
3. namespace bit
4. {
5.         int rand =10 ;
6. }
7. int main()
8. {
9.         printf("%d\n", bit::rand);
10.         return 0;
11. }

复制代码

   这里的 :: 符号 ： 定名空间限定符 ， 用于指定特定的作用域大概是定名空间 ；比方 bit :: rand 表明 我们必要访问的是bit 定名空间下的rand范例 ， 假如没有这个符号，大概导致定名辩说 。
  

• C++中域有函数局部域 ， 全局域 ， 定名空间域 ， 类域 ； 域影响的是编译时语法查找一个变量/函数/范例出处（声明或界说）的逻辑 ， 以是有了域隔离 ， 名字辩说就办理了 。局部域和全局域除了会影响编译查找逻辑 ， 还会影响变量的生命周期 ， 定名空间域和类域不影响变量的生命周期 。
  
  
  
  

2. #include <stdio.h>
3. #include <stdlib.h>
4. namespace bit
5. {
6.         int rand =10 ;
7. }
8. int main()
9. {
10.         //这里指的是访问全局的rand函数的地址
11.         printf("%p\n", rand);
12.         //这里是访问指定命名空间bit里的rand
13.         printf("%d\n", bit::rand);
14.         return 0;
15. }

复制代码

• namespace 只能界说在全局 ， 固然也可以嵌套界说。
  

2. #include <stdio.h>
3. namespace bit
4. {
5.         namespace zhangsan
6.         {
7.                 int age = 18;
8.                 int add(int x, int y)
9.                 {
10.                         return x + y;
11.                 }
12.         }
13.         namespace lisi
14.         {
15.                 int age = 19;
16.                 int add(int x, int y)
17.                 {
18.                         return x + y;
19.                 }
20.         }
21. }
22. int main()
23. {
24.         printf("%d\n", bit::zhangsan::age);
25.         printf("%d\n", bit::lisi::age);
26.         printf("%d\n", bit::zhangsan::add(1, 2));
27.         printf("%d\n", bit::lisi::add(3, 2));
28.         return 0;
29. }

复制代码

• 项目工程中多文件中界说的同名 namespace 会以为是一个namespace ， 不会辩说。
  

stack.h

1. #pragma once
2. #include<stdio.h>
3. #include<stdlib.h>
4. #include<stdbool.h>
5. #include<assert.h>
7. namespace bit
8. {
9.         typedef int STDataType;
10.         typedef struct Stack
11.         {
12.                 STDataType * a;
13.                 int top;
14.                 int capacity;
15.         }ST;
16.         void STInit(ST * ps, int n);
17.         void STDestroy(ST * ps);
19.         void STPush(ST * ps, STDataType x);
20.         void STPop(ST * ps);
21.         STDataType STTop(ST * ps);
22.         int STSize(ST * ps);
23.         bool STEmpty(ST * ps);
24. }

复制代码

stack.c

1. #include"Stack.h"
2. namespace bit
3. {
4.         void STInit(ST * ps, int n)
5.         {
6.                 assert(ps);
7.                 ps->a = (STDataType*)malloc(n * sizeof(STDataType));
8.                 ps->top = 0;
9.                 ps->capacity = n;
10.         }
12. // 栈顶
13.         void STPush(ST * ps, STDataType x)
14.         {
15.                 assert(ps);
17.         // 满了， 扩容
18.         if (ps->top == ps->capacity)
19.         {
20.                 printf("扩容\n");
21.                 int newcapacity = ps->capacity == 0 ? 4 : ps->capacity* 2;
22.                 STDataType * tmp = (STDataType*)realloc(ps->a,newcapacity * sizeof(STDataType));
23.                         if (tmp == NULL)
24.                         {
25.                                 perror("realloc fail");
26.                                 return;
27.                         }
28.        
29.                 ps->a = tmp;
30.                 ps->capacity = newcapacity;
31.         }
33.                 ps->a[ps->top] = x;
34.                 ps->top++;
35.         }
37. }

复制代码

• c++ 尺度库都放在一个叫std (standard) 的定名空间中 。
  

7.3 定名空间的利用

   编译查找一个变量的声明/界说时 ， 默认只会在局部大概全局查找 ， 不会到定名空间内里去查找 ， 以是下面步伐会编译报错 。 以是我们要利用定名空间中界说的变量/函数，有三种方式 ： 
  1 . 指定定名空间访问 ， 在项目中保举这种方式。
  2 . using 将定名空间某个成员睁开 ， 项目中常常访问的不存在辩说的成员保举这种方式。
  3 . 睁开定名空间中全部成员 ， 项目不保举 ， 辩说风险很大 ， 一样平常小训练步伐为了方便保举利用 。  
  
  总之就是 ， 想利用定名空间的成员就必要告诉编译器，这个变量要到定名空间里找
  -----> 1 . 可以用 :: （定名空间限定符)
  -----> 2.  using 睁开必要利用的定名空间

1. #include <stdio.h>
2. namespace bit
3. {
4.         int a = 10;
5.         int b = 20;
6. }
8. //编译报错："a"未声明标识符
9. int main()
10. {
11.         printf("%d\n", a);
12.         return 0;
13. }
15. //指定命名空间访问
16. int main()
17. {
18.         printf("%d\n", bit::a);
19.         return 0;
20. }
22. //using将命名空间中某个成员展开
23. using bit::a;
24. int main()
25. {
26.         printf("%d\n", a);
27.         printf("%d\n", bit::b);
28.         return 0;
29. }
31. //展开命名空间中全部成员
32. using namespace bit;
33. int main()
34. {
35.         printf("%d\n", a);
36.         printf("%d\n", b);
37.         return 0;
38. }

复制代码

三 . C++输入&输出

   

• <iostream> 是 Input Output Stream 的缩写 ， 是尺度的输入，输出流库 ， 界说了尺度的输入，输出对象。
  
• std::cin 是istream 类的对象 ， 它告急面向窄字符 ( narrow characters (of type char)) 的尺度输入流 。
  
• std:ut 是 ostream 类的对象 ， 它告急面向窄字符的尺度输出流。
  
• std::endl 是一个函数 ， 流插入输出时 ， 相称于插入一个换行字符 + 革新缓冲区。
  
• << 是流插入运算符 ， >> 是流提取运算符 。（c语言还用这两个运算符做位运算左移/右移）
  
• 利用c++ 输入输出更方便 ， 不必要像print / scanf 输入输出时那样 ， 必要手动指定格式 ， c++ 的输入输出可以主动辨认变量范例 ( 本质是通过函数重载实现) , 告急的是 ， c++流能更好的支持自界说范例对象的输入输出。
  
• IO流涉及类和对象 ， 运算符重载 ， 继承等许多面向对对象的知识
  
• cout / cin / endl 等都属于c++ 尺度库 ， c++ 尺度库都放在一个叫 std （ standard ) 定名空间中 ， 以是必要通过定名空间的利用去利用他们                                                        --------------->        using namespace std;
  

一样平常训练中 ， 我们可以利用 using namespace std , 但是在现实项目开辟中 ， 不发起利用。 

1. #define _CRT_SECURE_NO_WARNINGS 1
2. #include<iostream>
3. using namespace std;
5. int main()
6. {
7.         int a = 0;
8.         double b = 0.1;
9.         char c = 'a';
11.         cout << a << " " << b << " " << c << endl;
12.         std::cout << a << " " << b << " " << c <<std:: endl;
14.         //没有包含<stdio.h>，也可以使用print和scanf,在包含<iostream>间接包含了
15.         //vs编译器是这样的，其他编译器可能会报错
16.         scanf("%d%lf", &a, &b);
17.         printf("%d %lf\n", a, b);
19.         //可以自动识别类型
20.         cin >> a;
21.         cin >> b >> c;
23.         cout << a << endl;
24.         cout << b << " " << c << endl;
26.         return 0;
27. }

复制代码

  在io需求比力高的地方，如部门⼤大量输入的比赛题中，加上以下3行代码，可以进步C++IO服从

1. #include<iostream>
2. using namespace std;
3. int main()
4. {
5. // 在io需求⽐较⾼的地⽅，如部分⼤量输⼊的竞赛题中，加上以下3⾏代码
6. // 可以提⾼C++IO效率
7. ios_base::sync_with_stdio(false);
8. cin.tie(nullptr);
9. cout.tie(nullptr);
10. return 0;
11. }

复制代码

四 . 缺省参数

   1 . 缺省参数是声明或界说函数时为函数的参数指定一个缺省值。在调用该函数时，假如没有指定实参则接纳该形参的缺省值，否则利用指定的实参，缺省参数分为全缺省和半缺省参数。（有些地方把缺省参数也叫默认参数）
  2 . 全缺省就是全部形参给缺省值 ， 半缺省就是部门形参给缺省值 。 C++ 规定半缺省参数必须从右往左依次连续缺省 ， 不能隔断跳跃给缺省值 。 
  3 . 带缺省参数的函数调用 ， C++规定必须从左到右依次给实参 ， 不能跳跃给实参 。
  4 . 函数声明和界说分离时 ， 缺省参数不能在函数声明和界说中同时出现 ， 规定必须函数声明给缺省值 。 
  

1. #include<iostream>
2. using namespace std;
4. //全缺省
5. void Func1(int a = 10,int b = 20,int c=30)
6. {
7.         cout << "a = " << a << endl;
8.         cout << "b = " << b << endl;
9.         cout << "c = " << c << endl << endl;
10. }
12. //半缺省
13. void Func2(int a, int b = 10, int c = 20)
14. {
15.         cout << "a = " << a << endl;
16.         cout << "b = " << b << endl;
17.         cout << "c = " << c << endl << endl;
18. }
20. int main()
21. {
22.         Func1();
23.         Func1(1);
24.         Func1(1,2);
25.         Func1(1,2,3);
27.         Func2(100);
28.         Func2(100,200);
29.         Func2(100,200,300);
30.         return 0;
31. }

复制代码

五 . 函数重载

   C++支持在同一作用域出现同名函数 ， 但是要求这些同名函数的形参差别 ， 可以是参数个数差别大概范例差别 。 如许C++函数调用就表现出了多态活动，利用更机动 。 C语言是不支持同一作用域中出现同名函数的 。 
  ----> 同名函数，要求形参差别  (参数差别  大概  范例差别 )

1. #include<iostream>
2. using namespace std;
4. // 1、参数类型不同
5. int Add(int left, int right)
6. {
7.      cout << "int Add(int left, int right)" << endl;
9.      return left + right;
10. }
12. double Add(double left, double right)
13. {
14.     cout << "double Add(double left, double right)" << endl;
16.     return left + right;
17. }
19. // 2、参数个数不同
20.   void f()
21. {
22.      cout << "f()" << endl;
23. }
25. void f(int a)
26. {
27.     cout << "f(int a)" << endl;
28. }
30. // 3、参数类型顺序不同
31.   void f(int a, char b)
32. {
33.      cout << "f(int a,char b)" << endl;
34. }
36.   void f(char b, int a)
37. {
38.     cout << "f(char b, int a)" << endl;
39. }
41. void f1()
42. {
43. cout << "f()" << endl;
44. }
46. void f1(int a = 10)
47. {
48. cout << "f(int a)" << endl;
49. }
51. int main()
52. {
53. Add(10, 20);
54. Add(10.1, 20.2);
56. f();
57. f(10);
59. f(10, 'a');
60. f('a', 10);
62. return 0;
63. }

复制代码

   返回值差别不能作为重载条件 ， 由于调用时也无法区分 ， 会报错 ， 存在歧义 ， 编译不知道调用谁 ！

1. void fxx()
2. {
3. }
4. int fxx()
5. {
6.         return 0;
7. }

复制代码

六 . 引用

6.1 引用的概念和界说

    引用不是新界说一个变量 ， 而是给已存在变量取了一个别名 ， 编译器不会为引用变量开辟内存空间 ， 它和它引用的变量共用同一块内存空间 。 
    格式 :
  范例& 引用别名 = 引用对象 ；
  

1. #define _CRT_SECURE_NO_WARNINGS 1
2. #include<iostream>
3. using namespace std;
5. int main()
6. {
7.         int a = 0;
8.        
9.         //引用 : b 和 c 是 a 的别名
10.         int& b = a;
11.         int& c = a;
13.         //也可以给别名取别名
14.         int& d = b;
16.         ++d;
18.         //指向同一块的空间
19.         cout << &a << endl;
20.         cout << &b << endl;
21.         cout << &c << endl;
22.         cout << &d << endl;
23.         return 0;
24. }

复制代码

   这里引用可以拿水浒传中的李逵作比 ， 宋江叫他“铁牛” ， 江湖人称 " 黑旋风“ ；铁牛，李逵，黑旋风都是同一个人 ；
  C++ 中为了克制引入太多的运算符 ， 会复用C 的一些符号 ，比如前面的 << 和 >> , 这里引用  也和  取所在  利用了同一个符号 & , 各人留意区分
  

 6.2 引用的特性

   

• 引用在界说时 ， 必须初始化
  
• 一个变量可以有多个引用
  
• 引用一旦引用一个实体 ， 就不能再引用其他实体
  

1. #define _CRT_SECURE_NO_WARNINGS 1
2. #include<iostream>
3. using namespace std;
5. int main()
6. {
7.         int a = 0;
8.        
9.         int& b = a;
10.         int& c = a;
11.         int& d = b;
13.         int e = 10;
14.         b = e;
16.         cout << a << endl;
17.         cout << b << endl;
18.         cout << c << endl;
19.         cout << d << endl;
20.         cout << e << endl;
22.         cout << &a << endl;
23.         cout << &b << endl;
24.         cout << &c << endl;
25.         cout << &d << endl;
26.         cout << &e << endl << endl;
27.         return 0;
28. }

复制代码

 6.3 引用的利用

   1 . 引用在实践中告急是用于引用传参 和 引用返回值中淘汰拷贝进步服从 和 改变引用对象时同时改变被引用对象 。
  
  2 . 引用传参跟指针传参功能是类似的，引用传参相对更方便一些。
  
  3 . 引用返回值的场景相对比力复杂 ， 这里简单先容以了局景 ， 在后续的类和对象的博客中，还会继承深入先容 。
  
  4 . 引用 和  指针 在实践中相辅相成，功能有重叠性 ， 但是各有特点 ， 相互不可更换 。 C++的引用跟其他语言的引用 ( 如Java ） 是有很大的区别的 ， 除了用法 ， 最大的点 ， C++引用界说后不能改变指向 ， Java 引用可以改变指向 。 
  1 . 下面举一个我们熟悉的交换函数Swap , 来领会以下 引用  的 ”巧“ :
指针传参版本 :

2. #include<iostream>
3. using namespace std;
5. void Swap(int* x, int* y)
6. {
7.         int tmp = *x;
8.         *x = *y;
9.         *y = tmp;
10. }
11. int main()
12. {
13.         int x = 1;
14.         int y = 2;
15.         cout << "交换之前:x = " << x << " y = " << y << endl;
16.         Swap(&x, &y);
17.         cout << "交换之后:x = " << x << " y = " << y << endl;
18.         return 0;
19. }

复制代码

引用传参版本：

1. void Swap(int& x, int& y)
2. {
3.         int  tmp = x;
4.         x = y;
5.         y = tmp;
6. }
7. int main()
8. {
9.         int x = 1;
10.         int y = 2;
11.         cout << "交换之前:x = " << x << " y = " << y << endl;
12.         Swap(x, y);
13.         cout << "交换之后:x = " << x << " y = " << y << endl;
14.         return 0;
15. }

复制代码

    2 . 紧接着再来看看之前实现过的数据结构 -- 栈 ， 利用引用传参 ：
1 ) 引用后 ， 形到场实参指向的空间是同一个 ， 传参的时间不必要转达所在
  2 ) 访问结构体的时间 不利用 -> 操纵符 ， 而利用 . 操纵符
  
  假如想利用引用传参来实现数据结构栈 ， 可以看之前博客 : 栈与队列的常见接口的实现-CSDN博客 , 试着把指针传参改为引用传参
  

1. #include <assert.h>
2. #include<iostream>
3. using namespace std;
5. typedef int STDataType;
6. typedef struct Stack
7. {
8.         STDataType* a;
9.         int top;
10.         int capacity;
11. }ST;
12. void STInit(ST& rs, int n = 4)
13. {
14.         rs.a = (STDataType*)malloc(n * sizeof(STDataType));
15.         rs.top = 0;
16.         rs.capacity = n;
17. }
18. // 栈顶
19. void STPush(ST & rs, STDataType x)
20. {
21.          // 满了， 扩容
22.         if (rs.top == rs.capacity)
23.                  {
24.                         printf("扩容\n");
25.                         int newcapacity = rs.capacity == 0 ? 4 : rs.capacity * 2;
26.                         STDataType * tmp = (STDataType*)realloc(rs.a, newcapacity *sizeof(STDataType));
27.                 if (tmp == NULL)
28.                 {
29.                         perror("realloc fail");
30.                         return;
31.                 }
32.                         rs.a = tmp;
33.                         rs.capacity = newcapacity;
34.                 }
35.                         rs.a[rs.top] = x;
36.                         rs.top++;
37. }
39. // int STTop(ST& rs)
40. int& STTop(ST & rs)
41. {
42.         assert(rs.top > 0);
43.         return rs.a[rs.top];
44. }
46. int main()
47. {
48. // 调⽤全局的
49.         ST st1;
50.         STInit(st1);
51.         STPush(st1, 1);
52.         STPush(st1, 2);
54.         cout << STTop(st1) << endl;
55.        
56.         STTop(st1) += 10;
57.         cout << STTop(st1) << endl;
58.         return 0;
59. }

复制代码

  3 . 一些告急用C代码实现版本数据结构的课本中 ， 会利用C++引用传参 ， 来代替指针传参 ， 目的是简化步伐 ， 避开复杂指针 ---> 一级指针 ， 二级指针 ...；

1. //使用引用来代替一级指针
2. typedef struct SeqList
3. {
4. int a[10];
5. int size;
6. }SLT;
8. // ⼀些主要⽤C代码实现版本数据结构教材中，使⽤C++引⽤替代指针传参，⽬的是简化程序，避开复杂的指针
9. void SeqPushBack(SLT& sl, int x)
10. {
12. }
14. //void SeqPushBack(SLT* sl, int x)；
15. //void SeqPushBack(SLT& sl, int x)

复制代码

1. //使用引用来替代二级指针
2. //void ListPushBack(LTNode** phead, int x)
3. //void ListPushBack(LTNode*& phead, int x)
5. #include<iostream>
6. using namespace std;
8. typedef struct ListNode
9. {
10. int val;
11. struct ListNode* next;
12. }LTNode, *PNode;
14. // 指针变量也可以取别名，这⾥LTNode*& phead就是给指针变量取别名
15. // 这样就不需要⽤⼆级指针了，相对⽽⾔简化了程序
17. void ListPushBack(PNode& phead, int x)
18. {
19. PNode newnode = (PNode)malloc(sizeof(LTNode));
20. newnode->val = x;
21. newnode->next = NULL;
22.     if (phead == NULL)
23.     {
24.         phead = newnode;
25.     }
26.        else
27.    {
28. //...
29.    }
30. }
32. int main()
33. {
34.     PNode plist = NULL;
35.     ListPushBack(plist, 1);
36.     return 0;
37. }

复制代码

  留意 : 这里的Pnode 是结构体指针变量 。对于二级指针引用 ,拿 int 型做比， 只能是 
  ---->  int* & 引用名 = 引用对象 ；( 为整型指针变量给别名)
  不会有 int & *  引用名 = 引用对象 ，如许的界说,不符合引用的格式
  4 .  引用返回值
   下面的STTop(S) += 10 , 会报错 ，由于函数返回的时间 ， 返回的是临时对象 ， 具有常性 ， 不可以更改 ！
  

   假如想要实现 STTop(S) += 10 , 利用引用 ， 返回对象的别名
  

   为什么必要有临时对象的概念？直接返回不可吗？ 
  ----> 下面的代码 ， top 假如出了作用域 ， 生命周期竣事了，不利用 临时对象/寄存器存储 ， top 就找不到了
  

6.4 const 引用

   1 . 可以引用一个const 对象 ， 但是必须用 const 引用 。 const 引用也可以引用平凡对象，由于对象的访问权限在引用过程中可以缩小 ， 但是不能放大 。
  
  2 . 必要留意的是  类似 :
 int & rb = a*3 ;          double d = 12.34 ;      int& rd = d ;
  如许一些场景下 a* 3的结果生存在一个临时对象中 ， int& rd = d 也是类似 ， 在范例转换中会产生临时对象存储中心值 ， 也就是 ， rb 和 rd 引用的都是临时对象 ， 而 C++ 规定临时对象具有常性 ， 以是这里就触发了权限放大 ， 必须要用常引用才可以 。
  
  3 . 所谓临时对象就是编译器必要一个空间暂存表达式的求值结果时 -----> 临时创建的一个未定名的对象 ， C++中把这个未定名的对象叫做临时对象 。
  

1. #define _CRT_SECURE_NO_WARNINGS 1
2. #include<iostream>
3. using namespace std;
5. int main()
6. {
7.         const int a = 10;
9.         //权限不可以放大
10.         //int& ra = a;
12.         //权限可以平移
13.         const int& ra = a;
15.         //权限可以缩小
16.         int b = 20;
17.         const int& rb = b;
18.         return 0;
19. }

复制代码

2. //引用传参，减少拷贝，建议用引用传参，好处是实参可以是常量/运算表达式等
3. void Func(const int& r)
4. {
6. }
7. int main()
8. {
9.         int a = 10;
10.         const int& ra = a;
11.         const int& rra = 30;
13.         const int& rb = a * 3;
15.         double d = 13.14;
16.         const int& rd = d;
17.         Func(a);
18.         Func(10);
19.         Func(a * 3);
20.         Func(d);
22.         return 0;
23. }

复制代码

6.5 指针和引用的关系（笔试常考)

C++中指针和引用就像两个性格迥异的亲兄弟 , 指针是哥哥 ， 引用是弟弟 ， 在实践中 ， 他们相辅相成 ， 功能具有重叠性 ， 但是各有自己的特点 ，相互不可以更换 。
   

• 语法概念上 : 引用是一个变量的取别名 ---> 不开空间 ， 指针是存储一个变量的所在 ， 必要开辟空间 。
  
• 引用在界说时必须初始化，指针发起初始化，但是在语法上不是必须的。
  
• 引用初始化时引用一个对象  ， 就不能再引用其他对象 ； 而指针可以在不绝地改变指向对象 。
  
• 引用可以直接访问指向对象 ， 指针必要解引用才气访问指向对象。 
  
• sizeof 中寄义差别 ，  引用结果为引用范例的巨细 ， 但指针始终是所在空间所占字节个数(32位平台下 --> 4个字节 ， 64 位平台下 8 字节)
  
• 指针很轻易出现空指针和野指针的题目 ， 引用很少出现 ， 引用利用起来相对更安全一些 。