C++——指针，堆栈，引用，函数

C++——指针，堆栈，引用，函数

一. 指针

    声明： int *a = 3;   声明了一个int类型的指针变量a，初始值为3。

    赋值： int b = 3; a = &b; 将变量a的值(即地址)指向b，得到 *a == 3。

指针的好处：

    1. 处理堆中存放的大量数据;

    2. 快速访问类的成员数据和函数;

    3. 以别名方式向函数传递参数。

const与指针：

    指向常量的指针 是指针的值(地址)可以修改，可以指向其它const对象，但指针所指向的对象不能修改。

如：

     const double *a;

     const double b = 5.0;

     a = &b;        //right

     *a = 3.14     //error,不能通过指针来修改所指对象。

 

    常指针 是指针的值不能修改，但指针所指向的对象却可以修改。

如：

      double* const a;

      a = &b;       //error,指针a是一个常指针

      *a = 3;       //right

 

二. 堆和栈

程序在内存中的存放形式有：

1. 栈区。由编译器自动分配并释放，一般存放函数参数，局部变量等。

2. 堆区。由程序员分配并释放，若程序员不释放，程序结束后由操作系统回收。

3. 静态区(全局区)。全局变量和静态变量，程序结束后由系统释放。

4. 文字常量区。常量字符串，程序结束后由系统释放。

5. 程序代码区。函数体的二进制代码。

6. 寄存器区。用来保存栈顶指针和指令指针。

    栈中存放的数据时临时的，全局变量可以解决这个问题，但它永远不会被释放，除非程序结束，并且它的值很容易被修改，使用堆就可以解决这两个问题。

堆与栈的区别

1. 内存申请方式不同

    栈：自动，如int a; 就在内存中开辟了8个字节的空间。

    堆：需要程序员自己申请，因此也需指明变量的大小。

2. 系统响应不同

    栈：只要栈的剩余空间大于申请空间，就提供内存，否则提示overflow，也就是栈溢出。

    堆：系统首先遍历空闲地址链表，找到符合要求的就删除该空闲地址链表，然后在这块区域的首地址处记录大小(效率低，容易产生碎片)。

3. 空间大小不同

    栈：连续内存区域，2M，小量数据。

    堆：不连续，通过链表串联，大量数据。

总结

    栈与堆结合，在存储大型数据，将数据放在堆中，将指向该数据的指针放到栈中。

 

三. 用指针创建堆中的对象

    堆中的每个内存单元都是匿名的，因此必须先在堆中申请一个内存单元地址，然后把它保存到一个指针中，这样只有使用指针才能访问该内存单元的数据 。

    用new创建一个对象并分配内存

                                  int *p = new int;

                                  delete p;             //释放p所指向的内存空间

                                  p = 0;                  //使用delete后最好将指针清零

    用malloc

                                  int *p = (int *)malloc(sizeof(int));

                                  free(p);

 

关于new/delete与malloc/free

    1. new/delete是运算符，malloc/free是函数。

    2. new除了分配内存，还调用了构造函数，同理delete也会调用析构函数；而malloc/free只会分配内存，不会执行构造函数和析构函数。

    3. 内存泄露对于malloc和new都可以检查出来，区别是new可以指明是哪个文件的哪一行，malloc没有这些信息。

 

内存泄露

   指针消失，计算机再也找不到该内存区域，好像丢失了这块内存一样。

    例：

                                int *p= new int;

                                p = new int;

    先前申请的8个字节空间就丢失，再也找不到了。

 

四. 引用

   引用就是别名常量，它只能被初始化(不能赋值)，跟古代的女人一样，一旦嫁给某人就永远属于他。

                                int a = 3;

                                int &ra = a;  //&在这里是引用运算符，ra是a的引用，也就是a的别名，地址与a相同。

   引用在函数传参上很方便有效。

 

五. 函数传参

    一般分为值传递和地址传递(或者别名)两种：

 

Cpp代码  

1. #include <iostream>   
2. #include <stdio.h>   
3. using   namespace  std;  
4.   
5. /*  
6. 按值传递需要建立参数的副本，当传递较大的对象时，需要用引用或者指针。  
7. 在按值传递的过程中，不仅需要复制对象，还要调用默认复制构造函数，该函数的作用就是创建某个对象的临时副本；  
8. 返回时，副本会被删除，因此也会调用析构函数。  
9. 参数传递中：int* const a(指针的值不能边，指针所指向的对象的值可以变) 等同于 int& a(别名常量,a不能指向其他对象，但值可以改变)  
10. const int* const a 等同于 const int& a  
11. */   
12. class  A  
13. {  
14.     public :  
15.     A(){printf("构造函数执行\n" );}  
16.     A(A&) {printf("复制构造函数执行\n" );}  
17.     ~A() {printf("析构函数执行\n" );}  
18. };  
19.   
20. A fuc(A one)  
21. {  
22.     return  one;  
23. }  
24.   
25. void  SwapByValue( int  a,  int  b)  
26. {  
27.     int  t;  
28.     t = a;  
29.     a = b;  
30.     b = t;  
31. }  
32.   
33. void  SwapByPoint( int * a,  int * b)  
34. {  
35.     int  t;  
36.     t = *a;  
37.     *a = *b;  
38.     *b = t;  
39. }  
40.   
41. void  SwapByRef( int  &a,  int  &b)  
42. {  
43.     int  t;  
44.     t = a;  
45.     a = b;  
46.     b = t;  
47. }  
48.   
49. int  main()  
50. {  
51.     int  a=3,b=4;  
52.     SwapByValue(a,b);  
53.     printf("%d %d\n" ,a,b);  
54.     SwapByPoint(&a,&b);  
55.     printf("%d %d\n" ,a,b);  
56.     SwapByRef(a,b);  
57.     printf("%d %d\n" ,a,b);  
58.     A a1;  
59.     A b1;  
60.     b1 = fuc(a1);  
61.     return  0;  
62. }