C++之智能指针20170920

/******************************************************************************************************************/

一、C++智能指针_自己实现智能指针

1.使用局部变量结合new的方式，防止new导致的内存泄漏

class sp

{

private:

Person *p;

public:

sp() : p(0) {}//表明sp的构造函数 继承person的无参构造函数

sp(Person *other)

　　 {

cout<<"sp(const Person *other)"<<endl;

p = other;

}

~sp()

{

cout<<"~sp()"<<endl;

if (p)

delete p;

}

　　Person *operator->()//重载->

　　{

return p;

}

};

void test_func(void)

{

sp s = new Person();//分配的堆空间只是当作参数传递进去(传递给构造函数)了

　　  s->printInfo();

}

分配的堆空间只是当作参数传递进去(传递给构造函数)了，s执行完后调用s的析构函数(局部变量,栈里)，析构函数中又释放了内存就没有泄漏了

以后代码中需要person指针就可以使用sp代替，不用担心内存泄漏

/* 相当于:

* 1. Person *p = new Person();

* 2. sp tmp(p);  ==> sp(Person *other)

* 3.

* 3.1 sp other(tmp);  ==> sp(sp &other2)

问题在于: sp &other2 = tmp; // 错误语法，因为引用无法等于临时变量

const sp& other2 = tmp; //ok

* 或

* 3.2 sp other(tmp ==> Person*);  ==>sp(Person *other)

*/

sp other = new Person();//编译器优化，直接把2，3部合并为一步

for (i = 0; i < 2; i++)

test_func(other);//这里执行两次会崩溃，原因在于第一次执行完后，把p指向的对象释放了，第二次再使用该指针自然会奔溃。

2.解决办法，引入引用计数，也就是再增加一个整数成员，当发现有人引用对象时 该值加1，如果使用完 减一，如果等于0再释放(解决过早释放问题)

class Person {

private:

int count;

public:

void incStrong(){ count++; }

void decStrong(){ count--; }

int getStrongCount(){ return count;}

　　Person() : count(0)//表示构造时count值默认值是0

　　{

cout <<"Pserson()"<<endl;

}

~Person()

{

cout << "~Person()"<<endl;

}

void printInfo(void)

{

cout<<"just a test function"<<endl;

}

};

class sp

{

private:

Person *p;

public:

sp() : p(0) {}

sp(Person *other)

{

cout<<"sp(Person *other)"<<endl;

p = other;

p->incStrong();

}

sp(const sp &other)

{

cout<<"sp(const sp &other)"<<endl;

p = other.p;

p->incStrong();

}

~sp()

{

cout<<"~sp()"<<endl;

if (p)

{

p->decStrong();

if (p->getStrongCount() == 0)

{

delete p;

p = NULL;

}

}

}

Person *operator->()

{

return p;

}

};

void test_func(sp &other)

{

sp s = other;

cout<<"In test_func: "<<s->getStrongCount()<<endl;

s->printInfo();

//Person *p = new Person();

//p->printInfo();

//delete p;

}

int main(int argc, char **argv)

{

int i;

sp other = new Person();

cout<<"Before call test_func: "<<other->getStrongCount()<<endl;

for (i = 0; i < 2; i++)

{

test_func(other);

cout<<"After call test_func: "<<other->getStrongCount()<<endl;

}

return 0;//main函数执行完后，再次减一，这时就把person对象销毁了

}

3. 重载*，供下面使用

Person& operator*()//重载*，供下面使用

{//不使用引用，返回的是值，就又会去构造对象(临时对象,见上述引用章节)

return *p;

}

/* 少用"Person *"; 用"sp"来代替"Person *"

* Person *per;

* 有2种操作: per->XXXx, (*per).XXX

* sp也应该有这2中操作:

* sp->XXX, (*sp).XXX*

*/

sp other = new Person();

(*other).printInfo();

4.优化：将count的操作独立出去，单独为一个类，其他类如person直接继承，就可以操作count的类。

5.优化：为了让智能指针类更通用，应当把类修改为类模版，这样就不局限于内部的指针仅指向person。

template<typename T>

class sp

{

private:

T *p;

}

最终就可以实现， 用"sp<Person>"来代替"Person *

而且不需要delete，由系统释放

/******************************************************************************************************************/

二、C++智能指针_轻量级指针

count++不是原子操作，所以在多线程的情况下是不安全的

所以引入轻量级指针(保证原子操作,保证操作count值线程安全)：

1.使用安卓提供的轻量级智能指针的代码：

using namespace android::RSC;//使用安卓命名空间下的RSC命名空间

class Person : public LightRefBase<Person>

{//指定模版参数为person

public:

Person() {

cout <<"Pserson()"<<endl;

}

~Person()

{

cout << "~Person()"<<endl;

}

void printInfo(void)

{

cout<<"just a test function"<<endl;

}

};

2.被调用的安卓RefBase.h中的部分代码：

template <class T>

class LightRefBase

{

public:

inline LightRefBase() : mCount(0) { }

inline void incStrong(__attribute__((unused)) const void* id) const {

__sync_fetch_and_add(&mCount, 1);//__sync_fetch_and_add是原子操作

}

inline void decStrong(__attribute__((unused)) const void* id) const {

if (__sync_fetch_and_sub(&mCount, 1) == 1)

　　{//__sync_fetch_and_sub是原子操作

delete static_cast<const T*>(this);

}

}

3.注意轻量级指针只是对count的操作是线程安全的，但是对于操作的对象即智能指针还是不安全的，多线程情况下只能自己来保证智能指针的使用是线程安全的，即智能指针指向的对象的操作是线程安全的。

为啥叫轻量指针，是因为代码简单，使用方便。

/******************************************************************************************************************/

三、C++智能指针_弱指针的引入

轻量指针，代码简单，使用方便，但是

当有两个智能指针互相引用的时候，由于执行完引用计数不为零，就没办法释放，会造成内存泄漏：

/* 如果对象里含有其他对象成员:

* 构造时: 先构造其他对象成员, 再构造对象本身

* 析构时: 顺序刚好相反

*/

void test_func()

{

/* 1. 对于 new Person()

* 1.1 Person对象里的father先被构造

* 1.2 Person对象里的son被构造

* 1.3 Person对象本身

* 2. Person对象的指针传给"sp<Person> father"

*    导致: sp(T* other) 被调用

*    它增加了这个Person对象的引用计数(现在此值等于1)

*/

sp<Person> father = new Person();

/* 1. 对于 new Person()

* 1.1 Person对象里的father先被构造

* 1.2 Person对象里的son被构造

* 1.3 Person对象本身

* 2. Person对象的指针传给"sp<Person> son"

*    导致: sp(T* other) 被调用

*    它增加了这个Person对象的引用计数(现在此值等于1)

*/

sp<Person> son = new Person();

/* 它是一个"=" : this->son = son

* "="被重载, 它会再次增加该Person对象的引用计数

* 所以son对应的Person对象的引用计数增加为2

*/

father->setSon(son);

/* 它是一个"=" : this->father = father

* "="被重载, 它会再次增加该Person对象的引用计数

* 所以father对应的Person对象的引用计数增加为2

*/

son->setFather(father);

/* 当test_func执行完时, father和son被析构

* 1. 先看father:

*    ~sp(): decStrong, 里面会将计数值减1 , father对应的Person的计数值等于1, 还没等于0, 所以没有delete

* 2. 对于son:

*    ~sp(): decStrong, 里面会将计数值减1 , son对应的Person的计数值等于1, 还没等于0, 所以没有delete

*/

}

对于交叉引用导致内存泄漏的问题，如果两个指针是弱引用，也就是不增加对方的引用计数值，那么就不会造成内存泄漏，因此只能引用弱指针(弱引用)才能解决这个问题，

强指针(强引用):A指向B,A决定B的生死

弱指针(弱引用):A指向B，A不能决定B的生死

/******************************************************************************************************************/

四、C++智能指针_强弱指针的实现与使用

强弱指针的实现：

加入引用计数mWeak成员并提供加减操作，同时加入flag成员表示当前是强还是弱，具体实现见安卓源码.

1.源码说明：

I、在RefBase.h中的class RefBase中成员指针指向weakref_impl，也就是强弱指针的实现，weakref_impl继承于weakref_type（操作成员的抽象类），也就是说weakref_impl就是具体的实现类。

具体也可以说，

强弱指针的实现主要是加入引用计数mWeak成员并提供加减操作，同时加入flag成员表示当前是强还是弱

再将强弱指针的实现抽象出抽象类，具体实现类weakref_impl继承weakref_type抽象类，并在RefBase.h中的class RefBase中定义指向weakref_impl的指针。

II、这样实现的原因：

a.头文件中不想看到私有成员，只想看到接口，则把接口抽象出来为抽象类(放在头文件中)，然后剩下的独立为实现类(放在cpp文件中)，实现类继承抽象类，抽象类对外。

b.依赖对象的时候，最好依赖指针，因为直接依赖对象，当对象发生变化就会跟着发生变化，指针只占四个字节就不会跟着变化，对空间布局没有影响

2.强弱指针的使用:

I、使用安卓里现成的，

头文件:

system/core/include/utils

system/core/include/cutils

cpp:

system/core/libutils/RefBase.cpp

makefile:

%.o : %.cpp

g++ -c -o $@ $< -I include //-I include表示包含当前目录下的include目录

//查找头文件不会递归的往子目录查找，所以要么这里加要么代码中加上 目录名/XXX.h

例：

int main(int argc, char **argv)

{

wp<Person> s = new Person();//弱指针

//s->printInfo(); /* 出错, wp没有重载"->", "*" */

//(*s).printInfo(); /* 出错, wp没有重载"->", "*" */

sp<Person> s2 = s.promote();//提升为强指针，这样就可以调用了

　　  if (s2 != 0) {

s2->printInfo();

}

return 0;

}

II、使用弱指针可以解决交叉引用导致内存泄漏的问题，但是想使用引用的对象里的函数，就必须先升级为强指针才可以调用

#include <iostream>

#include <string.h>

#include <unistd.h>

#include <utils/RefBase.h>

using namespace std;

using namespace android;

class Person : public RefBase

{//继承RefBase

private:

char *name;

wp<Person> father;

wp<Person> son;

public:

Person() {

cout <<"Pserson()"<<endl;

}

Person(char *name) {

cout <<"Pserson(char *name)"<<endl;

this->name = name;

}

~Person()

{

cout << "~Person()"<<endl;

}

void setFather(sp<Person> &father)

{

this->father = father;

}

void setSon(sp<Person> &son)

{

this->son = son;

}

char *getName(void)

{

return name;

}

void printInfo(void)

{

sp<Person> f = father.promote();

sp<Person> s = son.promote();

//cout<<"just a test function"<<endl;

cout<<"I am "<<name<<endl;

if (f != 0)

cout<<"My Father is "<<f->getName()<<endl;

if (s != 0)

cout<<"My Son is "<<s->getName()<<endl;

}

};

/* 如果对象里含有其他对象成员:

* 构造时: 先构造其他对象成员, 再构造对象本身

* 析构时: 顺序刚好相反

*/

void test_func()

{

/* 1. 对于 new Person()

* 1.1 Person对象里的father先被构造

* 1.2 Person对象里的son被构造

* 1.3 Person对象本身

* 2. Person对象的指针传给"sp<Person> father"

*    导致: sp(T* other) 被调用

*    它增加了这个Person对象的引用计数(现在此值等于1)

*/

sp<Person> father = new Person("LiYiShi");

/* 1. 对于 new Person()

* 1.1 Person对象里的father先被构造

* 1.2 Person对象里的son被构造

* 1.3 Person对象本身

* 2. Person对象的指针传给"sp<Person> son"

*    导致: sp(T* other) 被调用

*    它增加了这个Person对象的引用计数(现在此值等于1)

*/

sp<Person> son = new Person("LiErShi");

father->setSon(son);

son->setFather(father);

father->printInfo();

son->printInfo();

}

int main(int argc, char **argv)

{

test_func();

return 0;

}