C++： 智能指针满足的需求，从需求谈指针

股民的并发症，需求为先。所以今天，从需求来谈谈指针，包括智能指针。

我们为什么需要指针？

标记一个地址。我们能够借由它对地址存储内容进行利用、改变。

特别是函数参数的传值引用（前面说了，传地址也是传值，只是这个值特殊）。

比如：

void changIt(int *p)
{
(*p)++;//存储内容改变
}

在指针的使用过程中，我们会学习到，什么表示为指针。

1、对变量取地址。

int a;
int *pa=&a;

2、数组名是一个地址。

int a[]{1,2,3,4,5};
int *p=a; //*p=&a[0]结果相同

3、函数名是一个地址。

void changeIt(){}
void (*p)() = changeIt;
p();//函数调用
(*p)();//函数调用

函数指针定义时，返回值（*指针变量名）(形参列表);妥妥的。

你就想着，没有括号的时候，是函数声明，前面表示的是返回值类型，没有定义出指针。

在变量定义过程中，*表示指针，&表示引用，你必须用一个来定义变量呀。于是不复杂了。

4、分配一个地址。

int *p= new int;
int *q= new int(10);//初始化了。
int *k = new int[10];//分配了一个数组

常见的表现形式齐了。

对地址使用的需求呢？

1、指向的地址不变。也就是指针变量 是个常量。

int a=10;
int * const p =&a;
*p +=10;//存储内容可变。
p++; //错误

2、指向的内容不能变。

int a=10;
const int *p =&a;  // p是一个指针，指向const int.
*p +=10;//存储内容不可变。
p++; //

3、常量指针同时指向内容不可变

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

有某意义？就是我把这个东西给你，你必须原封不动地执行它的意义。

函数是一系列动作，一系列命令，在这个命令执行过程中，你必须对我交给你的东西，不改变，坚决执行，不要玩花样。

以上是对单个指针进行的约束。

一个地址，可以用多个指针，那么就产生了新的需求。

1、我用的时候，别人都不能用。独占。

这个大家实际上见识得多了。在许多地方都必须有这个功能。在语言层面进行表示。

std::unique_ptr<int> foo;//(new int (101));
std::unique_ptr<int> bar;
foo = std::unique_ptr<int>(new int (101));  // rvalue
//bar =foo; //错误，独占式，不能复制
bar = std::move(foo);//移交，可行，foo被解除       

2、大家都用，计数，没有人用的时候，释放，解除。

std::shared_ptr<int> p(new int(10));

有个互相引用的例子，造成了互锁。如下：

#include <iostream> 
#include <memory>
using namespace std;


class B;
class A
{
public:
    shared_ptr<B> pb_;
    //weak_ptr<B> pb_;
    ~A()
    {
        cout<<"A delete\n";
    }
};
class B
{
public:
    shared_ptr<A> pa_;
    ~B()
    {
        cout<<"B delete\n";
    }
};
 
void fun()
{
    shared_ptr<B> pb(new B());
    shared_ptr<A> pa(new A());
    pb->pa_ = pa;
    pa->pb_ = pb;
    cout<<pb.use_count()<<endl;
    cout<<pa.use_count()<<endl;
}
 
int main()
{
    fun();
    return 0;
}

运行这个程序，会看不到析构函数的正常运行。产生了一个问题。

3、可以共用，但一个控制它的存亡，一个在存在的使用可以使用。

这个思想就解决了上面程序的问题。std::weak_ptr<> ;

#include <iostream> 
#include <memory>
using namespace std;


class B;
class A
{
public:
    //shared_ptr<B> pb_;
    weak_ptr<B> pb_;
    ~A()
    {
        cout<<"A delete\n";
    }
};
class B
{
public:
    shared_ptr<A> pa_;
    ~B()
    {
        cout<<"B delete\n";
    }
};
 
void fun()
{
    shared_ptr<B> pb(new B());
    shared_ptr<A> pa(new A());
    pb->pa_ = pa;
    pa->pb_ = pb;
    cout<<pb.use_count()<<endl;
    cout<<pa.use_count()<<endl;
}
 
int main()
{
    fun();
    return 0;
}

在使用的过程中，weak_ptr 必须进行检测，它还在吗，它还在吗，在，再使用。

指针真是一个很有趣味的东西。很底层，但理念很高层。在上帝的视角下，进行细节的规划使用。

C++真是最令人喜欢的强大语言。