C语言的内存管理交予用户。所以现在C语言的内存管理要靠用户的良好编码习惯。当然现在一般成熟的语言都有GC机制,即为垃圾回收机制。共同基类管理,内部加引用计数都可以实现GC机制。
但是C++没有GC机制,最主要是没有共同基类,其次是垃圾回收机制占用系统开销降低性能,并且需要占用更多的内存。C++使用析构函数或者智能指针引用计数去管理内存资源的释放。
智能指针
**作用:**帮助开发者对动态分配对象(new)的生命周期进行管理。能够有效防止内存泄漏。
**头文件:**memory
分类:
- auto_ptr(C++98):被C++11智能指针替代,不再使用
- unique_ptr(C++11): 独占指针
- shared_ptr(C++11):共享指针
- weak_ptr(C++11):弱指针
shared_ptr
#include <iostream>
#include <memory>
using namespace std;
class Test{
public:
Test(){
cout << "Test()" << endl;
}
~Test(){
cout << "~Test()" << endl;
}
friend ostream &operator<<(ostream &out , const Test &t){
out << "Test";
return out;
}
};
using namespace std;
int main(){
//shared_ptr
int num = 5;
//C++11
shared_ptr<int> pi(new int (5));
int *p = new int(4);
shared_ptr<int> pi2(p); //共享指针包裹
shared_ptr<Test> pt(new Test());
cout << *pi << endl;
cout << *pi2 << endl;
cout << *pt << endl;
//C++14 推荐该方法,效率更高
shared_ptr<string> ps = std::make_shared<string>("hello world");
shared_ptr<int> pi3 = std::make_shared<int>(1);
return 0;
}
方法:
//use_count() :返回有多少个shared_ptr智能指针指向某对象;(引用计数的个数)
//unique():是否该智能指针独占某个对象,独占返回true,否则返回false;
//reset():
shared_ptr<int> pi(new int (5));
shared_ptr<int> pi1 = pi; //裸指针int *
shared_ptr<int> pi2 = pi1;
cout << pi.use_count() << endl; //输出3
pi.reset();
if(pi == nullptr){
cout << "pui is null" << endl; //会执行
}
pi.reset(new int(6)); //重新指向新地址
//get():考虑到有些函数参数是裸指针并不是智能指针,所以需要将智能指针转化为裸指针;
int *p = pi.get(); //因为现在pi中存的是int。
//对于裸指针有时候要注意,例如下句会执行报错,程序默认裸指针为Test*而只调用一次析构函数。
shared_ptr<Test> pt(new Test[3]);
//修改:
shared_ptr<Test []> pt(new Test[3]);
//指定删除器
void mydelete(Test *pa){
cout << "my delete" << endl;
delete [] pa;
}
shared_ptr<Test> ps(new Test [3] , mydelete);
weak_ptr
一般用来辅助shared_ptr的使用,shared_ptr可以复制给weak_ptr,反过来不行,需要lock()
与shared_ptr的强引用不同的是,它是弱引用。
两者大小都是16,因为本质是两个指针,一个指向对象,一个是指向控制块。
shared_ptr<int> pi(new int (5));
weak_ptr<int> pw = pi;
//lock函数获得shared_ptr(若对象已经被释放,则返回空)
pi = pw.lock();
//use_count():返回有多少个shared_ptr指向某对象
//expired():判断弱指针是否过期(所检测的对象是否被释放 true/false)
//reset():将该弱指针设置为空,弱引用计数减1,强引用计数不变
unique_ptr
独占式指针(专属所有权),同一时刻,只能有一个unique_ptr指向这个对象;当指针销毁,指向的对象也销毁;大小等于裸指针的大小。
初始化
手动初始化:unique_ptr p;
或unique p(new int(5));
std::make_unique函数(C++14) 注:生成的指针不支持指定删除器语法
unique_ptr常规操作
不支持操作:该指针不支持拷贝和赋值操作;所以函数传参必须传引用。
移动语义std::move();
release():放弃对指针的控制权,将该指针置nullptr,返回裸指针。
reset();
解引用:get():返回裸指针。
指定删除器
语法:unique_ptr<指向对象类型,删除器的类型> 智能指针变量名
自定义删除函数
lambda函数
decltype()
指定不同的删除器会导致不同的unique_ptr;
shared_ptr指定不同的删除器不会影响其类型;而unique_ptr 会。
比如定义一个vector存放,会发现不同删除器的指针不同都push_back()。
unique_ptr尺寸:和裸指针一样大,但是指定自定义删除函数会影响尺寸大小;
作业:实现shared_ptr
//my_shared_ptr.h
#pragma once
#include <iostream>
using namespace std;
template <typename T>
class My_shared_ptr
{
private:
T *ptr;
int *count_ptr;
using Del_ptr = void (*)(T*);
Del_ptr del = nullptr;
public:
My_shared_ptr() : ptr((T *) 0) , count_ptr(0) {}
My_shared_ptr(T *data) : ptr(data) , count_ptr(new int(1)) {
cout << "My_shared_ptr" << endl;
}
My_shared_ptr(T *data , Del_ptr func) : ptr(data) , count_ptr(new int(1)) , del(func) {
cout << "My_shared_ptr with my_del" << endl;
}
My_shared_ptr(const My_shared_ptr<T> &other_ptr){
cout << "copy My_shared_ptr" << endl;
if(this != &other_ptr){
this->ptr = other_ptr.ptr;
this->count_ptr = &(++ *other_ptr.count_ptr);
this->del = other_ptr.del;
}
}
My_shared_ptr &operator=(const My_shared_ptr<T> &other_ptr){
cout << "operator =" << endl;
if(this == &other_ptr)
return *this;
++ *other_ptr.count_ptr;
if(-- *this->count_ptr == 0){
delete ptr;
delete count_ptr;
}
this->ptr = other_ptr.ptr;
this->count_ptr = other_ptr.count_ptr;
this->del = other_ptr.del;
return *this;
}
~My_shared_ptr(){
cout << "~My_shared_ptr()" << endl;
if(-- *this->count_ptr == 0){
if(this->del){
this->del(this->ptr);
}
else{
delete ptr;
delete count_ptr;
}
}
this->ptr = nullptr;
this->count_ptr = nullptr;
}
int get_count(){
return *this->count_ptr;
}
bool unique(){
if(*this->count_ptr == 1)
return true;
else
return false;
}
T &operator*(){
return *this->ptr;
}
T *get(){
return this->ptr;
}
void reset(){
if(-- *this->count_ptr == 0){
delete ptr;
delete count_ptr;
}
}
void reset(T *data){
if(-- *this->count_ptr == 0){
delete ptr;
delete count_ptr;
}
this->ptr = data;
this->count_ptr = new int(1);
}
void reset(T *data , Del_ptr func){
if(-- *this->count_ptr == 0){
delete ptr;
delete count_ptr;
}
this->ptr = data;
this->count_ptr = new int(1);
this->del = func;
}
};
//test.cpp
#include <iostream>
#include "my_shared_ptr.h"
using namespace std;
class Test{
public:
Test(){
cout << "Test()" << endl;
}
~Test(){
cout << "~Test()" << endl;
}
};
void mydelete(Test *pa){
cout << "my delete" << endl;
delete [] pa;
}
int main(){
My_shared_ptr<string> pstr(new string("hello world"));
My_shared_ptr<string> pstr1 = pstr;
cout << "值:" << endl;
cout << *pstr << endl;
cout << *pstr1 << endl;
cout << "引用数量:" << endl;
cout << pstr.get_count() << endl;
cout << pstr1.get_count() << endl;
cout << "转化为普通指针输出:" << endl;
string *s = pstr.get();
cout << *s << endl;
cout << "第二个智能指针重新赋地址:" << endl;
pstr1.reset(new string("a new string"));
cout << *pstr1 << endl;
cout << "更改后的引用数量:" << endl;
cout << pstr.get_count() << endl;
My_shared_ptr<Test> pi(new Test[3] , mydelete);
return 0;
}