读书笔记 effective c++ Item 15 在资源管理类中提供对原生(raw)资源的访问

简介: 1.为什么需要访问资源管理类中的原生资源  资源管理类是很奇妙的。它们是防止资源泄漏的堡垒,没有资源泄漏发生是设计良好的系统的一个基本特征。在一个完美的世界中,你需要依赖这样的类来同资源进行交互,绝不要直接访问原生(raw)资源而玷污你的双手。

1.为什么需要访问资源管理类中的原生资源 

资源管理类是很奇妙的。它们是防止资源泄漏的堡垒,没有资源泄漏发生是设计良好的系统的一个基本特征。在一个完美的世界中,你需要依赖这样的类来同资源进行交互,绝不要直接访问原生(raw)资源而玷污你的双手。但是世界不是完美的,许多API会直接引用资源,所以除非你放弃使用这样的API(这是不实际的想法),你将会绕开资源管理类而时不时的处理原生资源。

2. 如何获取原生资源——通过显示转换和隐式转换

2.1 一个例子

举个例子,Item 13中介绍了使用像auto_ptr或者tr1::shared_ptr这样的智能指针来存放调用createInvestment工厂函数的返回结果:

1 std::tr1::shared_ptr<Investment> pInv(createInvestment()); // from Item 13

 

假设你想使用一个同Investment对象一起工作的函数,如下:

1 int daysHeld(const Investment *pi); // return number of days
2 
3 // investment has been held

你会像下面这样调用它:

1 int days = daysHeld(pInv); // error!

 

代码将不能通过编译:dayHeld想要使用一个原生Investment*指针,你却传递了一个tr1::shared_ptr<Investment>类型的对象。

 

你需要一种方法将一个RAII类对象(在这个例子中是tr1::shared_ptr)转换成它所包含的原生资源类型。有两种常见的方法来实现它:显示转换和隐式转换

2.2 使用智能指针的get进行显示转换

Tr1::shared_ptr和auto_ptr都提供了一个get成员函数来执行显示转换,也就是返回智能指针对象内部的原生指针:

1 int days = daysHeld(pInv.get()); // fine, passes the raw pointer
2 
3 // in pInv to daysHeld

 

2.3 使用智能指针的解引用进行隐式转换

事实上像所有的智能指针一样,tr1::shared_ptr和auto_ptr也重载了指针的解引用运算符(operator->和operator*),这就允许将其隐式的转换成底层原生指针: 

 1 class Investment { // root class for a hierarchy
 2 
 3 public: // of investment types
 4 
 5 bool isTaxFree() const;
 6 
 7 ...
 8 
 9 };
10 
11 Investment* createInvestment(); // factory function
12 
13 std::tr1::shared_ptr<Investment> // have tr1::shared_ptr
14 
15 pi1(createInvestment()); // manage a resource
16 
17 bool taxable1 = !(pi1->isTaxFree()); // access resource
18 
19 // via operator->
20 
21 ...
22 
23 std::auto_ptr<Investment> pi2(createInvestment()); // have auto_ptr
24 
25 // manage a
26 
27 // resource
28 
29 bool taxable2 = !((*pi2).isTaxFree()); // access resource
30 
31 // via operator*

 

2.3 自己实现get进行显示转换

因为有时候获取RAII对象中的原生资源是必要的,一些RAII类的设计者通过提供一个隐式转换函数来顺利达到此目的。举个例子,考虑下面的字体RAII类,字体对于C API来说是原生数据结构:

 1 FontHandle getFont(); // from C API — params omitted
 2 
 3 // for simplicity
 4 
 5 void releaseFont(FontHandle fh); // from the same C API
 6 
 7 class Font { // RAII class
 8 
 9 public:
10 
11 explicit Font(FontHandle fh) // acquire resource;
12 
13 : f(fh) // use pass-by-value, because the
14 
15 {} // C API does
16 
17 ~Font() { releaseFont(f ); } // release resource
18 
19 ... // handle copying (see Item 14)
20 
21 private:
22 
23 FontHandle f; // the raw font resource
24 
25 };

 

假设有大量的字体相关的C API用于处理FontHandles,因此会有频繁的需求将Font对象转换成FontHandles对象。Font类可以提供一个显示的转换函数,比如说:get:

 

 1 class Font {
 2 
 3 public:
 4 
 5 ...
 6 
 7 FontHandle get() const { return f; } // explicit conversion function
 8 
 9 ...
10 
11 };

 

不幸的是,如果它们想同API进行通讯,每次都需要调用get函数:

 1 void changeFontSize(FontHandle f, int newSize); // from the C API
 2 
 3 Font f(getFont());
 4 
 5 int newFontSize;
 6 
 7 ...
 8 
 9 changeFontSize(f.get(), newFontSize); // explicitly convert
10 
11 // Font to FontHandle

一些程序员发现显示请求这些转换是如此令人不愉快以至于不想使用RAII类。但是这会增加泄漏字体资源的机会,这正是设计Font类要预防的事情。

 

2.3 自己实现operator() 进行隐式转换

 一种替代的方法是让Font提供一个隐式转换到FontHandle的函数:

 1 class Font {
 2 
 3 public:
 4 
 5 ...
 6 
 7 operator FontHandle() const // implicit conversion function
 8 { return f; }
 9 
10 ...
11 
12 };

 

这会使C API的调用变得容易并且很自然:

1 Font f(getFont());
2 
3 int newFontSize;
4 
5 ...
6 
7 changeFontSize(f, newFontSize); // implicitly convert Font
8 
9 // to FontHandle

 

缺点是隐式转换增加了出错的机会。举个例子,客户端本来想要一个Font却创建了一个FontHandle:

 1 Font f1(getFont());
 2 
 3 ...
 4 
 5 FontHandle f2 = f1; // oops! meant to copy a Font
 6 
 7 // object, but instead implicitly
 8 
 9 // converted f1 into its underlying
10 
11 // FontHandle, then copied that

 

现在程序拥有一个被Font对象 f1管理的FontHandle,但是直接使用f2也可以获得这个FontHandle。这就不好了。例如:当f1被销毁,字体资源被释放,f2就变成了悬挂指针。

3.隐式转换和显示转换如何选择?

提供从RAII类对象到底层资源的显示转换(通过一个get成员函数)还是提供隐式转换依赖于设计出来的RAII类需要执行的特殊任务以及使用的场景。最好的设计看上去要遵守Item 18的建议:使接口容易被正确使用,很难被误用。通常情况下,像get一样的显示转换函数会是更好的选择,因为它减少了类型误转换的机会。然而有时候,使用隐式类型转换的自然特性会使局面发生扭转。

 

4.访问原生资源和封装背道而驰?

函数返回一个RAII类中的原生资源同封装是背道而驰的,这已经发生了。这不是设计的灾难,RAII类的存在不是用来封装一些东西;他们的存在是用来保证资源的释放会发生。如果需要,资源封装可以在这个基本功能之上进行实现,但这不是必要的。此外,一些RAII类将实现的真正封装同底层资源非常松散的封装组合到一块。举个例子:tr1::shared_ptr封装了所有的引用计数,但是仍然可以非常容易的访问它所包含的原生指针。像一些设计良好的类,它隐藏了客户没有必要看到的东西,但是它提供了客户端确实需要访问的东西。

5.总结

  • API通常需要访问原生资源,所以每个RAII类应该提供一个获得它所管理的原生资源的方法。
  • 访问原生资源可以通过显式转换或者隐式转换来达到。一般情况下,显示转换更加安全,隐式转换对客户端来说更加方便。


作者: HarlanC

博客地址: http://www.cnblogs.com/harlanc/
个人博客: http://www.harlancn.me/
本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出, 原文链接

如果觉的博主写的可以,收到您的赞会是很大的动力,如果您觉的不好,您可以投反对票,但麻烦您留言写下问题在哪里,这样才能共同进步。谢谢!

目录
相关文章
|
编译器 C++ 容器
【c++11】c++11新特性(上)(列表初始化、右值引用和移动语义、类的新默认成员函数、lambda表达式)
C++11为C++带来了革命性变化,引入了列表初始化、右值引用、移动语义、类的新默认成员函数和lambda表达式等特性。列表初始化统一了对象初始化方式,initializer_list简化了容器多元素初始化;右值引用和移动语义优化了资源管理,减少拷贝开销;类新增移动构造和移动赋值函数提升性能;lambda表达式提供匿名函数对象,增强代码简洁性和灵活性。这些特性共同推动了现代C++编程的发展,提升了开发效率与程序性能。
605 12
|
机器学习/深度学习 存储 算法
基于 C++ 布隆过滤器算法的局域网上网行为控制:URL 访问过滤的高效实现研究
本文探讨了一种基于布隆过滤器的局域网上网行为控制方法,旨在解决传统黑白名单机制在处理海量URL数据时存储与查询效率低的问题。通过C++实现URL访问过滤功能,实验表明该方法可将内存占用降至传统方案的八分之一,查询速度提升约40%,假阳性率可控。研究为优化企业网络管理提供了新思路,并提出结合机器学习、改进哈希函数及分布式协同等未来优化方向。
392 0
|
人工智能 机器人 编译器
c++模板初阶----函数模板与类模板
class 类模板名private://类内成员声明class Apublic:A(T val):a(val){}private:T a;return 0;运行结果:注意:类模板中的成员函数若是放在类外定义时,需要加模板参数列表。return 0;
329 0
|
存储 编译器 程序员
c++的类(附含explicit关键字,友元,内部类)
本文介绍了C++中类的核心概念与用法,涵盖封装、继承、多态三大特性。重点讲解了类的定义(`class`与`struct`)、访问限定符(`private`、`public`、`protected`)、类的作用域及成员函数的声明与定义分离。同时深入探讨了类的大小计算、`this`指针、默认成员函数(构造函数、析构函数、拷贝构造、赋值重载)以及运算符重载等内容。 文章还详细分析了`explicit`关键字的作用、静态成员(变量与函数)、友元(友元函数与友元类)的概念及其使用场景,并简要介绍了内部类的特性。
503 0
|
编译器 C++ 开发者
【C++篇】深度解析类与对象(下)
在上一篇博客中,我们学习了C++的基础类与对象概念,包括类的定义、对象的使用和构造函数的作用。在这一篇,我们将深入探讨C++类的一些重要特性,如构造函数的高级用法、类型转换、static成员、友元、内部类、匿名对象,以及对象拷贝优化等。这些内容可以帮助你更好地理解和应用面向对象编程的核心理念,提升代码的健壮性、灵活性和可维护性。
|
编译器 C语言 C++
类和对象的简述(c++篇)
类和对象的简述(c++篇)
|
设计模式 安全 C++
【C++进阶】特殊类设计 && 单例模式
通过对特殊类设计和单例模式的深入探讨,我们可以更好地设计和实现复杂的C++程序。特殊类设计提高了代码的安全性和可维护性,而单例模式则确保类的唯一实例性和全局访问性。理解并掌握这些高级设计技巧,对于提升C++编程水平至关重要。
312 16
|
安全 C++
【c++】继承(继承的定义格式、赋值兼容转换、多继承、派生类默认成员函数规则、继承与友元、继承与静态成员)
本文深入探讨了C++中的继承机制,作为面向对象编程(OOP)的核心特性之一。继承通过允许派生类扩展基类的属性和方法,极大促进了代码复用,增强了代码的可维护性和可扩展性。文章详细介绍了继承的基本概念、定义格式、继承方式(public、protected、private)、赋值兼容转换、作用域问题、默认成员函数规则、继承与友元、静态成员、多继承及菱形继承问题,并对比了继承与组合的优缺点。最后总结指出,虽然继承提高了代码灵活性和复用率,但也带来了耦合度高的问题,建议在“has-a”和“is-a”关系同时存在时优先使用组合。
1041 6
|
编译器 C++
类和对象(中 )C++
本文详细讲解了C++中的默认成员函数,包括构造函数、析构函数、拷贝构造函数、赋值运算符重载和取地址运算符重载等内容。重点分析了各函数的特点、使用场景及相互关系,如构造函数的主要任务是初始化对象,而非创建空间;析构函数用于清理资源;拷贝构造与赋值运算符的区别在于前者用于创建新对象,后者用于已存在的对象赋值。同时,文章还探讨了运算符重载的规则及其应用场景,并通过实例加深理解。最后强调,若类中存在资源管理,需显式定义拷贝构造和赋值运算符以避免浅拷贝问题。
|
存储 编译器 C++
类和对象(上)(C++)
本篇内容主要讲解了C++中类的相关知识,包括类的定义、实例化及this指针的作用。详细说明了类的定义格式、成员函数默认为inline、访问限定符(public、protected、private)的使用规则,以及class与struct的区别。同时分析了类实例化的概念,对象大小的计算规则和内存对齐原则。最后介绍了this指针的工作机制,解释了成员函数如何通过隐含的this指针区分不同对象的数据。这些知识点帮助我们更好地理解C++中类的封装性和对象的实现原理。