二十四、C++ 智能指针

已于 2023-11-26 18:30:39 修改
阅读量100 收藏
点赞数
文章标签： c++ 算法 开发语言
于 2023-11-26 18:28:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xhk951/article/details/134629107
版权

1.

#include <iostream>
#include <string.h>
#include <unistd.h>

using namespace std;

class Person {

public:

	Person() {
		cout <<"Pserson()"<<endl;
	}


	~Person()
	{
		cout << "~Person()"<<endl;
	}
	void printInfo(void)
	{
		cout<<"just a test function"<<endl;
	}
};

void test_func(void)
{
	Person *p = new Person();
	p->printInfo();    //没有delete 造成内存泄漏
} 

int main(int argc, char **argv)
{	
	int i;

	for (i = 0; i < 2; i++)
		test_func();
	return 0;
}


执行结果：
Pserson()
just a test function
Pserson()
just a test function
没有执行析构函数，造成内存泄漏

2.

#include <iostream>
#include <string.h>
#include <unistd.h>

using namespace std;

class Person {

public:

	Person() {
		cout <<"Pserson()"<<endl;
	}


	~Person()
	{
		cout << "~Person()"<<endl;
	}
	void printInfo(void)
	{
		cout<<"just a test function"<<endl;
	}
};

void test_func(void)
{
	//Person *p = new Person();
	Person per;
	per.printInfo();
}

int main(int argc, char **argv)
{	
	int i;

	for (i = 0; i < 2; i++)
		test_func();
	return 0;
}


Pserson()
just a test function
~Person()
Pserson()
just a test function
~Person()

3.以后用 Person *p指针，就用 sp 代替

#include <iostream>
#include <string.h>
#include <unistd.h>

using namespace std;

class Person {

public:

	Person() {
		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(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();    //导致 函数sp(Person *other) 被调用
                            //s 会在test_func被执行后销毁，new Person() 会传给 函数sp(Person *other)  
                            //Person就是 s的 p成员，会在 ~sp() 中delete，从而销毁person

	s->printInfo();    //本来不能调用，但是重载了 -> 符号

	//Person *p = new Person();
	//p->printInfo();
	//delete p;    //需要手工执行delete p 操作才不会内存泄漏

}

int main(int argc, char **argv)
{	
	int i;

	for (i = 0; i < 2; i++)
		test_func();
	return 0;
}

 4.

#include <iostream>
#include <string.h>
#include <unistd.h>

using namespace std;

class Person {

public:

	Person() {
		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;
	}

	sp(const sp &other)
	{
		cout<<"sp(const sp &other)"<<endl;
		p = other.p;
	}

	~sp()
	{
		cout<<"~sp()"<<endl;
		if (p)
			delete p;
	}

	Person *operator->()
	{
		return p;
	}
	
};

void test_func(sp &other)
{
	sp s = other;

	s->printInfo();

	//Person *p = new Person();
	//p->printInfo();
	//delete p;
}

int main(int argc, char **argv)
{	
	int i;

	sp other = new Person();
    //相当于
    //1. Person *p = new Person();
    //2. sp tem(p);  ==> 调用构造函数 sp(Person *other) 使用Person * 构造sp 对象
    //3
    //3.1 sp other(tem);  ==> 调用拷贝构造函数 sp(sp &other2)
           //  sp &other2 = tem;  //错误语法 一个引用不能指向临时变量
           //  const sp &other2 = tem;  OK  所以拷贝构造函数 加 const
      或
    //3.2 sp other(tem ==> Person *);  ==> 调用构造函数 sp(Person *other)
            //  tem ==> Person *;  //tem 不能隐式转换为 Person *       

	for (i = 0; i < 2; i++)
		test_func(other);
	return 0;
}

5.引用计数

#include <iostream>
#include <string.h>
#include <unistd.h>

using namespace std;

class Person {
private:
	int count;

public:
	void incStrong(){ count++; }	
	void decStrong(){ count--; }	
	int getStrongCount(){ return count;}

	Person() : 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;     用 other构造这个 s

	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;
}

6.少用person* ，用 sp 来代替

      Person *per;

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

     sp也应该有两种操作:

     sp->XXX, (*sp).XXX

重载这两个符号： ->   *

#include <iostream>
#include <string.h>
#include <unistd.h>

using namespace std;

class Person {
private:
	int count;

public:
	void incStrong(){ count++; }	
	void decStrong(){ count--; }	
	int getStrongCount(){ return count;}

	Person() : 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;
	}

	Person& operator*()
	{
		return *p;
	}
	
};

void test_func(sp &other)
{
	sp s = other;

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

	s->printInfo();	
}

int main(int argc, char **argv)
{	
	int i;

	sp other = new Person();

	(*other).printInfo();
	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;
}

7.

#include <iostream>
#include <string.h>
#include <unistd.h>

using namespace std;

class RefBase {
private:
	int count;

public:
	RefBase() : count(0) {}
	void incStrong(){ count++; }	
	void decStrong(){ count--; }	
	int getStrongCount(){ return count;}
};

class Person : public RefBase{

public:
	Person() {
		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;
	}

	Person& operator*()
	{
		return *p;
	}
	
};

void test_func(sp &other)
{
	sp s = other;

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

	s->printInfo();
}

int main(int argc, char **argv)
{	
	int i;

	sp other = new Person();

	(*other).printInfo();
	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;
}

8.少用person* ，用 sp<Pserson>来代替，new出来的对象不需要delete

#include <iostream>
#include <string.h>
#include <unistd.h>

using namespace std;

class RefBase {
private:
	int count;

public:
	RefBase() : count(0) {}
	void incStrong(){ count++; }	
	void decStrong(){ count--; }	
	int getStrongCount(){ return count;}
};

class Person : public RefBase{

public:
	Person() {
		cout <<"Pserson()"<<endl;
	}

	~Person()
	{
		cout << "~Person()"<<endl;
	}
	void printInfo(void)
	{
		cout<<"just a test function"<<endl;
	}
};

template<typename T>
class sp {
private:
	T *p;

public:
	sp() : p(0) {}
	
	sp(T *other)
	{
		cout<<"sp(T *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;
			}
		}
	}

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

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

template<typename T>
void test_func(sp<T> &other)
{
	sp<T> s = other;

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

	s->printInfo();
}

int main(int argc, char **argv)
{	
	int i;

	sp<Person> other = new Person();

	(*other).printInfo();
	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;
}

xhk951
关注
c++智能指针最全知识点即面试题目总结
02-27
以智能指针的面试题线索，穿插讲解完最常用的四种智能指针的各个方面。本文讲解4个智能指针的基本概念和特性，以及其他设计到的知识点。讲解的过程中，如果此部分内容涉及到面试题目，会在旁边以这个题目的序号来...
2小时精通C++智能指针
06-18
本课程讲解C++11标准库中的智能指针。对于C/C++程序员来说，指针是天堂，也是地狱。指针用得好程序运行效率倍增，用得不好问题层出不穷。智能指针可以解决普通指针存在的悬垂指针、野指针、资源泄露等问题本教程的...
C++ 智能指针 - 全部用法详解
热门推荐
cpp_learner的博客
08-02 7万+
血的教训？不学智能指针，本人丢了一份工作。
C++ STL 四种智能指针
Dablelv 的博客专栏。
08-07 7万+
auto_ptrunique_ptrshared_ptrweak_ptrauto_ptr 是 C++98 提出的，C++11 已将其摒弃，并提出了 unique_ptr 替代 auto_ptr。虽然 auto_ptr 已被摒弃，但在实际项目中仍可使用，但建议使用更加安全的 unique_ptr，后文会详细叙述。shared_ptr 和 weak_ptr 则是 C+11 从准标准库 Boost 中引入的两种智能指针。
c++智能指针详解
bitcarmanlee的博客
05-18 3万+
1.什么是智能指针 从比较简单的层面来看，智能指针是RAII(Resource Acquisition Is Initialization，资源获取即初始化)机制对普通指针进行的一层封装。这样使得智能指针的行为动作像一个指针，本质上却是一个对象，这样可以方便管理一个对象的生命周期。 在c++中，智能指针一共定义了4种： auto_ptr、unique_ptr、shared_ptr 和 weak_ptr。其中，auto_ptr 在 C++11已被摒弃，在C++17中已经移除不可用。 2.原始指针的问题 原始指
【C++进阶学习】第十三弹——C++智能指针的深入解析
2301_80220607的博客
08-13 2754
【C++进阶学习】：C++掌握内存管理重要一步——智能指针的深入解析：什么是智能指针？为什么需要智能指针？一篇带你搞清楚智能指针的作用及原理
C++智能指针详解
qq_61635026的博客
10-02 2034
智能指针是存储指向动态分配（堆）对象指针的类。除了能够在适当的时间自动删除指向的对象外，他们的工作机制很像C++的内置指针。智能指针在面对异常的时候格外有用，因为他们能够确保正确的销毁动态分配的对象。他们也可以用于跟踪被多用户共享的动态分配对象。下面我们先分析一下下面这段程序有没有什么内存方面的问题？ 关于内存泄漏见文章【C++ 内存管理】RAII（Resource Acquisition Is Initialization），也称为 “资源获取就是初始化” ，是一种利用对象生命周期来控制程序资源（如内存
C++ 智能指针
Cdreamfly的博客
02-23 2572
shared_ptr 智能指针也是模板类，因此当我们创建一个智能指针是要提供额外的信息——指针可以指向的类型。默认初始化的智能指针保存着一个空指针。shared_ptr允许多个指针指向同一对象。 shared_ptr<string> p1; //可指向string shared_ptr<list<int>> p2; //可指向int的list make_shared 最安全的分配和使用动态内存的方法是调用一一个名为make_shared 的标准库函数。此函数在动态内存
【C++】智能指针详解
就爱摆烂
05-04 9953
今天我们来讲一下c++11中的智能指针。
C++智能指针的用法
朝花夕拾
11-06 1万+
智能指针（Smart Pointers）是一种在C++中用于管理动态分配内存的工具，它们提供了更安全和方便的方式来管理内存资源，以避免内存泄漏和资源管理错误。C++标准库提供了多种不同类型的智能指针。
【C++】智能指针
上上谦. 的博客
03-19 1761
前倾回顾，在我们之前学习异常的时候，讲到过异常安全的问题，会有内存泄露的问题。内存泄露这个问题对程序员的要求很高，申请的空间就必须要手动释放，不像Java这种语言自带垃圾回收器（gc）。就算是我们手动释放了空间，也有可能存在内存泄露的问题（异常安全），抛异常时会乱跳，有可能就会导致即使手动释放了，也没会内存泄露。上节在异常种我们可以通过拦截异常手动释放掉，但是防不胜防并不是所有的都能拦截到，于是C++就引入了智能指针。异常安全回顾：传送门。
C/C++智能指针
水澹澹兮生烟
09-16 2275
我们在在动态开辟空间的时候，malloc出来的空间如果没有进行释放，那么回传在内存泄漏问题。或者在malloc与free之间如果存在抛异常，那么还是有内存泄漏安全。因此我们在这里引入了智能指针来对资源进行管理。（内存泄漏） 1.使用及原理 1.1RAII(资源获取几初始化) RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。 在对象构造时获取资源，接着控制对资源的访问使之在.
C++智能指针用法详解
12-22
　用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: ...
C++智能指针-unique-ptr智能指针详解.pdf
02-27
《C++智能指针——unique_ptr智能指针详解》 智能指针是C++中用于自动管理动态分配内存的一种工具，它可以确保在适当的时候自动释放内存，从而避免内存泄漏的问题。其中，`unique_ptr`是一种特殊的智能指针，它拥有...
C语言[函数实现模块化程序设计]
2401_87108776的博客
10-09 418
函数的名字函数的类型函数参数的名字及类型函数的功能。
PyQt 的Tree Widget中拖放和点击的异常行为
最新发布
weixin_44617651的博客
10-10 506
在 PyQt 的 ​​QTreeWidget​​ 中，如果你遇到 拖放 和 点击 的异常行为，可能是由于信号处理、事件拦截、拖放设置或树结构配置等问题导致的。以下是一些可能的常见问题和解决方案。
42 C 语言 typedef：为基本数据类型、数组、指针、结构体、共用体起别名
Thanks_ks的IT探秘之旅
10-09 654
本文全面介绍了 C 语言中 typedef 的使用方法和技巧。从为基本类型如 int、unsigned char 起别名，到为结构体、共用体、指针以及数组等复杂类型起别名，都进行了详细的阐述。通过具体示例，展示了如何分开定义结构体和别名、如何在结构体定义中直接使用 typedef、如何为匿名结构体起别名等高级用法。此外，还探讨了为指针和数组类型起别名的方法，并给出了综合案例，帮助读者更好地理解和应用 typedef。
大话C++：第15篇 友元
whccf的博客
10-09 966
友元（Friend）是C++中的一个特殊概念，它允许一个类或函数访问另一个类的私有和保护成员。友元可以是一个函数，也可以是一个类。
C++智能指针实例详解：内存管理神器
C++智能指针实例详解深入解析了C++编程中解决内存管理问题的关键工具。C++语言原生缺乏自动内存回收功能，导致程序员在使用new分配内存后必须手动调用delete来释放，这易引发内存泄漏或因异常而未释放内存的问题。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值