花式使用C/C++的指针

指针无疑是C/C++语言的精髓所在，用好了是把利剑，用不好就是一颗炸弹。指针出BUG了，分分钟会让你写程序崩溃

今天被C++的指针搞混了，翻阅了很多资料，有点懂了。赶快来做一下笔记。
先来使用一个最简单的指针

    int a = 10;
    int *p=&a;

这个没啥难度不会出错，接下来来个难点的

    int a = 10;
    int *p = &a;
    int **p1 = &p;

这个指针的指针是不是已经头皮发麻了，别急，还有更变态的——指针数组，数组指针，函数指针，指针函数。这回是不是彻底懵了。
现在就开始一个个使用这些指针
首先要明确一点，指针数组和数组指针不是一个概念

int *p3[10];
这就定义了一个指针数组，
[]优先级高，先与p结合成为一个数组，再由int*说明这是一个整型指针数组，它有10个指针类型的数组元素

---

int (*p4)[10];
这是一个数组指针，因为()优先级高，首先说明p是一个指针，指向一个整型的一维数组，这个一维数组的长度是10

---

int* fun(int a);
这样就声明了一 个指针函数，就是返回指针的函数，函数可以不返回任何值，也可以返回整型值，实型值，字符型值，当然也可以返回指针值。函数fun需要在函数体中返回一个int型的指针。

---

int (*fun)(int a);
这样就定义了一个指向函数的指针，可以通过这个指针来调用函数，注意，这个指针不能指向任意的函数，只能指向返回值是int，并且只有一个形参的函数。
这些都是C中指针的使用，到了C++中，指针遇到类和对象，遇到new和delete这两个运算符，稍有不慎就会内存泄漏。
说了这么多，现在开始研究C++中指针的使用问题
先来新建一个Test类
Test.h

#pragma once
class Test
{
public:
    Test();
    Test(int _a);
    ~Test();
    int a;
};

Test.cpp

#include "stdafx.h"
#include "Test.h"
#include <iostream>
using std::cout;
using std::endl;


Test::Test():Test(0)//委托构造函数
{
    cout << "调用委托构造函数给a赋值 0"<<endl;
}

Test::Test(int _a=10):a(_a)//构造初始化,形参默认值=10
{
    cout << "call function Test(int _a) "<<endl;
}


Test::~Test()
{
    cout << "delete Test  " << a << endl;
}

main.cpp

// main.cpp: 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "Test.h"
#include <stdlib.h>

int main()
{
    /*1
    创建Test的实例，指针t1指向实例*/
    Test *t1 = new Test(6);

    delete t1;
    t1 = nullptr;


    /*2
    创建3个test实例数组  指针t2指向数组的第一个元素,
    此时只能调用Test类的无参构造函数*/
    Test *t2 = new Test[3];

    delete[] t2;//释放 test的三个实例
    t2 = nullptr;

    /*3 
    在堆中创建3个（Test）类型的指针数组，t3指向这个数组；*/
    Test* *t3 = new Test*[3];
    for (int i = 0; i < 3; i++)
    {
        /*创建3个Test的实例，让t3数组中的元素（指针）指向创建的对象*/
        t3[i] = new Test(i + 10);
    }

    for (int i = 0; i < 3; i++)
    {
        /*释放 在堆中创建的三个Test的实例*/
        delete t3[i];
    }

    delete[] t3;//释放动态创建的指向Test实例的指针数组


    system("pause");
    return 0;
}

先来开一下最简单的一种对象指针Test *t1 = new Test(6); 这时定义了一个Test类型的指针t1，并让这个指针指向从堆中申请的内存（Test的实例）运行以下看看

没意外，Test的实例正常创建，正常释放了。
再来看一下第二种情况

Test *t2 = new Test[3];

delete[] t2;

现在定义了一个Test的指针t2，并且在堆中创建了3个Test的实例，放在一个数组中，指针t2指向了这个数组。运行看一下

这时有一点要注意一下，这样new创建对象时只能调用Test类的默认无参构造函数，其他的函数不能调用。我们为了给a赋值，使用了委托构造函数（不太熟悉的同学可以忽略），从打印的结果来看，程序正常创建了Test的实例，也正常释放内存。
现在来看一下最复杂的一种情况

/*3 
在堆中创建3个（Test）类型的指针数组，t3指向这个数组；*/
Test* *t3 = new Test*[3];
    for (int i = 0; i < 3; i++)
    {
        /*创建3个Test的实例，让t3数组中的元素（指针）指向创建的对象*/
        t3[i] = new Test(i + 10);
    }

    for (int i = 0; i < 3; i++)
    {
        /*释放 在堆中创建的三个Test的实例*/
        delete t3[i];
    }

    delete[] t3;

是不是已经晕倒在电脑前了0.0     莫慌,先看一下运行结果

一步步来分析以下代码，首先看一下 Test* *t3 = new Test*[3];t3是一个指针，它指向了堆中的一个数组，这个数组的类型是 Test*的。 new Test*[3]在堆内存中创建了一个长度为3的 Test*的数组。重点 t3指向的是堆中的一个数组
第一个for循环中的 t3[i] = new Test(i + 10);是给 t3所指向的数组中的元素赋值，因为数组是 Test*类型的，所以可以指向Test类的实例。
第二个for循环中 delete t3[i];是把在堆内存中创建的Test 类的实例释放。因为 t3[i]是一个指针，而且是指针数组，也就是说 t3[i]，是 t3指针指向的数组（在堆内存中）的一个元素，所以要把 t3指向的数组释放 delete[] t3;

好了先总结到这吧。项目我已经上传到码云，需要的可以下载。