C++学习笔记之指针引用
指针
指针定义
指针定义的基本形式：指针本身就是一个变量，其符合变量定义的基本形式，它存储的是值的地址。对类型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更高效；
