C++：C++Primer Plus(第六版)：Chapter16 : string类和标准模板库：智能指针

于 2023-05-11 12:31:16 发布
阅读量600 收藏
点赞数
分类专栏： # C++ 书籍 文章标签： c++ 开发语言 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013620306/article/details/130615168
版权

Chapter16.2 : 智能指针模板类


本章节我们主要讲解 智能模板类，并主要从下面几个方面入手：

  1. 智能指针出现背景和现实需求
  2. 智能指针 使用范式
  3. 智能指针种类以及该如何选型

1.指针指针现实需求

智能指针是行为类似于指针的类对象，但这种对象还有其他功能，它可以管理给指针分配的对象

1.1 普通指针弊端

先看下面函数

#include<string>
void remodel(std::string& str)
{
	std::string* ps = new std::string(str);
	....
	std = ps;
	return;
}

上面的代码呢可以已经发现了这样一个现象：
该函数分配在堆中的随想，从来不收回，这会导致内存泄漏，你可能也知道解决之道： 在 return 前添加下面语句，释放内存即可

delete ps

但是这仍然会有问题，情况下面的变体。

#include<string>
void remodel(std::string & str)
{
	std::string *ps = new std::string(str);
	...
	if (weird_thing())
		throw exception();
	str = *ps;
	delete ps;
	return;
}

很显然，出现异常时，delete将不再执行，因此还是会导致内存泄漏。

1.2 智能指针现实需求

  1. 基于1.1章节，我们知道，你可能会在函数执行完毕，忘记 delete ps 或者在 delete ps 执行之前，代码发生异常。这两点都会无法释放内存，造成内存泄漏。
  2. 所以，我们需要有这样一种情况：函数栈在执行完毕后，指针ps 占的内存被释放，指针ps 指向的堆内存也会自动释放（这个可以通过析构函数释放）
  3. 但是 ps 只是一个常规指针，不是有析构函数的类对象，如果它是对象，那么可以在对象过期时，让它的析构函数删除指向的内存。
  4. 这就是 auto_ptr , unique_ptr和 shared_ptr 背后的思想所在。
  5. auto_ptr 是C++98 提供的解决方案，C++11 已经将摒弃，并提供了另外两种解决方案， 如果您的编译器不支持其他两种方案，那么 auto_ptr 是唯一的选择。

💚💚💚
下面来看一个使用智能指针的例子

在这里插入图片描述
很显然 auto_ptr 定义了类似指针的对象，可以将 new 获取（直接或间接）的地址赋给对象，当智能指针过期时，对象其析构函数 将使用 delete 来释放内存。

  1. 如果将 new返回的地址赋给这些对象，将无需记住稍后需要释放的内存。
  2. 智能指针在过期时，这些内存会自动释放。

2. 智能指针使用范式

  1. 要创建智能指针对象，必须包含头文件 memory, 下面是 auto_ptr 文件模板定义如下。
// 下面是伪代码
#include<memory>
#include<string>
template<class X>
class auto_ptr
{
public:
	eplicit auto_ptr(X* p = 0);
}

void create_auto_ptr()
{
	auto_ptr<double> pd(new double); // pd an auto_ptr to double
	auto_ptr<string> ps(new string);  // ps an auto_ptr string 
}
  1. new double/ new string 是new 返回的指针，指向新分配的内存块，它是构造函数 auto_ptr 的参数，对应原型中形参 p 的实参。

因此第一节的例子就可以这样转换
💚 包含头文件 memory
💚 指向 string 的指针 替换为 指向 string 的智能指针对象
💚 删除 delete语句

#include<string>
#include<memory>
void remodel(std::string & str)
{
	// std::string *ps = new std::string(str);
	std::auto_ptr<str::string> ps (new std::string(str));
	...
	if (weird_thing())
		throw exception();
	str = *ps;
	// delete ps;   no longer needed
	return;
}

2.1 下面演绎三种智能指针用法

#incdlue<iostream>
#include<string>
#include<memory>
class Report
{
private:
    std::string str;
public:
	Report(const std::string s):str(s)
	{
		std::cout<< "Objcet create \n";
	}
	~Report()
	{
		std::cout << "Object deleted\n";
    }
	void comment() const
	{
		std::cout <<str << std::endl;
    }
}

int main()
{
    {
    	// 将 new Report 对象地址 赋值给 auto_ptr 构造函数 实参p
		std::auto_ptr<Report> ps(new Report("using auto_ptr"));
		ps->comment();  // use ->invoke a member function
    }
	
	{
    	// 将 new Report 对象地址 赋值给 shared_ptr 构造函数 实参p
		std::shared_ptr<Report> ps(new Report("using shared_ptr"));
		ps->comment();  // use ->invoke a member function
    }
	{
    	// 将 new Report 对象地址 赋值给 unique_ptr 构造函数 实参p
		std::unique_ptr<Report> ps(new Report("using unique_ptr"));
		ps->comment();  // use ->invoke a member function
    }
	return 0;
}

// 打印结果
Objcet create 
using auto_ptr
Object deleted

Objcet create 
using shared_ptr
Object deleted

Objcet create 
using unique_ptr
Object deleted
  1. 所有智能指针类都有一个 explicit 构造函数，该构造函数将指针作为参数，因此不需要自动将指针转换为 智能指针对象，更不要将指针转换成智能指针。如
shared_ptr<double> pd;
double *p_reg = new double;
pd = p_reg;  // not allow (implicit conversion)
pd = shared_ptr<double>(p_reg);  // allow (explicit conversion)

shared_ptr<double> pshared = p_reg;  // not allowed (implicit conversion)
shared_ptr<double> pshared(p_reg);  // allowed (explicit conversion)

注意一个问题

下面这个问题，全部三种智能指针都应该避免

string vacation("I wandeed lonely as a child");
shared_ptr<string> pvac(&vacation);  // error 

// pvac 过期时，程序将把 delete 运算符用于非 堆内存，这是 错误的

3. 三种智能指针特点

3.1 为何摒弃 auto_ptr

先看下面语句

string str = new string("I wandeed lonely as a child");
string *ps = &str;
string* vocation;
vocation = ps;  // 将指针赋值给另一个指针
delete ps;
delete vocation;

💚 上面这段语句会完成什么操作了 ？

  1. 这两个指针都指向一个string 对象，这是不能接受的，因为程序将视图删除同一个对象 两次，一次是 ps 过期时，另一次是 vocation过期时，要避免这种问题方法有很多 。
    🧡
  2. 定义赋值运算符：使之执行深度赋值，这样两个指针指向不同的对象，其中的一个对象是另一个对象的副本。
  3. 建立所有权（ownership） 概念：对于特定对象，只能有一个指针拥有它，这样只有拥有对象的指针指针的析构函数才可以删除，然后，让赋值操作转让所有权，这就是 auto_ptr 和unique_ptr 的策略，但是 unique_ptr 的策略更严格
  4. 创建智能更高的指针，跟踪引用特定对象的智能指针，这被称为引用计数 (reference counting)。

🚀 下面我们来通过另一个例子详细说明：为何摒弃 auto_ptr。

#include<iostream>
#include<string>
#include<memory>

int main()
{

    using namespace std;
	auto_ptr<string> film[5]=
	{
		
		auto_ptr<string> (new string("Flowl Bals")),
		auto_ptr<string> (new string("Duck walks")),
		auto_ptr<string> (new string("Chicken run")),
		auto_ptr<string> (new string("Turkey errors")),
		auto_ptr<string> (new string("Goose Eggs"))
	};
	
	auto_ptr<string> pwin;
	pwin = film[2]; // film[2] loses ownership(将对象的所有权转让给 pwin)
	for(int i = 0;i<5;i++)
	{
		
		cout << *film[i] << endl;
	}
	cout<< "the winner is: " << *pwin << "\n";
	
	return 0;
}

// 打印结果
Flowl Bals
Duck walks
Segmentation fault

很显然，这是由于错误的使用 auto_ptr 可能导致的问题（但是这种行为是不确定的，其行为可能随系统而定），这里的问题是由于下面的语句将 ：所有权 从 films[2] 转让给 pwin

pwin = films[2] // films[2] loses ownership
这导致 films[2] 不再引用 该字符串，在 auto_ptr 放弃对象所有权后，你又通过 *films[2] 访问指向的对象，却发现这是一个空指针。
这便是 auto_ptr 令人讨厌的地方。

3.2 选用 unique_ptr

如果我们将 auto_ptr 修改成 unipue_ptr 了 ？

#include<iostream>
#include<string>
#include<memory>

int main()
{

    using namespace std;
	unique_ptr<string> film[5]=
	{
		
		unique_ptr<string> (new string("Flowl Bals")),
		unique_ptr<string> (new string("Duck walks")),
		unique_ptr<string> (new string("Chicken run")),
		unique_ptr<string> (new string("Turkey errors")),
		unique_ptr<string> (new string("Goose Eggs"))
	};
	
	unique_ptr<string> pwin;
	pwin = film[2]; // film[2] loses ownership(将对象的所有权转让给 pwin)
	for(int i = 0;i<5;i++)
	{
		
		cout << *film[i] << endl;
	}
	cout<< "the winner is: " << *pwin << "\n";
	
	return 0;
}

好家伙，直接报错，都不能编译通过，

💚💚💚这便是 unique_str 与 auto_ptr 的区别

  1. 它避免了 films[2] 指针不再指向有效数据的问题，即悬挂指针问题。
    在这里插入图片描述

3.3 选用 shared_ptr

#include<iostream>
#include<string>
#include<memory>

int main()
{

    using namespace std;
	shared_ptr<string> film[5]=
	{
		
		shared_ptr<string> (new string("Flowl Bals")),
		shared_ptr<string> (new string("Duck walks")),
		shared_ptr<string> (new string("Chicken run")),
		shared_ptr<string> (new string("Turkey errors")),
		shared_ptr<string> (new string("Goose Eggs"))
	};
	
	shared_ptr<string> pwin;
	pwin = film[2]; // film[2] loses ownership(将对象的所有权转让给 pwin)
	for(int i = 0;i<5;i++)
	{
		
		cout << *film[i] << endl;
	}
	cout<< "the winner is: " << *pwin << "\n";
	
	return 0;
}
// 打印结果
Flowl Bals
Duck walks
Chicken run
Turkey errors
Goose Eggs
the winner is: Chicken run

这次 pwin和films[2] 指向同一个对象。

  1. 引用计数从 1 增加到 2
  2. 在程序结尾，后声明的 pwin先调用析构函数，该析构函数将引用计数降低到1
  3. 对 films[2] 调用析构函数时，引用计数降低到0 ，这个时候就可以释放以前分配的空间。

4. 应该使用哪种智能指针

  1. 如果程序使用多个指向同一个对象的指针，应选择 shared_ptr
  2. STL容器包含指针，很多STL算法都支持 复制和赋值操作，这些操作可用于 shared_ptr
  3. 如果您的编译器没有体用 shared_ptr 可以使用 Boost库提供的 shared_ptr
  4. 如果程序不需要多个指向同一个对象的指针，则可以使用 unique_ptr 。
FishAnd_Yu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《C++ Primer Plus 第6版》第16章 string类和标准模板库 学习笔记——智能指针模板类
Anna_L的博客
12-23 216
智能指针模板类
C++ Primer Plus 第6版 中文版课后代码习题答案
最新发布
03-10
《C++ Primer Plus 第6版 中文版》是一本深入浅出的C++学习书籍，其课后代码习题答案是学习过程中不可或缺的部分。这本书旨在帮助读者从零基础开始掌握C++编程语言，通过实例和习题来巩固理论知识，提升编程技能。...
C++中的一些自带类——string、智能指针
weixin_49150819的博客
03-15 1690
C++的string类与智能指针类
C++，string类的指针，string类数组的指针 string *s
热门推荐
xuanweiace的博客
11-17 1万+
可以这样： #include<iostream> #include<string> using namespace std; int main(void) { string s = "hello"; //定义一个char类型指针，把string s的首元素地址赋给pt,则pt指向字符串s. char *pt = &s[0]; cout << pt << endl; return 0; } 或者这样： string var =
【C++笔记】十七、string类与智能指针
段昊东的博客
08-19 942
1.string类的构造方法 #include <iostream> using namespace std; int main(int argc, const char * argv[]) { // 模板类string的构造方法 // 1. 没有参数的构造方法 string str1; str1 = "超人"; cout << "str1 = " << str1 << endl; /
C++学习5：详解带指针的类（侯捷String类为例）
时间有泪
03-30 1661
同不带指针的类一样，防卫式声明、前置声明都要有。然后进行类的定义、函数（成员函数和全局函数）的声明和定义。 这部分内容的大体框架和不带指针的类相同，可以参考：C++学习4：详解不带指针的类（侯捷Complex类为例）。下面就不同之处加以剖析。 1 代码部分 1.1 main函数 为了清楚看出与不带指针的类主要的不同之处，下面请直接看main函数： int main() { String s1()...
C++ Primer Plus 第六版 String练习 Hangman拼字游戏
01-22
本练习是基于C++ Primer Plus第六版中的一个经典案例——Hangman拼字游戏，旨在帮助学习者深入理解和掌握C++中的字符串操作。 Hangman游戏是一种猜词游戏，玩家需要根据给出的提示字母来猜测单词。在这个练习中，...
C++ Primer Plus 第六版 第6版 中文版 编程练习答案
08-17
C++ Primer Plus 第六版 第6版 中文版 编程练习答案 全面详细，助力深入理解C++精髓
C++PrimerPlus第6版中文版勘误表共4页.pdf
10-29
《C++ Primer Plus 第6版》是一本广受欢迎的C++编程教材，旨在帮助初学者和有经验的程序员深入理解C++语言。该书详细介绍了C++的基础语法、面向对象编程概念以及高级特性，是学习C++的重要参考资料。提供的“C++...
模板中的嵌套 C++PRIMER PLUS 第六版练习
01-22
在《C++ PRIMER PLUS 第六版》中，作者深入探讨了模板的各个方面，包括模板的嵌套。嵌套模板是模板的一个高级特性，它允许我们在一个模板内部定义另一个模板，从而实现更复杂的代码复用。以下是对这一主题的详细阐述...
数据结构中二叉树的建立为什么要用指针的引用？
weixin_46223467的博客
10-10 2463
在函数调用时用指针或者引用做参数，表示把变量的地址传递给子函数，但是子函数只能修改指针所指变量的值，并不能修改指针的指向。如果想要修改指针的指向，就要用指针的指针，或者指针的引用。 二叉树的建立中 t=(BiTtree*)malloc(sizeof(BiTtree)); t->data=d; CreateBiTree(t->left,x); CreateBiTree(t->right,x);; 其中t=(tree*)malloc(sizeof(tree)); 改变了指针的指向所
C++中的指针和字符串
阿达King哥的博客
09-17 817
main(){    char* string = "c language";    count} 一般来讲，对于字符数组作为函数的参数可以采用以下4种方法：            实参        形参(1)        数组名      数组名(2)        数组名      字符指针变量(3)     字符指针变量   字符指针变量(4)  
C/C++笔记：std::string（二）指针数组字符串
南城同学的博客
05-26 1807
在内存里的布局，与C字符串（char*）不同的是，C字符串以0结尾，而string字符串由于有专门记录其长度的属性，在实现的时候，并没有严格要求是否以0结尾！ 但是在C++11标准推出后，要求string字符串也以0结尾； 通过.c_str()方法可以得到一个const char*的指针，指向str存储字符数据的内存空间； 通过.data()方法可以得到一个const char*的指针，指向str存储字符数据的内存空间； 在C++17标准下 .data()方法得到的是一个char*的指针。 ...
【C++】侯捷：C++面向对象笔记03-带有指针的类：String
Friday
09-07 755
防卫式定义编译器给的那一套拷贝赋值与拷贝构造函数，仅仅是一个bit一个bit的拷贝，而对于带有指针的类而言，很显然，这样的构造是不满足使用场景的。
C++ 字符串指针和字符串指针数组详解
Mr.horse的博客
04-19 6500
C++处理字符串有两种方式，即：指针方式和数组方式 数组方式：char a[] = "HelloWorld"; 指针方式：const char* s= "HelloWorld"; const可以忽略 接下来详细讲解一下字符串指针 首先，为什么字符串可以直接赋值给指针，即char* s = "HelloWorld"不会报错，不应该是把字符串的地址赋值给指针吗？ 原因：这里的双引号做了3件...
【c++笔记（二）侯捷老师课程】带指针的类——string的实现
九袋面的博客
07-07 828
一、拷贝构造，拷贝复制 如果创建了带指针的类，那么一定要自己写拷贝函数，不能用编译器中的，因为编译器将指针复制，两个指针仍然指向同一个地址，不是真正意义上的拷贝。 一般字符串的设计 让字符串里面拥有一根指针，在需要内存时才去创建另外一个空间来放字符本身，字符有大有小，有种动态的感觉。 所以字符串的data应该是一个指针，指向字符。 1.String类的设计 class Str...
[标准C/C++基础]用指针指向string类的对象
myKernel
07-13 8192
//用指针指向string类的对象#include #include using namespace std; int main(void) { string s = "hello"; //定义一个char类型指针，把string s的首元素地址赋给pt,则pt指向字符串s. char *pt = &s[0]; cout << pt << endl; return 0; }
【C++】string类的使用
学了就忘是正常现象
11-08 2229
C语言处理串要用大量指针，用C++的string真的方便很多！
C/C++ 字符数组(字符串)和指针总结(char *, string, Type *)
一些笔记
08-09 3209
对 C/C++ 字符串（数组）和指针做的总结
C++ Primer Plus 第六版：编程专业指南
第六版可能包含了C++11、C++14甚至C++17标准的新特性，如智能指针、lambda表达式、协程、并发编程等。 在学习过程中，读者可以了解到如何利用C++的强大功能进行面向对象编程，以及如何编写高效、可维护的代码。作者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值