布鲁斯·埃克尔《Think in C++ 第2版》Volume1：面向对象编程入门

需积分: 9 68 浏览量更新于2024-07-15 收藏 1.54MB PDF 举报

"《思考C++第二版：卷1》是由著名编程作者Bruce Eckel所著的经典之作，这本书是根据官方网站的内容转换成的PDF版本。它涵盖了C++语言的深入剖析和高级编程思想，旨在帮助读者掌握面向对象编程的基础和实践技巧。该书共分为两卷，第一卷主要介绍C++的核心概念和设计原则。在《Thinking In C++ 2nd Edition Volume1》中，章节包括了对抽象进步的探讨，强调了对象具有接口和隐藏的实现，以及如何通过继承重用接口。作者还解释了is-a与is-like关系的区别，并介绍了通过多态实现对象的互换性。创建和销毁对象、异常处理以及错误处理等实用主题也得到了详尽讲解。作者提倡分析与设计阶段，将整个开发过程划分为五个阶段：制定计划、确定目标、构建核心、迭代使用场景和持续进化。书中强调了极限编程（Extreme Programming）的方法，如先编写测试、结对编程，这些都是提高代码质量和效率的重要策略。 C++之所以成功，部分原因在于其高效性和表达力，它能够帮助系统更易理解和表达。此外，作者还对比了C++与早期语言的差异，指出C++作为一种更好的编程语言，已经在学习曲线初期就展现出了优势。《Thinking In C++ 2nd Edition Volume1》是一本适合C++初学者和进阶者阅读的宝典，不仅传授语言知识，更注重培养良好的编程习惯和设计思维。通过阅读这本书，读者不仅能掌握C++语法，还能提升软件开发的策略和实践能力。" 这是一篇对《Thinking In C++ 2nd Edition Volume1》的详细概述，包括其主要内容、章节结构、核心概念以及作者倡导的编程方法论，为读者提供了一个全面的学习指南。

[ Viewing Hints ] [ Exercise Solutions ] [ Volume 2 ] [ Free Newsletter ]

[ Seminars

] [ Seminars on CD ROM ] [ Consulting ]

Thinking in C++, 2nd ed. Volume 1

[ Previous Chapter ] [ Table of Contents ] [ Index ] [ Next Chapter ]

Preface

Like any human language, C++ provides a way to express concepts. If successful,

this medium of expression will be significantly easier and more flexible than the

alternatives as problems grow larger and more complex.

You can’t just look at C++ as a collection of features; some of the features make no sense in isolation. You

can only use the sum of the parts if you are thinking about design, not simply coding. And to understand

C++ this way, you must understand the problems with C and with programming in general. This book

discusses programming problems, why they are problems, and the approach C++ has taken to solve such

problems. Thus, the set of features I explain in each chapter will be based on the way that I see a

particular type of problem being solved with the language. In this way I hope to move you, a little at a

time, from understanding C to the point where the C++ mindset becomes your native tongue.

Throughout, I’ll be taking the attitude that you want to build a model in your head that allows you to

understand the language all the way down to the bare metal; if you encounter a puzzle, you’ll be able to

feed it to your model and deduce the answer. I will try to convey to you the insights that have rearranged

my brain to make me start “thinking in C++.”

What’s new in the second edition

This book is a thorough rewrite of the first edition to reflect all of the changes introduced in C++ by the

finalization of the C++ Standard, and also to reflect what I’ve learned since writing the first edition. The

entire text present in the first edition has been examined and rewritten, sometimes removing old

examples, often changing existing examples and adding new ones, and adding many new exercises.

Significant rearrangement and re-ordering of the material took place to reflect the availability of better

tools and my improved understanding of how people learn C++. A new chapter was added which is a

rapid introduction to the C concepts and basic C++ features for those who don’t have the C background to

tackle the rest of the book. The CD ROM bound into the back of the book contains a seminar that is an

even gentler introduction to the C concepts necessary to understand C++ (or Java). It was created by

Chuck Allison for my company (MindView, Inc.), and it’s called “Thinking in C: Foundations for Java and

C++.” It introduces you to the aspects of C that are necessary for you to move on to C++ or Java, leaving

out the nasty bits that C programmers must deal with on a day-to-day basis but that the C++ and Java

languages steer you away from (or even eliminate, in the case of Java).

So the short answer to the question “what’s different in the 2

edition?” is: what isn’t brand new has been

rewritten, sometimes to the point where you wouldn’t recognize the original examples and material.

What’s in Volume 2 of this book

The completion of the C++ Standard also added a number of important new libraries, such as string and

the containers and algorithms in the Standard C++ Library, as well as new complexity in templates. These

and other more advanced topics have been relegated to Volume 2 of this book, including issues such as

multiple inheritance, exception handling, design patterns, and topics about building and debugging stable

systems.

How to get Volume 2

Just like the book you currently hold, Thinking in C++, Volume 2 is downloadable in its entirety from my

Web site at www.BruceEckel.com. You can find information on the Web site about the expected print

date of Volume 2.

The Web site also contains the source code for both of the books, along with updates and information

about other seminars-on-CD ROM that MindView, Inc. offers, public seminars, and in-house training,

consulting, mentoring, and walkthroughs.

Prerequisites

In the first edition of this book, I decided to assume that someone else had taught you C and that you have

at least a reading level of comfort with it. My primary focus was on simplifying what I found difficult: the

C++ language. In this edition I have added a chapter that is a rapid introduction to C, along with the

Thinking in C seminar-on-CD, but I am still assuming that you already have some kind of programming

experience. In addition, just as you learn many new words intuitively by seeing them in context in a novel,

it’s possible to learn a great deal about C from the context in which it is used in the rest of the book.

Learning C++

I clawed my way into C++ from exactly the same position I expect many of the readers of this book are in:

as a programmer with a very no-nonsense, nuts-and-bolts attitude about programming. Worse, my

background and experience was in hardware-level embedded programming, in which 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( ) and free( ),

setjmp( ) and longjmp( ), and other “sophisticated” concepts, scuttling away in shame when the

subjects came up in conversation instead of reaching out for new knowledge.

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

professed “expert’s guide,[1]

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

first C++ book,[2]

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[3]

of the book garnered

enthusiastic response.

At about the same time that Using C++ came out, I began teaching the language in seminars and

presentations. Teaching C++ (and later, Java) became 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 to 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 creating and chairing the

C++ and Java tracks at the Software Development Conference for many 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. It tackles

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

situation) there are exercises following each of the presentations. You can find out about my public

seminars at www.BruceEckel.com, and you can also learn about the seminars that I’ve turned into CD

ROMs.

The first edition of 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 who is struggling with a new programming language.

Goals

My goals in this book are to:

1. Present the material one 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 often 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

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

producing something pedagogically useful.

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

that I know. I believe there is an “information importance hierarchy,” and there are some facts that

95 percent of programmers will never need to know and that would just confuse them and add to

their perception of the complexity of the language. 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. 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

reasonable. Not only does this keep the audience’s minds more active and involved during a hands-

on seminar, it gives the reader a greater sense of accomplishment.

6. Provide readers with a solid foundation so they can understand the issues well enough to move on to

more difficult coursework and books (in particular, Volume 2 of this book).

7. I’ve tried not to use any particular vendor’s version of C++ because, for learning the language, I

don’t think that 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 in which 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 pass through

the learning curve, we’ve begun to get a feel for the way programmers move through the stages of the C++

language features. Because it appears to be the natural progression of the procedurally-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 those questions that came from audiences as I

taught the language.

This course was designed with one thing in mind: to streamline the process of learning C++. Audience

feedback helped me understand which parts were difficult and needed extra illumination. In the areas in

which 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 major concept at a time per chapter.

The goal, then, is for each chapter to teach a single concept, or a small group of associated concepts, 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 some C features in place for

longer than I would prefer. The benefit is that you will not be confused by seeing all the C++ features used

before they are 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:

Chapter 1: Introduction to Objects. When projects became too big and complicated to easily

maintain, the “software crisis” was born, with programmers 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. The chapter walks you through the basic concepts and features of OOP and also introduces the

analysis and design process. In addition, you’ll learn about the benefits and concerns of adopting the

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

Chapter 2: Making and Using Objects. This chapter explains the process of building programs using

compilers and libraries. It introduces the first C++ program in the book and shows how programs are

constructed and compiled. Then some of the basic libraries of objects available in Standard C++ are

introduced. By the time you finish this chapter you’ll have a good grasp of what it means to write a C++

program using off-the-shelf object libraries.

Chapter 3: The C in C++. This chapter is a dense overview of the features in C that are used in C++, as

well as a number of basic features that are available only in C++. It also introduces the “make” utility

that’s common in the software development world and that is used to build all the examples in this book

(the source code for the book, which is available at www.BruceEckel.com, contains makefiles for each

chapter). Chapter 3 assumes that you have a solid grounding in some procedural programming language

like Pascal, C, or even some flavors of Basic (as long as you’ve written plenty of code in that language,

especially functions). If you find this chapter a bit too much, you should first go through the Thinking in

C seminar on the CD that’s bound with this book (and also available at www.BruceEckel.com).

Chapter 4: Data Abstraction. Most features in C++ revolve around the ability to create new data types.

Not only does this provide superior code organization, but it lays the groundwork 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. You’ll also learn the best way to organize your

code into header files and implementation files.

Chapter 5: 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 that 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 fancy variable).

Chapter 6: Initialization and 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 initialized properly. If your objects also require some sort of cleanup, you

can guarantee that this cleanup will always happen with the C++ destructor.

Chapter 7: Function Overloading and 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.

Chapter 8: Constants. This chapter covers the const and volatile keywords, which have additional

meaning in C++, especially inside classes. You’ll learn what it means to apply const to a pointer

definition. The chapter also shows how the meaning of const varies when used inside and outside of

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

Chapter 9: 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 of the benefits of a real function call. This chapter thoroughly explores the

implementation and use of inline functions.

Chapter 10: 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 in terms of their creation, visibility, placement of storage, and linkage. This chapter shows how

names are controlled in C++ 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.

Chapter 11: References and the Copy-Constructor. C++ pointers work like C pointers with the

additional benefit of stronger C++ type checking. C++ also provides an additional 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.

Chapter 12: 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 you’ll learn how to write

your own, dealing with the sometimes-confusing uses of arguments, return types, and the decision of

whether to make an operator a member or friend.

Chapter 13: Dynamic Object Creation. How many planes will an air-traffic system need to manage?

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

quantity, lifetime, or type of 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. You’ll also see

how new and delete can be overloaded in a variety of ways so you can control how storage is allocated

剩余515页未读，继续阅读

陈业新(Jimmy)

粉丝: 0
资源: 3

布鲁斯·埃克尔《Think in C++ 第2版》Volume1：面向对象编程入门

Thinking.inC_2nd.edition.Volume.2.Standard.Libraries.Advanced.Topics

thinking in c++, volume two书本源码

python设计一个基类可以完成思考、吃和睡，通过继承完成人、马和猫的思考、吃和睡，通过比例化对人、马和猫的各个动作的调用

哲学家就餐问题带界面python

thinking in c++ 中文版 pan

thinking in c++ 英文版

哲学家就餐问题带界面python带界面动态图

think in c++ pdf

最新资源