嵌入式C++总结

1、new delete与malloc free区别

new delete是运算符，malloc free是函数。

前者不需要传入大小，后者需要。

前者会调用构造、析构函数，后者不会。

前者不需要强制转换，后者需要。

2、智能指针

智能指针是避免忘记释放动态申请对象容易内存泄漏而设计的。主要特点是会在离开作用域会使用delete进行内存释放。实现原理也就是在构造函数中new对象，析构函数中delete对象。智能指针有share_ptr、auto_ptr、unique_ptr、weak_ptr。

auto_ptr，当使用拷贝或赋值构造函数时会将右值赋值给左值后将右值指针置零，局限性就在复制后不能使用。

unique_ptr，在auto_ptr的基础上直接禁用赋值和拷贝构造函数，这样从根本上解决了问题，但是赋值时会比较麻烦。

其中shared_ptr中有一个引用计数，用于记录多少个对象指向申请内存，析构这些对象时计数值减1，为0时候再释放动态内存。避免了重复释放的问题。但是会引出循环引用的问题：创建出来的两个对象通过shared_ptr相互指的时候析构时由于被别的对象指向所以计数值不为0，导致无法调用析构函数释放内存。解决办法是创建时使用shared_ptr，引用时使用weak_ptr。

shared_ptr实现原理（理解基本原理，细节没有处理）：

cpp 复制代码

#include <iostream>
#include <memory>

using namespace std;

class boy;
class girl;

template<typename T>

class my_shared_ptr
{
    public:
    my_shared_ptr(T *a)
    {
        ref_cnt = 1;
        Type_Ptr = a;
    }

    my_shared_ptr(T &a)
    {
        ref_cnt = 1;
        Type_Ptr = &a;
    }

    my_shared_ptr()
    {
        ref_cnt = 1;
        Type_Ptr = NULL;
    }
    void Release()
    {
        if(Type_Ptr&&((--ref_cnt) == 0))
        {
            delete Type_Ptr;
            Type_Ptr = NULL;
        }
    }
    ~my_shared_ptr()
    {
        Release();
    }

    T* operator->()
    {
        return Type_Ptr;
    }

    T& operator*()
    {
        return *Type_Ptr;
    }

    my_shared_ptr& operator=(my_shared_ptr &target)
    {
        if(this != &target)
        {
            Release();
            Type_Ptr = target.Type_Ptr;
            ref_cnt = target.ref_cnt;
            target.Ref_Add();
        }
        return *this;
    }

    void Ref_Add()
    {
        ref_cnt++;
    }

    private:

    T *Type_Ptr;
    int ref_cnt;
};

// 男孩类
class boy {
public:

	boy() { cout << "boy structure" << endl; }
	~boy() { cout << "~boy destruct"  << endl; }

	void set_girl_friend(my_shared_ptr<girl>& g) {
		girl_friend = g;
	}


private:
	my_shared_ptr<girl> girl_friend; 
};


// 女孩类
class girl {
public:

	girl() { cout << "girl structure" << endl; }
	~girl() { cout << "~girl destruct" << endl; }

	void set_boy_friend(my_shared_ptr<boy>& b) {
		boy_friend = b;
	}

private:
	my_shared_ptr<boy> boy_friend;
};

// 测试函数
void test() {

	// 定义共享指针，初始化指向新建的girl女孩类
	my_shared_ptr<girl> sp_girl(new girl());	
		
	// 定义共享指针，初始化指向新建的boy男孩类
	my_shared_ptr<boy> sp_boy (new boy());

	// 调用 sp_girl 指向 girl 的成员函数 set_boy_friend 
	// 将 sp_boy 共享指针作为参数传递进成员函数
	sp_girl->set_boy_friend(sp_boy);

	// 调用 sp_boy 指向 boy 的成员函数 set_girl_friend
	// 将 sp_girl共享指针作为参数传递进成员函数
	sp_boy->set_girl_friend(sp_girl);
}


int main(void) {

	// 调用测试函数
	test();

	return 0;
}

weak_ptr，不能改变引用计数，只能观察对象，不能直接使用*和->访问对象，需要通过lock()获得一个指向共享对象的shared_ptr，然后操作该共享指针。