C++编程思想深度解析

需积分: 10 12 浏览量更新于2024-07-31 收藏 3.16MB PDF 举报

"C++编程思想 thinking in C++" 《Thinking in C++》是C++编程领域中一本经典的著作，作者深入浅出地探讨了C++语言的核心概念和编程思想。这本书以其清晰的表述和丰富的实例深受程序员们的喜爱，被誉为学习C++的绝佳参考资料。在C++中，"编程思想"不仅涵盖了语法层面的知识，还包括设计模式、面向对象编程（OOP）、泛型编程（Generic Programming）等高级主题。书中对这些内容进行了详细的阐述，帮助读者建立起坚实的基础，并理解如何利用C++的强大功能来解决实际问题。版本历史部分显示，作者在不断更新和完善这本书，例如TICA9版完成了STL算法章节的大量工作，这个章节需要大量的研究和思考，因为STL（Standard Template Library，标准模板库）是C++中一个复杂且强大的工具。STL容器章节在TICA8版时完成，包含了如vector、list、map等常见容器的使用和实现原理。而在TICA7版，字符串章节被修改，字符串在C++中是重要的一部分，处理不当可能会引发各种问题。TICA6版增加了字符串章节，虽然仍需完善，但已经具备了良好的结构。此外，STL算法章节的基本框架已经建立，只需要填充具体内容。作者在每个版本间都有旅行和研讨会等活动，但依然保持对书籍工作的专注。在C++中，复制赋值操作符`=`是一个关键的概念，因为它涉及到对象的深拷贝和浅拷贝。书中可能有专门的章节讨论如何区分不同的赋值操作形式，以及避免使用非标准的`strlwr()`函数，这有助于确保代码的兼容性和可移植性。模板（Templates）是C++的一个强大特性，它们允许创建泛型代码，可以应用于多种数据类型，是泛型编程的基础。书中"高级模板"章节的扩展，意味着作者会深入讲解模板的高级用法，如模板元编程等。《Thinking in C++》是一本全面而深入的C++教程，它涵盖了从基础到高级的广泛主题，包括C++的面向对象特性、STL的使用、模板的深度探索以及编程的最佳实践。通过阅读此书，读者可以提升C++编程技能，理解C++的设计哲学，并学会如何运用这些思想解决实际编程问题。

Preface 16

http://www.BruceEckel.com. [Note: the CD will not be available until late Fall 98, at the

earliest – watch the Web site for updates]

Learning C++

I clawed my way into C++ from exactly the same position as I expect the readers of this book

will: As a C programmer with a very no-nonsense, nuts-and-bolts attitude about programming.

Worse, my background and experience was in hardware-level embedded programming, where

C has often been considered a high-level language and an inefficient overkill for pushing bits

around. I discovered later that I wasn’ t even a very good C programmer, hiding my ignorance

of structures, malloc( ) & free( ), setjmp( ) & longjmp( ), and other “sophisticated” concepts,

scuttling away in shame when the subjects came up in conversation rather than reaching out

for new knowledge.

When I began my struggle to understand C++, the only decent book was Stroustrup’ s self-

professed “expert’ s guide,

” so I was left to simplify the basic concepts on my own. This

resulted in my first C++ book,

which was essentially a brain dump of my experience. That

was designed as a reader’ s guide, to bring programmers into C and C++ at the same time.

Both editions

of the book garnered an enthusiastic response and I still feel it is a valuable

resource.

At about the same time that Using C++ came out, I began teaching the language. Teaching

C++ has become my profession; I’ ve seen nodding heads, blank faces, and puzzled

expressions in audiences all over the world since 1989. As I began giving in-house training

with smaller groups of people, I discovered something during the exercises. Even those

people who were smiling and nodding were confused about many issues. I found out, by

chairing the C++ track at the Software Development Conference for the last three years, that I

and other speakers tended to give the typical audience too many topics, too fast. So eventually,

through both variety in the audience level and the way that I presented the material, I would

end up losing some portion of the audience. Maybe it’ s asking too much, but because I am

one of those people resistant to traditional lecturing (and for most people, I believe, such

resistance results from boredom), I wanted to try to keep everyone up to speed.

For a time, I was creating a number of different presentations in fairly short order. Thus, I

ended up learning by experiment and iteration (a technique that also works well in C++

program design). Eventually I developed a course using everything I had learned from my

teaching experience, one I would be happy giving for a long time. It tackles the learning

Bjarne Stroustrup, The C++ Programming Language, Addison-Wesley, 1986 (first edition).

Using C++, ibid.

Using C++ and C++ Inside & Out, ibid.

Preface 17

problem in discrete, easy-to-digest steps and for a hands-on seminar (the ideal learning

situation), there are exercises following each of the short lessons.

This book developed over the course of two years, and the material in this book has been

road-tested in many forms in many different seminars. The feedback that I’ ve gotten from

each seminar has helped me change and refocus the material until I feel it works well as a

teaching medium. But it isn’ t just a seminar handout — I tried to pack as much information as

I could within these pages, and structure it to draw you through, onto the next subject. More

than anything, the book is designed to serve the solitary reader, struggling with a new

programming language.

Goals

My goals in this book are to:

1. Present the material a simple step at a time, so the reader can easily digest

each concept before moving on.

2. Use examples that are as simple and short as possible. This sometimes

prevents me from tackling “real-world” problems,

but I’ ve found that beginners are usually happier when they can understand

every detail of an example rather than being impressed by the scope of the

problem it solves. Also, there’ s a severe limit to the amount of code that can

be absorbed in a classroom situation. For this I will no doubt receive

criticism for using “toy examples,” but I’ m willing to accept that in favor of

producing something pedagogically useful. Those who want more complex

examples can refer to the later chapters of C++ Inside & Out.

3. Carefully sequence the presentation of features so that you aren’ t seeing

something you haven’ t been exposed to. Of course, this isn’ t always

possible; in those situations, a brief introductory description will be given.

4. Give you what I think is important for you to understand about the language,

rather than everything I know. I believe there is an “information importance

hierarchy,” and there are some facts that 95% of programmers will never

need to know, but would just confuse people and add to their perception of

the complexity of the language — and C++ is now considered to be more

complex than ADA! To take an example from C, if you memorize the

operator precedence table (I never did) you can write clever code. But if

you have to think about it, it will confuse the reader/maintainer of that code.

Ibid.

Preface 18

So forget about precedence, and use parentheses when things aren’ t clear.

This same attitude will be taken with some information in the C++ language,

which I think is more important for compiler writers than for programmers.

5. Keep each section focused enough so the lecture time — and the time

between exercise periods — is small. Not only does this keep the audience’

minds more active and involved during a hands-on seminar, but it gives the

reader a greater sense of accomplishment.

6. Provide the reader with a solid foundation so they can understand the issues

well enough to move on to more difficult coursework and books.

7. I’ ve endeavored not to use any particular vendor’ s version of C++ because,

for learning the language, I don’ t feel like the details of a particular

implementation are as important as the language itself. Most vendors’

documentation concerning their own implementation specifics is adequate.

Chapters

C++ is a language where new and different features are built on top of an existing syntax.

(Because of this it is referred to as a hybrid object-oriented programming language.) As more

people have passed through the learning curve, we’ ve begun to get a feel for the way C

programmers move through the stages of the C++ language features. Because it appears to be

the natural progression of the C-trained mind, I decided to understand and follow this same

path, and accelerate the process by posing and answering the questions that came to me as I

learned the language and that came from audiences as I taught it.

This course was designed with one thing in mind: the way people learn the C++ language.

Audience feedback helped me understand which parts were difficult and needed extra

illumination. In the areas where I got ambitious and included too many features all at once, I

came to know — through the process of presenting the material — that if you include a lot of

new features, you have to explain them all, and the student’ s confusion is easily compounded.

As a result, I’ ve taken a great deal of trouble to introduce the features as few at a time as

possible; ideally, only one at a time per chapter.

The goal, then, is for each chapter to teach a single feature, or a small group of associated

features, in such a way that no additional features are relied upon. That way you can digest

each piece in the context of your current knowledge before moving on. To accomplish this, I

leave many C features in place much longer than I would prefer. For example, I would like to

be using the C++ iostreams IO library right away, instead of using the printf( ) family of

functions so familiar to C programmers, but that would require introducing the subject

prematurely, and so many of the early chapters carry the C library functions with them. This

is also true with many other features in the language. The benefit is that you, the C

programmer, will not be confused by seeing all the C++ features used before they are

Preface 19

explained, so your introduction to the language will be gentle and will mirror the way you

will assimilate the features if left to your own devices.

Here is a brief description of the chapters contained in this book.

(0) The evolution of objects. When projects became too big and too complicated to easily

maintain, the “software crisis” was born, saying, “We can’ t get projects done, and if we can

they’ re too expensive!” This precipitated a number of responses, which are discussed in this

chapter along with the ideas of object-oriented programming (OOP) and how it attempts to

solve the software crisis. You’ ll also learn about the benefits and concerns of adopting the

language and suggestions for moving into the world of C++.

(1) Data abstraction. Most features in C++ revolve around this key concept: the ability to

create new data types. Not only does this provide superior code organization, but it lays the

ground for more powerful OOP abilities. You’ ll see how this idea is facilitated by the simple

act of putting functions inside structures, the details of how to do it, and what kind of code it

creates.

(2) Hiding the implementation. You can decide that some of the data and functions in your

structure are unavailable to the user of the new type by making them private. This means you

can separate the underlying implementation from the interface that the client programmer sees,

and thus allow that implementation to be easily changed without affecting client code. The

keyword class is also introduced as a fancier way to describe a new data type, and the

meaning of the word “object” is demystified (it’ s a variable on steroids).

(3) Initialization & cleanup. One of the most common C errors results from uninitialized

variables. The constructor in C++ allows you to guarantee that variables of your new data

type (“objects of your class”) will always be properly initialized. If your objects also require

some sort of cleanup, you can guarantee that this cleanup will always happen with the C++

destructor.

(4) Function overloading & default arguments. C++ is intended to help you build big,

complex projects. While doing this, you may bring in multiple libraries that use the same

function name, and you may also choose to use the same name with different meanings within

a single library. C++ makes this easy with function overloading, which allows you to reuse

the same function name as long as the argument lists are different. Default arguments allow

you to call the same function in different ways by automatically providing default values for

some of your arguments.

(5) Introduction to iostreams. One of the original C++ libraries — the one that provides the

essential I/O facility — is called iostreams. Iostreams is intended to replace C’ s STDIO.H

with an I/O library that is easier to use, more flexible, and extensible — you can adapt it to

work with your new classes. This chapter teaches you the ins and outs of how to make the

best use of the existing iostream library for standard I/O, file I/O, and in-memory formatting.

(6) Constants. This chapter covers the const and volatile keywords that have additional

meaning in C++, especially inside classes. It also shows how the meaning of const varies

inside and outside classes and how to create compile-time constants in classes.

Preface 20

(7) Inline functions. Preprocessor macros eliminate function call overhead, but the

preprocessor also eliminates valuable C++ type checking. The inline function gives you all

the benefits of a preprocessor macro plus all the benefits of a real function call.

(8) Name control. Creating names is a fundamental activity in programming, and when a

project gets large, the number of names can be overwhelming. C++ allows you a great deal of

control over names: creation, visibility, placement of storage, and linkage. This chapter shows

how names are controlled using two techniques. First, the static keyword is used to control

visibility and linkage, and its special meaning with classes is explored. A far more useful

technique for controlling names at the global scope is C++’ s namespace feature, which

allows you to break up the global name space into distinct regions.

(9) References & the copy-constructor. C++ pointers work like C pointers with the

additional benefit of stronger C++ type checking. There’ s a new way to handle addresses;

from Algol and Pascal, C++ lifts the reference which lets the compiler handle the address

manipulation while you use ordinary notation. You’ ll also meet the copy-constructor, which

controls the way objects are passed into and out of functions by value. Finally, the C++

pointer-to-member is illuminated.

(10) Operator overloading. This feature is sometimes called “syntactic sugar.” It lets you

sweeten the syntax for using your type by allowing operators as well as function calls. In this

chapter you’ ll learn that operator overloading is just a different type of function call and how

to write your own, especially the sometimes-confusing uses of arguments, return types, and

making an operator a member or friend.

(11) Dynamic object creation. How many planes will an air-traffic system have to handle?

How many shapes will a CAD system need? In the general programming problem, you can’ t

know the quantity, lifetime or type of the objects needed by your running program. In this

chapter, you’ ll learn how C++’ s new and delete elegantly solve this problem by safely

creating objects on the heap.

(12) Inheritance & composition. Data abstraction allows you to create new types from

scratch; with composition and inheritance, you can create new types from existing types. With

composition you assemble a new type using other types as pieces, and with inheritance you

create a more specific version of an existing type. In this chapter you’ ll learn the syntax, how

to redefine functions, and the importance of construction and destruction for inheritance &

composition.

(13) Polymorphism & virtual functions. On your own, you might take nine months to

discover and understand this cornerstone of OOP. Through small, simple examples you’ ll see

how to create a family of types with inheritance and manipulate objects in that family through

their common base class. The virtual keyword allows you to treat all objects in this family

generically, which means the bulk of your code doesn’ t rely on specific type information.

This makes your programs extensible, so building programs and code maintenance is easier

and cheaper.

(14) Templates & container classes. Inheritance and composition allow you to reuse object

code, but that doesn’ t solve all your reuse needs. Templates allow you to reuse source code by

剩余1049页未读，继续阅读

wztbgenit

粉丝: 0
资源: 3

C++编程思想深度解析

深入理解C++：Thinking in C++第二版解析

C++编程思想精要：Thinking in C++ 2nd Edition 概览

《Thinking in C++》第二版卷一：编程思想解析

c++编程思想 thinking in c++

C++编程思想 Thinking in C++

c++编程思想thinking in c ++,c++编程的经典书籍，希望对大家有益。

C++编程思想 thinking c++

C++编程思想-Thinking in C++

C++编程思想.Thinking in C++

C++编程思想（Thinking In C++）

最新资源