ModernC++Design，英文原版_ModernLensDesign资源-CSDN文库

共4个文件

pdf：4个

3星 · 超过75%的资源需积分: 10 126 浏览量 2011-07-29 18:59:25 上传评论收藏 556KB RAR 举报

资源推荐

资源详情

资源评论

收起资源包目录

Modern C++ Design.rar （4个子文件）

Modern C++ Design

alexan01.pdf 91KB

alexan08.pdf 142KB

alexan07.pdf 214KB

alexan11.pdf 206KB

157

Smart Pointers

Hecatombs of code and rivers of ink have been dedicated to smart pointers by program-

mers and writers around the world. Perhaps the most popular, intricate, and powerful

C idiom, smart pointers are interesting in that they combine many syntactic and se-

mantic issues. This chapter discusses smart pointers, from their simplest aspects to their

most complex ones and from the most obvious errors in implementing them to the subtlest

ones—some of which also happen to be the most gruesome.

In brief, smart pointers are C objects that simulate simple pointers by implement-

ing operator-> and the unary operator*. In addition to sporting pointer syntax and

semantics, smart pointers often perform useful tasks—such as memory management or

locking—under the covers, thus freeing the application from carefully managing the life-

time of pointed-to objects.

This chapter not only discusses smart pointers but also implements a SmartPtr class

template. SmartPtr is designed around policies (see Chapter 1), and the result is a smart

pointer that has the exact levels of safety, efﬁciency, and ease of use that you want.

After reading this chapter, you will be an expert in smart pointer issues such as the

following:

• The advantages and disadvantages of smart pointers

• Ownership management strategies

• Implicit conversions

• Tests and comparisons

• Multithreading issues

This chapter implements a generic SmartPtr class template. Each section presents one

implementation issue in isolation. At the end, the implementation puts all the pieces to-

gether. In addition to understanding the design rationale of SmartPtr, you will know how

to use, tweak, and extend it.

7.1 Smart Pointers 101

So what’s a smart pointer? A smart pointer is a C class that mimics a regular pointer

in syntax and some semantics, but it does more. Because smart pointers to different type

07-A1568 01/23/2001 12:38 PM Page 157

158

Smart Pointers Chapter 7

of objects tend to have a lot of code in common, almost all good-quality smart pointers in

existence are templated by the pointee type, as you can see in the following code:

template <class T>

class SmartPtr

{

public:

explicit SmartPtr(T* pointee) : pointee_(pointee);

SmartPtr& operator=(const SmartPtr& other);

~SmartPtr();

T& operator*() const

{

...

return *pointee_;

}

T* operator->() const

{

...

return pointee_;

}

private:

T* pointee_;

...

};

SmartPtr<T>

aggregates a pointer to T in its member variable pointee_. That’s what

most smart pointers do. In some cases, a smart pointer might aggregate some handles to

data and compute the pointer on the ﬂy.

The two operators give SmartPtrToSomething pointer-like syntax and semantics. That

is, you can write

class Widget

{

public:

void Fun();

};

SmartPtr<Widget> sp(new Something);

sp->Fun();

(*sp).Fun();

Aside from the deﬁnition of sp, nothing reveals it as not being a pointer. This is the mantra

of smart pointers: You can replace pointer deﬁnitions with smart pointer deﬁnitions with-

out incurring major changes to your application’s code. You thus get extra goodies with

ease. Minimizing code changes is very appealing and vital for getting large applications to

use smart pointers. As you will soon see, however, smart pointers are not a free lunch.

7.2 The Deal

But what’s the deal with smart pointers? you might ask. What do you gain by replacing

simple pointers with smart pointers? The explanation is simple. Smart pointers have value

semantics, whereas some simple pointers do not.

07-A1568 01/23/2001 12:38 PM Page 158

Section 7.2 The Deal 159

An object with value semantics is an object that you can copy and assign to. Type

int is

the perfect example of a ﬁrst-class object. You can create, copy, and change integer values

freely. A pointer that you use to iterate in a buffer also has value semantics—you initialize

it to point to the beginning of the buffer, and you bump it until you reach the end. Along

the way, you can copy its value to other variables to hold temporary results.

With pointers that hold values allocated with new, however, the story is very different.

Once you have written

Widget* p = new Widget;

the variable p not only points to, but also owns, the memory allocated for the Widget object.

This is because later you must issue delete p to ensure that the Widget object is destroyed

and its memory is released. If in the line after the line just shown you write

p = 0; // assign something else to p

you lose ownership of the object previously pointed to by p, and you have no chance at all

to get a grip on it again. You have a resource leak, and resource leaks never help.

Furthermore, when you copy

p into another variable, the compiler does not automati-

cally manage the ownership of the memory to which the pointer points. All you get is two

raw pointers pointing to the same object, and you have to track them even more carefully

because double deletions are even more catastrophic than no deletion. Consequently,

pointers to allocated objects do not have value semantics—you cannot copy and assign to

them at your will.

Smart pointers can be of great help in this area. Most smart pointers offer ownership

management in addition to pointer-like behavior. Smart pointers can ﬁgure out how own-

ership evolves, and their destructors can release the memory according to a well-deﬁned

strategy. Many smart pointers hold enough information to take full initiative in releasing

the pointed-to object.

Smart pointers may manage ownership in various ways, each appropriate to a category

of problems. Some smart pointers transfer ownership automatically: After you copy a

smart pointer to an object, the source smart pointer becomes null, and the destination

points to (and holds ownership of) the object. This is the behavior implemented by the

standard-provided

std::auto_ptr. Other smart pointers implement reference counting:

They track the total count of smart pointers that point to the same object, and when this

count goes down to zero, they delete the pointed-to object. Finally, some others duplicate

their pointed-to object whenever you copy them.

In short, in the smart pointers’ world, ownership is an important topic. By providing

ownership management, smart pointers are able to support integrity guarantees and full

value semantics. Because ownership has much to do with constructing, copying, and de-

stroying smart pointers, it’s easy to ﬁgure out that these are the most vital functions of a

smart pointer.

The following few sections discuss various aspects of smart pointer design and imple-

mentation. The goal is to render smart pointers as compatible with raw pointers as pos-

sible, but not closer. It’s a contradictory goal: After all, if your smart pointers behave exactly

like dumb pointers, they are dumb pointers.

07-A1568 01/23/2001 12:38 PM Page 159

160

Smart Pointers Chapter 7

In implementing compatibility between smart pointers and raw pointers, there is a thin

line between nicely ﬁlling compatibility checklists and paving the way toward chaos. You

will ﬁnd that adding seemingly worthwhile features might expose the clients to costly

risks. Much of the craft of implementing good smart pointers consists of carefully balanc-

ing their set of features.

7.3 Smart Pointers’ Storage

To start, let’s ask a fundamental question about smart pointers. Is pointee_’s type neces-

sarily T*? If not, what else could it be? In generic programming, you should always ask

yourself questions like these. Each type that’s hardcoded in a piece of generic code de-

creases the genericity of the code. Hardcoded types are to generic code what magic con-

stants are to regular code.

In several situations, it is worthwhile to allow customizing the pointee type. One situa-

tion is when you deal with nonstandard pointer modiﬁers. In the 16-bit Intel 80x86 days,

you could qualify pointers with modiﬁers like __near, __far, and __huge. Other seg-

mented memory architectures use similar modiﬁers.

Another situation is when you want to layer smart pointers. What if you have a

Legacy-

SmartPtr<T>

smart pointer implemented by someone else, and you want to enhance

it? Would you derive from it? That’s a risky decision. It’s better to wrap the legacy smart

pointer into a smart pointer of your own. This is possible because the inner smart pointer

supports pointer syntax. From the outer smart pointer’s viewpoint, the pointee type is not

T* but LegacySmartPtr<T>.

There are interesting applications of smart pointer layering, mainly because of the

mechanics of operator->. When you apply operator-> to a type that’s not a built-in

pointer, the compiler does an interesting thing. After looking up and applying the user-

deﬁned operator-> to that type, it applies operator-> again to the result. The compiler

keeps doing this recursively until it reaches a pointer to a built-in type, and only then pro-

ceeds with member access. It follows that a smart pointer’s operator-> does not have to

return a pointer. It can return an object that in turn implements operator->, without chang-

ing the use syntax.

This leads to a very interesting idiom: pre- and postfunction calls (Stroustrup 2000). If

you return an object of type

PointerType by value from operator->, the sequence of exe-

cution is as follows:

1. Constructor of

PointerType

2. PointerType::operator-> called; likely returns a pointer to an object of type

PointeeType

3. Member access for PointeeType—likely a function call

4. Destructor of PointerType

In a nutshell, you have a nifty way of implementing locked function calls. This idiom has

broad uses with multithreading and locked resource access. You can have PointerType’s

constructor lock the resource, and then you can access the resource; ﬁnally, Pointer Type’s

destructor unlocks the resource.

The generalization doesn’t stop here. The syntax-oriented “pointer” part might some-

07-A1568 01/23/2001 12:38 PM Page 160

Section 7.4 Smart Pointer Member Functions 161

times become dim in comparison with the powerful resource management techniques that

are included in smart pointers. It follows that, in rare cases, smart pointers could drop the

pointer syntax. An object that does not deﬁne

operator-> and operator* violates the

deﬁnition of a smart pointer, but there are objects that do deserve smart pointer–like treat-

ment, although they are not, strictly speaking, smart pointers.

Look at real-world APIs and applications. Many operating systems foster handles as

accessors to certain internal resources, such as windows, mutexes, or devices. Handles are

intentionally obfuscated pointers; one of their purposes is to prevent their users from ma-

nipulating critical operating system resources directly. Most of the time, handles are inte-

gral values that are indices in a hidden table of pointers. The table provides the additional

level of indirection that protects the inner system from the application programmers. Al-

though they don’t provide an operator->, handles resemble pointers in semantics and in

the way they are managed.

For such a smart resource, it does not make sense to provide operator-> or

operator*. However, you do take advantage of all the resource management techniques

that are speciﬁc to smart pointers.

To generalize the type universe of smart pointers, we distinguish three potentially dis-

tinct types in a smart pointer:

• The storage type. This is the type of

pointee_. By “default”—in regular smart pointers—

it is a raw pointer.

• The pointer type. This is the type returned by operator->. It can be different from the

storage type if you want to return a proxy object instead of just a pointer. (You will ﬁnd

an example of using proxy objects later in this chapter.)

• The reference type. This is the type returned by operator*.

It would be useful if

SmartPtr supported this generalization in a ﬂexible way. Thus, the

three types mentioned here ought to be abstracted in a policy called Storage.

In conclusion, smart pointers can, and should, generalize their pointee type. To do

this, SmartPtr abstracts three types in a Storage policy: the stored type, the pointer type,

and the reference type. Not all types necessarily make sense for a given SmartPtr instanti-

ation. Therefore, in rare cases (handles), a policy might disable access to operator-> or

operator* or both.

7.4 Smart Pointer Member Functions

Many existing smart pointer implementations allow operations through member func-

tions, such as Get for accessing the pointee object, Set for changing it, and Release for

taking over ownership. This is the obvious and natural way of encapsulating SmartPtr’s

functionality.

However, experience has proven that member functions are not very suitable for smart

pointers. The reason is that the interaction between member function calls for the smart

pointer for the pointed-to object can be extremely confusing.

Suppose, for instance, that you have a Printer class with member functions such as

Acquire and Release. With Acquire you take ownership of the printer so that no other

application prints to it, and with Release you relinquish ownership. As you use a smart

07-A1568 01/23/2001 12:38 PM Page 161

评论收藏

内容反馈

JayKay-X

2014-08-29

很赞,一直找不到完整的中文版,只能看原文了
bmewxd

2020-06-17

章节不全，只有1 7 8 11

zhangyumeng123456

粉丝: 0
资源: 12

Modern C++ Design，英文原版

最新资源

Modern C++ Design，英文原版

Modern C++ Design(中文版+英文版)

modern c++ design 中文+英文版

Modern C++ Design 中文版英文版

modern c++ design中文版+英文版+完整书签

Modern C++ Design中文版

Modern C++ Design

Modern C++ Design: Generic Programming and Design Patterns Applied

Modern C++ Design Generic Programming and Design Patterns Applied epub

Effective Modern C++_英文原版_超高清_带书签_pdf

Modern C++ Design英文版.pdf

ModernC++Design

Modern+C++Design

Modern c++ design 简体中文、繁体中文和英文

Modern C++ Design Generic Programming and Design Patterns Applied .pdf

Modern C++ Design Generic Programming and Desig

Modern C++ Design PDF格式

Design Patterns in Modern C++

C＋＋之Modern C++ Design.pdf

最新资源