• 指针
  • 指针定义
  • 左值与右值
  • 指针数组与数组指针
  • const与指针
  • 指针的指针
  • NULL指针
  • 内存泄漏（Memory Leak）问题
  • 智能指针
  • 引用

指针

指针定义

指针定义的基本形式：指针本身就是一个变量，其符合变量定义的基本形式，它存储的是值的地址。对类型T，T是“到T的指针”类型，一个类型为T的变量能保存一个类型T的对象的地址。
如：

int a=112;
float c=3.14;
int* d=&a;
float* e=&c;

cout << d << endl;    cout << e << endl;
cout << (*d) << endl;    cout << (*e) << endl;

通过一个指针访问它所指向地址的过程称为间接访问（indirection）或者引用指针（dereferencing the point）；这个用于执行间接访问的操作符是单目操作符*：

cout<<(*d)<<endl;
cout<<(*e)<< endl;

左值与右值

概念：

• 编译器为其单独分配了一块存储空间，可以取其地址的，左值可以放在赋值运算符左边；
• 右值指的是数据本身，不能取到其自身地址，右值只能赋值运算右边；

具体分析：

• 左值最常见的情况如函数和数据成员的名字；
• 右值是没有标识符、不可以取地址的表达式，一般也称之为“临时对象"。

比如：a=b+c; &a是允许的操作，而&（b+c）不能通过编译，因此a是一个左值，而（b+c）是一个右值；

指针数组与数组指针

指针的数组（array of pointers）与数组的指针（a pointer to an array）：

• 指针的数组 T t []*：运算符和T结合，定义数组的元素为T指针类型。
• 数组的指针 T (*t) []：*运算符和t结合，定义变量t为指针变量。

int*  a[4];                          // array of pointers        指针的数组
int (*b) [4];                       // a pointer to an array  数组的指针

// 输出
cout << *(a[0]) << endl; 
cout << (*b)[0] << endl; 

const与指针

const pointer与pointer to const例子：

char strHelloworld[]={"helloworld"};
char const * pStr1="helloworld";  //和const char* pStr1等效
char * const pStr2="helloworld";
char const * const pStr3="helloworld";
pStr1=strHelloworld;
//pStr2=strHelloworld; //pStr2不可改
//pStr3=strHelloworld; //pStr3不可改

关于const修饰的部分：

• 看左侧最近的部分；
• 如果左侧没有，则看右侧；

指针的指针

指向指针的指针例子：

int a=123;
int* b=&a;
int** c=&b;

*操作符具有从右向左的结合性，上面取值规则如下：

• **这个表达式相当于*(*c)，必须从里向外逐层求值；
• *c得到的是c指向的位置，即b；
• **c相当于*b，得到变量a的值；

NULL指针

NULL指针：一个特殊的指针变量，表示不指同任何东西。

int* a=NULL;

NULL指针给了一种方法，来表示特定的指钍目前未指向任何东西，使用的注意事项：

• 对于一个指针，如果已经知道将被初始化为什么地址，那么请赋给它这个地址值，否则适把它设置为NULL。
• 在对一个指针进行间接引用前，请先判断这个指针的值为否为NULL。
• 没有初始化的，不用的或者超出范围的指针请把值置为NULL。

内存泄漏（Memory Leak）问题

内存泄漏问题：指程序中己动态分配的维内存由于某种原因程序未释放或无法释，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。

内存泄漏发生原因和排查方式：

• 内存泄漏主要发生在堆内存分配方式中，即“配置了内存后，所有指向该内存的指针都遗失了”。
• 因为内存泄漏属于程序运行中的问题，无法通过编译识别，所以只能在程序运行过程中来判别和诊断。

while (true) 
{
      int* wp1 = new int(10); //内存泄漏
}

智能指针

C++中推出了四种常用的智能指针：

• unique ptr：专属所有权，管理的内存只能被一个对象持有，不支持复制和赋值，可以使用std:move()进行控制所有权的转移。

auto w = std::make_unique<int>(10);
cout << *(w.get()) << endl;    // 10
//auto w2 = w;                        // 编译错误如果想要把 w 复制给 w2, 是不可以的。	
auto w2 = std::move(w);         // w2 获得内存所有权，w 此时等于 nullptr
cout << ((w.get() != nullptr) ? (*w.get()) : -1) << endl;     // -1
cout << ((w2.get() != nullptr) ? (*w2.get()) : -1) << endl;   // 10

• shared ptre：通过一个引用计数共享一个对象，当引用计数为0时，该对象没有被使用，可以进行析构。

auto wA = shared_ptr<int>(new int(20));
{
    auto wA2 = wA;
    cout << ((wA2.get() != nullptr) ? (*wA2.get()) : -1) << endl;       // 20
    cout << ((wA.get() != nullptr) ? (*wA.get()) : -1) << endl;         // 20
    cout << wA2.use_count() << endl;                                    // 2
    cout << wA.use_count() << endl;                                     // 2
}
//cout << wA2.use_count() << endl;                                               
cout << wA.use_count() << endl;                                         // 1
cout << ((wA.get() != nullptr) ? (*wA.get()) : -1) << endl;             // 20

// move 语法，意味着放弃了对内存的所有权和管理
auto wAA = std::make_shared<int>(30);
auto wAA2 = std::move(wAA);            // 此时 wAA 等于 nullptr，wAA2.use_count() 等于 1
cout << ((wAA.get() != nullptr) ? (*wAA.get()) : -1) << endl;          // -1
ccout << wAA.use_count() << endl;                                      // 0
cout << wAA2.use_count() << endl;                                      // 1

• weak ptr：被设计为与shared_ptr共同工作（避免循环引用shared_ptr导致的内存泄露），用一种观察者模式工作，只对shared ptr进行引用而不改变其引用计数，当被观察的 shared ptr失效后相应的weak ptr也相应失效。

struct AW
{
    shared_ptr<BW> pb;
    ~AW()	{ cout << "~AW()" << endl; }
};
struct BW
{
    weak_ptr<AW> pa;          //此处改为shared_ptr则会发生内存泄漏（循环引用）
    ~BW()	{ cout << "~BW()" << endl; }
};
void Test()
{
    cout << "Test shared_ptr and shared_ptr:  " << endl;
    shared_ptr<A> tA(new A());                                               
    shared_ptr<B> tB(new B());                                                
    cout << tA.use_count() << endl;          // 1
    cout << tB.use_count() << endl;          // 1
    tA->pb = tB;
    tB->pa = tA;
    cout << tA.use_count() << endl;          // 2
    cout << tB.use_count() << endl;          // 2
}
void Test()
{
    cout << "Test weak_ptr and shared_ptr:  " << endl;
    shared_ptr<AW> tA(new AW());
    shared_ptr<BW> tB(new BW());
    cout << tA.use_count() << endl;              // 1
    cout << tB.use_count() << endl;              // 1
    tA->pb = tB;
    tB->pa = tA;
    cout << tA.use_count() << endl;              // 1
    cout << tB.use_count() << endl;              // 2
}

int main()
{
    Test();
    return 0;
}

• auto_ptr：在拷贝/赋值过程中，会直接剥夺指针对原对象对内存的控制权（C++11中已经废弃的，在C++17中被正式删除）。

引用

C++的引用是一种特殊的指针，不允许修改的指针，参考 C++：引用的简单理解 。

注：C++中类的引用也需要显式定义，C#中除了值类型则全是引用类型，注意区别。

使用指针有空指针、野指针、不知不觉改变了指针的值却继续使用的问题，使用引用则：

• 不存在空引用；
• 必须初始化；
• 一个引用永远指向它初始化的那个对象；

int x = 1, x2 = 3;
int& rx = x;
rx = 2;
cout << x << endl;    //2
cout << rx << endl;   //2
rx = x2;
cout << x << endl;    //3
cout << rx << endl;   //3

有了指针为什么还需要引用？
Bjarne Stroustrup的解释：为了支持函数运算符重载；

有了引用为什么还需要指针？
Bjarne Stroustrup的解释：为了兼容C语言；

关于函数传递参数类型的说明：

• 对内置基础类型（如int，double等）而言，在函数中传递时pass by value更高效；
• 对OO面向对象中自定义类型而言，在函数中传递时pass by reference to const更高效；