首页 / C++ / C++---智能指针上

C++---智能指针上

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了C++---智能指针上，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含7105字，纯文字阅读大概需要11分钟。

内容图文

首先要知道智能指针是用来解决什么问题的，首先我们先看下面这段代码

void Func(int *p)
{
	int *sp = new int;
	if (p == NULL)
	{
		throw std::exception("p is NULL");
	}
	delete sp;
}

这个函数有一个很大的问题，如果传入的参数p为空，遇到 if 语句就命中之后就会抛出异常，程序中断。那么指针sp指向开辟的内存没有释放，导致内存泄漏。有什么方法可以来解决这个问题？

栈：系统开辟内存，系统释放；堆：手动开辟内存，手动释放。那么如果能对堆上空间实现用户分配、系统自行回收的机制，就不用担心内存泄露的问题了。

智能指针的思想：定义一个类来封装资源的分配和释放，在构造函数完成资源的分配和初始化，在析构函数中完成资源的清理和释放，可以保证资源的正确使用和释放。(资源指的是堆上资源)

看下面这段代码：

#include<iostream>
template <typename T>
class Smart_ptr
{
public:
	Smart_ptr(T *ptr) :mptr(ptr)//构造函数
	{}
	~Smart_ptr()//析构函数
	{
		delete mptr;
		mptr = NULL;
	}
	
	T& operator*()//*运算符重载
	{
		return *mptr;
	}
	T* operator->()//->运算符重载
	{
		return mptr;
	}
private:
	
	T *mptr;
};

int main()
{
	Smart_ptr<int>sp1(new int);
	*sp1 = 20;
	Smart_ptr<int>sp2 = sp1;
}

Smart_ptr<int>sp2 = sp1;这句代码会释放同一块内存两次，导致程序出错。

这里介绍四个智能指针auto_ptr

1、auto_ptr（已经被摒弃）

实现一：不带标记的auto_ptr（所有权唯一）

C++---智能指针上 - 文章图片

#include<iostream>
template <typename T>
class Smart_ptr
{
public:
	Smart_ptr(T *ptr) :mptr(ptr)
	{}
	~Smart_ptr()
	{
		delete mptr;
		mptr = NULL;
	}
	Smart_ptr(const Smart_ptr<T>& rhs)//拷贝构造函数
	{
		mptr = rhs.mptr;
		rhs.Release();//将旧的指针置为NULL
	}
	Smart_Ptr<T>& operator=(const Smart_Ptr<T>& rhs)//赋值运算符重载
	{
		if (this != &rhs)
		{
			delete mptr;
			mptr = rhs.mptr;
			rhs.Release();//将旧的指针置为NULL
		}
		return *this;
	}
	T& operator*()
	{
		return *mptr;
	}
	T* operator->()
	{
		return mptr;
	}
private:
	void Release()const
	{
		(T*)mptr = NULL;
	}
	T *mptr;
};

int main()
{
	Smart_ptr<int>sp1(new int);
	Smart_ptr<int>sp2 = sp1;
	*sp1 = 20;
}

问题：*sp1 = 20; sp1指针指向已经为NULL，对其解引用访问了保留区的数据，程序出错。

实现二：带有标记的auto_ptr（释放权唯一，管理权不唯一)，即可以多个auto_ptr管理同一片内存，但是只能有一个指针释放该片内存。怎么确定是哪个指针能释放呢？在成员变量中加入一个标志变量flag，flag为true则有释放权，flag为false则没有释放权。那么就牵扯释放权限转移的问题，概括来说就是旧智能指针拥有的权限，那么新智能指针也拥有。旧智能指针没有的权限，那么新智能指针也没有。

C++---智能指针上 - 文章图片

这个功能的实现：new flag = old flag; old flag = false;

#include<iostream>
template<typename T>
class SmartPtr
{
public:
	SmartPtr(T* ptr) :mptr(ptr), flag(true)
	{}
	SmartPtr(const SmartPtr<T>& rhs) :mptr(rhs.mptr)
	{
		flag = rhs.flag;
		rhs.flag = false;
	}
	SmartPtr<T>& operator = (const SmartPtr<T>& rhs)
	{
		if (this != &rhs)
		{
			this->~SmartPtr();
			mptr = rhs.mptr;
			flag = rhs.flag;
			rhs.flag = false;
		}
		return *this;
	}
	~SmartPtr()
	{
		if (flag)
		{
			delete mptr;
		}
		mptr = NULL;
	}
	T& operator*()
	{
		return *mptr;
	}
	T* operator->()
	{
		return mptr;
	}
private:
	T* mptr;
	mutable bool flag;//是否拥有释放权
};
void func(SmartPtr<int> sp)//true
{}
int main()
{
	SmartPtr<int> sp1(new int);//false
	SmartPtr<int> sp2 = sp1;//false
	func(sp2);
	*sp1 = 20;
	return 0;
}

问题：根据管理权原则一，若旧智能指针有释放权，则新智能指针将释放权拿走，旧释放权false。那么如果这个新智能指针只是一个临时量，随着生存周期的到来也随之消失，那块被管理的内存岂不是莫名其妙就被释放了

void func(SmartPtr<int> sp)//true
{}
void test(SmartPtr<int> rhs)
{
	std:: cout << *rhs << std::endl;
}
int main()
{
	SmartPtr<int> p(new int(10));
	SmartPtr<int> q(new int(20));
	*p = 11;
	*q = 22;
	p = q;
	SmartPtr<int> w = p;
	test(w);//在传参的过程中，w的释放权发生转移

	std::cout << "w" << *w << std::endl;//打印一个随机值
	return 0;
}

C++---智能指针上 - 文章图片

2、Scope_ptr(管理权唯一，释放权唯一）

在auto_ptr中，因为设计的问题，导致在使用拷贝构造函数和赋值运算符的可重载函数时，发生了访问空指针、野指针的情况。为了规避这些情况，scoped_str在设计的时候就直接屏蔽了拷贝构造函数和赋值运算符重载函数。

#include<iostream>
template<typename T>
class Scope_Ptr
{
public:
	Scope_Ptr(T* ptr) :mptr(ptr){}
	~Scope_Ptr()
	{
		delete mptr;
		mptr = NULL;
	}
	T& operator*()
	{
		return *mptr;
	}
	T* operator->()
	{
		return mptr;
	}
private:
	Scope_Ptr(const Scope_Ptr<T>&);
	Scope_Ptr<T>& operator=(const Scope_Ptr<T>&);
	T* mptr;
};

int main()
{
	int* p = new int;
	Scope_Ptr<int> sp1(p);
	Scope_Ptr<int> sp2(p);
	return 0;
}

问题： scoped_ptr的原则也是“管理权唯一，释放权唯一”，因为屏蔽了拷贝构造函数和赋值运算符重载函数，所以不可能通过这两种方式去使得两个及以上的指针指向同一片内存，但是仍然避免不了人为的操作，如sp1和sp2；即初始化两个scope_ptr指向同一片内存，当其中一个指针释放了该内存，另一个再想去修改内存的内容的话程序就会崩溃
3、shared_ptr（管理权不唯一，释放权不唯一）

shared_ptr是基于“引用计数”实现的，多个shared_ptr可指向同一片内存，并且它们维护着共享的引用计数器——记录着指向同一片内存的shared_ptr对象的个数。当最后一个指向某一片内存的shared_ptr对象也销毁之后，会自动销毁掉该片内存。shared_ptr很好地解决了多个智能指针指向一块内存块时, 析构时程序崩溃的情况。

引用计数器：我们只需要一个引用计数器对象，这个对象中就存储了所有关于内存引用的信息。

C++---智能指针上 - 文章图片

class Ref_Management
{
public:
	void AddRef(void* mptr)//增加
	{
		std::vector<Node>::iterator it = find(mptr);//查找是否存在这个地址
		if (it == vec.end())//引用计数表中不存在这个地址那么就增加一个
		{
			Node tmp(mptr, 1);
			vec.push_back(tmp);
		}
		else
		{
			(*it).ref++;//存在，那么就加引用计数
		}
	}
	void DelRef(void* mptr)//删除
	{
		std::vector<Node>::iterator fit = find(mptr);//查找是否存在这个地址
		if (fit == vec.end())//如果找到最后都没有，那么就不存在抛出异常
		{
			throw std::exception("mptr is not exisit!");
		}
		else
		{
			if (GetRef(mptr) != 0)//判断该地址的引用计数
			{
				(*fit).ref--;//计数不为0就--
			}
		}
	}
	int GetRef(void* mptr)//获取
	{
		std::vector<Node>::iterator it = find(mptr);//查找是否存在这个地址
		if (it == vec.end())//如果找到最后都没有，那么就不存在抛出异常
		{
			throw std::exception("ptr is not exsit!");
		}
		else
		{
			return (*it).ref;//找到返回引用计数
		}
	}
private:
	class Node;
	std::vector<Node>::iterator find(void* mptr)//使用迭代器查找
	{
		std::vector<Node>::iterator it = vec.begin();
		for (it; it != vec.end(); it++)
		{
			if ((*it).addr == mptr)
			{
				break;
			}
		}
		return it;
	}

	class Node//结点类型
	{
	public:
		Node(void* pa = NULL, int r = 0) :addr(pa), ref(r){}//构造函数
	public:
		void* addr;//存放的地址
		int ref;//引用计数
	};
	std::vector<Node> vec;
};


template<typename T>
class Shared_Ptr
{
public:
	Shared_Ptr(T* ptr) :mptr(ptr)//构造函数
	{
		addref();
	}
	Shared_Ptr(const Shared_Ptr<T>& rhs) :mptr(rhs.mptr)//拷贝构造函数
	{
		addref();//增加引用计数
	}
	Shared_Ptr<T>& operator = (const Shared_Ptr<T>& rhs)//赋值运算符重载
	{
		if (this != &rhs)//防止自赋值
		{
			delref();//减引用计数
			if (getref() == 0)//若引用计数为0，删除该指针
			{
				delete mptr;
			}
			mptr = rhs.mptr;
			addref();
		}
		return *this;
	}
	~Shared_Ptr()
	{
		delref();//减引用计数
		if (getref() == 0)//若引用计数为0，删除该指针
		{
			delete mptr;
		}
		mptr = NULL;
	}
	T& operator*()
	{
		return *mptr;
	}
	T* operator->()
	{
		return mptr;
	}
private:
	void addref()
	{
		rm.AddRef(mptr);
	}
	void delref()
	{
		rm.DelRef(mptr);
	}
	int getref()
	{
		return rm.GetRef(mptr);
	}
	T* mptr;
	static Ref_Management rm;//引用计数器成员变量象
};
//静态成员变量类外初始化
template<typename T>
Ref_Management Shared_Ptr<T>::rm;

int main()
{
	int* p = new int;
	Shared_Ptr<int> sp1(p);
	Shared_Ptr<int> sp2(p);
	Shared_Ptr<int> sp3(p);
	Shared_Ptr<int> sp4(new int);
	return 0;
}

问题：虽然shared_ptr很好地解决了 “多个智能指针指向同一块内存时，析构时出错”的问题，可是同时也带来了新的问题。shared_ptr之间不能相互引用，否则管理的堆上内存块无法释放。

内容总结

以上是互联网集市为您收集整理的C++---智能指针上全部内容，希望文章能够帮你解决C++---智能指针上所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/754738.html

来源：【匿名】

【上一篇】C++返回引用【下一篇】c++有个库什么的吗?

更多 ►

【C++---智能指针上】教程文章相关的互联网学习教程文章

C++智能指针【代码】

C++智能指针智能指针与异常如果使用智能指针, 如果程序块过早的结束, 智能指针能保证在内存不再需要时进行释放. (特别是在有多个出口的函数中 -- 虽然应尽量避免设计这样的函数, 但凡事总有例外 -- 此时使用智能指针来自动释放内存是非常方便的) 对于异常处理来说, 考虑下面两个函数, 当程序发生异常时, 智能指针也能正确的释放内存. 　　void f3() 　　{ 　　　　int* p = new int(10); ...

C++11中智能指针的原理、使用、实现【代码】

目录理解智能指针的原理智能指针的使用智能指针的设计和实现1.智能指针的作用 C++程序设计中使用堆内存是非常频繁的操作，堆内存的申请和释放都由程序员自己管理。程序员自己管理堆内存可以提高了程序的效率，但是整体来说堆内存的管理是麻烦的，C++11中引入了智能指针的概念，方便管理堆内存。使用普通指针，容易造成堆内存泄露（忘记释放），二次释放，程序发生异常时内存泄露等问题等，使用智能指针能更好的管理堆内存。理...

转载：C++中两个类中互相包含对方对象的指针问题【代码】【图】

原文链接：http://www.cnblogs.com/hanxi/archive/2012/07/25/2608068.html　　前几天很不爽，因为C++中两个类中互相包含对方对象的指针编译时提示某一个类未定义。。。所以我就想啊想，这样也对，我的头文件都有#ifndef的，包含了一次就不能再包含了，以为就实现不了这样的功能，于是就改了设计方案：class A { public:A(B* pB):m_pB(pB){}private:B* m_pB; };class B { public:B() {} private:int m_i; };只在一个类中包含另一个...

【C++】利用指针实现通过函数改变多个参数的值【代码】

写惯了python，对于C++的语法越来越生疏，不同于python中函数可以return多个变量，C++的函数要想返回多个参数可以利用指针实现。因为在函数内部的变量都是局部变量，所以当参数传入函数中，不return不会改变函数之外的全局变量的值。但是如果传入指针参数或者地址参数，则可以实现对外部变量的改变。有以下2种做法：1、函数定义：void function(int &a){a = 500;//return; //void时可以省略return }　函数调用：int b = 10; func...

C++ void/指针与其他数据类型的相互转换【代码】

在写opencv多线程的时候用到了pthread_create()函数，int pthread_create(pthread_t *tidp,const pthread_attr_t *attr,(void*)(*start_rtn)(void*),void *arg);其中函数里最后一个变量声明为void* args。因为涉及到函数之间的传参，因此考虑将void*指针转换为string类型存放opencv图片存放路径，因为void*指针的特殊性，将void*作为中间指针变量，在string转换后的void*指针传入后，再将void* 转换为string类型，在调用的线程函数...

C/C++中利用空指针简化代码,提高效率

这里的写法，可以避免使用 for 循环，减少栈空间内存的使用和减少运行时的计算开销！#include <iostream> #include <string> using namespace std; void print_char(char* array[]);//函数原形声明 void main(void) { char* test[]={"abc","cde","fgh",NULL};//这里添加一个NULL,表示不指向任何地址,值为0 print_char(test); cin.get(); } void print_char(char* array[]) { ...

c++ 指向类成员函数的函数指针【代码】

// ConsoleApplication34.cpp : 定义控制台应用程序的入口点。 //#include "stdafx.h" #include <iostream> usingnamespace std;class Parent { public:Parent(){//cout << "我是爹" << endl; }virtualvoid print() {cout << "我是爹" << endl;} private:int a; }; class Child :public Parent { public:Child(){}void print() {cout << "我是儿子" << endl;} private:int b; };int main() {//返回值类型 (域作用符::*函数指针...

#C++初学记录（字符串与指针操作库函数）【代码】

测试程序#include<iostream> #include<cstring> using namespace std; int a[204],b[204],lena,n; char s1[100]="12345"; char s2[100]="abcdefg"; char s3[100]="ABCDE"; int main() {strncat (s1,s2,3);//s1="12345abc";strncpy(s1,s3,3);//s3的前三个字符拷贝到s1，s1="ABC45abc"; strncpy(s2,s3,6);//s2="ABCDE";strncmp(s1,s3,3);//比较s1和s3的前三个字符，比较结果相等则输出0，小于则输出负数，大于则输出正数； char *p=s...

【C++】智能指针【代码】

auto_ptr　　auto_ptr是当前C++标准库中提供的一种智能指针。　　auto_ptr在构造时获取某个对象的所有去（ownership),在析构时释放该对象。我们可以这样使用auto_ptr来提高代码安全性：int* p = newint(0); auto_ptr<int> ap(p);　　从此我们不必关心应该何时释放p,也不必担心发生异常会有内存泄漏，这是因为auto_ptr的析构函数会执行指针的释放，而析构函数会在ap除了作用域以后执行。　　auto_ptr的出现，主要是为了解决“被异常...

C++ 智能指针【代码】

智能指针概念C/C++ 语言最为人所诟病的特性之一就是存在内存泄露问题，因此后来的大多数语言都提供了内置内存分配与释放功能，有的甚至干脆对语言的使用者屏蔽了内存指针这一概念。这里不置贬褒，手动分配内存与手动释放内存有利也有弊，自动分配内存和自动释放内存亦如此，这是两种不同的设计哲学。有人认为，内存如此重要的东西怎么能放心交给用户去管理呢？而另外一些人则认为，内存如此重要的东西怎么能放心交给系统去管理呢？...

关于c/c++指针，指针的指针

伪军迷祝：建军节快乐！当调用一个函数时，实际上入参使用的都是副本（除非是引用），指针也不例外。举个例子如：void func(int a, int * p);当调用func时无论是a还是p其实传入的都是副本，假设调用func时传给p的值是pt，则p这个pt的副本保存着和pt一样的地址，*p和*pt都是同一地址上的值，改变*p也就改变了*pt。但是，对p本身的操作是不会影响pt的，例如不能在函数func内部给p动态分配内存，或者使p指向别的地方，因为这只是对p这...

c++ 11学习笔记--智能指针【代码】

C++ 98的 std::auto_ptr已经被彻底遗弃了，取而代之的是unique_ptr、shared_ptr与weak_ptr。大部分时候我们自己手动申请内存方式内存都是没有问题的，问题是如果程序很大了之后，一个复杂的对象，多次拷贝的代价非常高，很多地方都会使用到，只存在一份拷贝显然是最好的，这个时候对象生命周期的管理就会很复杂，所以c++引入了智能指针。任何事物都会有两面性。 Shared_ptr摘录于Effective C++, 3rd Edition, Item 17: 在 standal...

C/C++ 指针数组、二维数组

一、二维数组1> 初始化int a[3][3] = { {1,0,0}, {0,1,0}, {0,0,1} }; // 这里是 {} , 而不是()2> 将二维数组当做一维数组处理void print_array( int * p, int row, int line){　　for(int i=0; i<row; ++i)　　{　　　　for(int j=0; j<line; ++j)　　　　{　　　　　　printf("%d \n", *( p + i * row + j ) ); // 相当于 *( *(p+i) + j ); // p[i][j]　　　　}　　}}// 调用print_array( (int *)a, 3, 3 );3> 二维数组当二维数...

【C/C++学院】0828-数组与指针/内存分配/数据结构数组接口与封装

【送给在路上的程序员】对于一个开发者而言，能够胜任系统中任意一个模块的开发是其核心价值的体现。对于一个架构师而言，掌握各种语言的优势并可以运用到系统中，由此简化系统的开发，是其架构生涯的第一步。对于一个开发团队而言，能在短期内开发出用户满意的软件系统是起核心竞争力的体现。每一个程序员都不能固步自封，要多接触新的行业，新的技术领域，突破自我。数组与指针#include<stdio.h> #include<stdlib.h>void main1()...

c++指针笔记一

左值和右值的区别：左值就是在赋值中可以放在赋值操作符两边的值，比如： int a = 1; double b = 2.0 a = b; b = a; 这里a和b都是左值，一切变量都是左值，但const量是例外。而右值则是只可以放在赋值操作符右边的值，比如： int a = 0; char *b = "hello"; 3 = a; // ERROR "howdy" = b // ERROR 这里3和"howdy"都是右值，所以不能放在赋值操作符左边，一切常数、字符和字符串都是右值。指针变量的声明与初始化1.指针包含的是包含...

首页 / C++ / C++---智能指针上

C++---智能指针上

内容导读

内容图文

内容总结

内容备注

内容手机端

【C++---智能指针上】教程文章相关的互联网学习教程文章

指针 - 相关标签

C++ - 技术教程分类

C++ - 最新教程

C++ - 最热教程