<Item 15> Provide access to raw resources in resource-managing classes

1、You need a way to convert an object of the RAII class (in this case, tr1::shared_ptr) into the raw resource it contains (e.g., the underlying Investment*). There are two general ways to do it: explicit conversion and implicit conversion.

tr1::shared_ptr and auto_ptr both offer a get member function to perform an explicit conversion, i.e., to return (a copy of) the raw pointer inside the smart pointer object:

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

Like virtually all smart pointer classes, TR1::shared_ptr and auto_ptr also overload the pointer dereferencing operators (operator-> and operator*), and this allows implicit conversion to the underlying raw pointers:

class Investment {                         // root class for a hierarchy
public: // of investment types
bool isTaxFree() const;
...
};
Investment* createInvestment(); // factory function
std::tr1::shared_ptr<Investment> // have tr1::shared_ptr
pi1(createInvestment()); // manage a resource bool taxable1 = !(pi1->isTaxFree()); // access resource
// via operator->
...
std::auto_ptr<Investment> pi2(createInvestment()); // have auto_ptr
// manage a
// resource bool taxable2 = !((*pi2).isTaxFree()); // access resource
// via operator*
...

2、The Font class could offer an explicit conversion function such as get:

class Font {
public:
...
FontHandle get() const { return f; } // explicit conversion function
...
};

Unfortunately, this would require that clients call get every time they want to communicate with the API:

void changeFontSize(FontHandle f, int newSize);     // from the C API
Font f(getFont());
int newFontSize;
... changeFontSize(f.get(), newFontSize); // explicitly convert
// Font to FontHandle

Some programmers might find the need to explicitly request such conversions off-putting enough to avoid using the class. That, in turn, would increase the chances of leaking fonts, the very thing the Font class is designed to prevent.

The alternative is to have Font offer an implicit conversion function to its FontHandle:

class Font {
public:
...
operator FontHandle() const { return f; } // implicit conversion function
...
};

That makes calling into the C API easy and natural:  但是隐式转换可能会偷偷造成不想要的转换

Font f(getFont());
int newFontSize;
... changeFontSize(f, newFontSize); // implicitly convert Font
// to FontHandle

3、Often, an explicit conversion function like get is the preferable path, because it minimizes the chances of unintended type conversions. Sometime, however, the naturalness of use arising from implicit type conversions will tip the scales in that direction.但是一切以Item18为原则。Furthermore, some RAII classes combine true encapsulation of implementation with very loose encapsulation of the underlying resource. For example, tr1::shared_ptr encapsulates all its reference-counting machinery, but it still offers easy access to the raw pointer it contains. Like most well-designed classes, it hides what clients don't need to see, but it makes available those things that clients honestly need to access.

4、Things to Remember

  • APIs often require access to raw resources, so each RAII class should offer a way to get at the resource it manages.

  • Access may be via explicit conversion or implicit conversion. In general, explicit conversion is safer, but implicit conversion is more convenient for clients.

<Item 16>Use the same form in corresponding uses of new and delete.

5、When you employ a new expression (i.e., dynamic creation of an object via a use of new), two things happen. First, memory is allocated (via a function named operator new—see Items 49 and 51). Second, one or more constructors are called for that memory. When you employ a delete expression (i.e., use delete), two other things happen: one or more destructors are called for the memory, then the memory is deallocated (via a function named operator delete—see Item 51).

6、 In particular, the memory for an array usually includes the size of the array, thus making it easy for delete to know how many destructors to call. The memory for a single object lacks this information. This is just an example, of course. Compilers aren't required to implement things this way, though many do.

7、This is a particularly important rule to bear in mind when you are writing a class containing a pointer to dynamically allocated memory and also offering multiple constructors, because then you must be careful to use the same form of new in all the constructors to initialize the pointer member. If you don't, how will you know what form of delete to use in your destructor?

8、This rule is also noteworthy for the typedef-inclined, because it means that a typedef's author must document which form of delete should be employed when new is used to conjure up objects of the typedef type. For example, consider this typedef:

typedef std::string AddressLines[];   // a person's address has 4 lines,
// each of which is a string

Because AddressLines is an array, this use of new,

std::string *pal = new AddressLines;   // note that "new AddressLines"
// returns a string*, just like
// "new string[4]" would

must be matched with the array form of delete:

delete pal;                           // undefined!
delete [] pal; // fine

delete 和delete []用错了的话,The result is undefined。使用string和vector来避免动态分配数组。

9、Things to Remember

  • If you use [] in a new expression, you must use [] in the corresponding delete expression. If you don't use [] in a new expression, you mustn't use [] in the corresponding delete expression.

<Item 17>Store newed objects in smart pointers in standalone statements.

10、C++的编译器相比java和C#给予更多语句执行顺序的自由度,exception可能打断正常的执行流程,导致资源泄露

int priority();
void processWidget(std::tr1::shared_ptr<Widget> pw, int priority);
processWidget(new Widget, priority()); //不会编译,没有定义好的隐式转换
processWidget(std::tr1::shared_ptr<Widget>(new Widget), priority());
  1. Execute "new Widget".

  2. Call priority.

  3. Call the tr1::shared_ptr constructor.

可以修正如下

std::tr1::shared_ptr<Widget> pw(new Widget);  // store newed object
// in a smart pointer in a
// standalone statement processWidget(pw, priority()); // this call won't leak

11、Things to Remember

  • Store newed objects in smart pointers in standalone statements. Failure to do this can lead to subtle resource leaks when exceptions are thrown.

<Effective C++>读书摘要--Resource Management<二>的更多相关文章

  1. <Effective C++>读书摘要--Resource Management<一>

    1.除了内存资源以外,Other common resources include file descriptors, mutex locks, fonts and brushes in graphi ...

  2. <Effective C++>读书摘要--Implementations<二>

    <Item29> Strive for exception-safe code. 1.如下面的代码 class PrettyMenu { public: ... void changeBa ...

  3. <Effective C++>读书摘要--Designs and Declarations<一>

    <Item 18> Make interfaces easy to use correctly and hard to use incorrectly 1.That being the c ...

  4. <Effective C++>读书摘要--Inheritance and Object-Oriented Design<二>

    <Item 36> Never redefine an inherited non-virtual function 1.如下代码通过不同指针调用同一个对象的同一个函数会产生不同的行为Th ...

  5. <Effective C++>读书摘要--Designs and Declarations<二>

    <Item 20> Prefer pass-by-reference-to-const to pass-by-value 1.By default, C++ passes objects ...

  6. <Effective C++>读书摘要--Ctors、Dtors and Assignment Operators<二>

    <Item 9> Never call virtual functions during construction or destruction 1.you shouldn't call ...

  7. <Effective C++>读书摘要--Templates and Generic Programming<一>

    1.The initial motivation for C++ templates was straightforward: to make it possible to create type-s ...

  8. <Effective C++>读书摘要--Implementations<一>

    1.For the most part, coming up with appropriate definitions for your classes (and class templates) a ...

  9. <Effective C++>读书摘要--Designs and Declarations<三>

    <Item 22> Declare data members private 1.使数据成员private,保持了语法的一致性,client不会为访问一个数据成员是否需要使用括号进行函数调 ...

随机推荐

  1. Hbase过滤器

    Hbase过滤器简介 HBase的基本API,包括增.删.改.查等,增.删都是相对简单的操作,与传统的RDBMS相比,这里的查询操作略显苍白,只能根据特性的行键进行查询(Get)或者根据行键的范围来查 ...

  2. 『Python基础-9』元祖 (tuple)

    『Python基础-9』元祖 (tuple) 目录: 元祖的基本概念 创建元祖 将列表转化为元组 查询元组 更新元组 删除元组 1. 元祖的基本概念 元祖可以理解为,不可变的列表 元祖使用小括号括起所 ...

  3. 20154327 Exp3 免杀原理与实践

    实践内容 基础问题回答 (1)杀软是如何检测出恶意代码的? 杀毒软件主要靠特征码进行查杀,匹配到即为病毒. 还有通过云查杀,查看云端库中该文件是否属于恶意代码. 跟踪该程序运行起来是否存在恶意行为,来 ...

  4. 广州Uber优步司机奖励政策(1月4日~1月10日)

    滴快车单单2.5倍,注册地址:http://www.udache.com/ 如何注册Uber司机(全国版最新最详细注册流程)/月入2万/不用抢单:http://www.cnblogs.com/mfry ...

  5. 【POJ1733】Parity game

    [POJ1733]Parity game 题面 vjudge 题解 比较简单的分类并查集 将一个查询操作看作前缀和\(s_r-s_{l-1}\)的奇偶性 将每个点拆成一奇一偶然后分别连边即可 如果一个 ...

  6. springBoot 中webSocket 应用一

    <html> <head> <meta charset="UTF-8"> <title>websocket测试</title& ...

  7. letsencrypt证书-管理工具certbot

    目录 1. 安装certbot 2. certbot 介绍 3. 插件的具体使用 3.1 webroot 3.2 standalone 3.3 DNS plugins 3.4 manual 4. 证书 ...

  8. gdb 分析出错

    1 创建测试代码test.php <?php function test1(){ while(true){ sleep(1); } }echo getmypid() "\r\n&quo ...

  9. python版protobuf 安装

    转自:http://www.tuicool.com/articles/VfQfM3 1. 下载protobuf源代码(当前最新版本为:2.5.0) #cd /opt #wget https://pro ...

  10. SpringBoot入门(五)——自定义配置

    本文来自网易云社区 大部分比萨店也提供某种形式的自动配置.你可以点荤比萨.素比萨.香辣意大利比萨,或者是自动配置比萨中的极品--至尊比萨.在下单时,你并没有指定具体的辅料,你所点的比萨种类决定了所用的 ...