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相同。

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

 

五. 函数传参

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

 

#include <iostream>
#include <stdio.h>
using
 
namespace
 std;

/*
按值传递需要建立参数的副本，当传递较大的对象时，需要用引用或者指针。
在按值传递的过程中，不仅需要复制对象，还要调用默认复制构造函数，该函数的作用就是创建某个对象的临时副本；
返回时，副本会被删除，因此也会调用析构函数。
参数传递中：int* const a(指针的值不能边，指针所指向的对象的值可以变) 等同于 int& a(别名常量,a不能指向其他对象，但值可以改变)
const int* const a 等同于 const int& a
*/
class
 A
{
    public
:
    A(){printf("构造函数执行\n"
);}
    A(A&) {printf("复制构造函数执行\n"
);}
    ~A() {printf("析构函数执行\n"
);}
};

A fuc(A one)
{
    return
 one;
}

void
 SwapByValue(
int
 a, 
int
 b)
{
    int
 t;
    t = a;
    a = b;
    b = t;
}

void
 SwapByPoint(
int
* a, 
int
* b)
{
    int
 t;
    t = *a;
    *a = *b;
    *b = t;
}

void
 SwapByRef(
int
 &a, 
int
 &b)
{
    int
 t;
    t = a;
    a = b;
    b = t;
}

int
 main()
{
    int
 a=3,b=4;
    SwapByValue(a,b);
    printf("%d %d\n"
,a,b);
    SwapByPoint(&a,&b);
    printf("%d %d\n"
,a,b);
    SwapByRef(a,b);
    printf("%d %d\n"
,a,b);
    A a1;
    A b1;
    b1 = fuc(a1);
    return
 0;
}