深入理解C++第2版：标准库与高级主题

需积分: 10 73 浏览量更新于2024-07-22 收藏 1.99MB PDF 举报

《Thinking in C++ 第二版：标准库与高级主题》（Volume 2）是 Bruce Eckel 的经典之作，该书专为深入理解和学习 C++ 对象导向编程而设计。作为第二版的续篇，它不仅涵盖了 C++ 标准库的详尽剖析，还探讨了一系列高级话题，旨在帮助读者提升编程技能和理解。在本书中，Eckel以清晰易懂的方式阐述了如何将面向对象的思想应用于程序构建，这是他在众多同类书籍中独树一帜的地方。他强调了 C++ 编程中的核心概念，如类、继承、多态和模板等，确保读者能够掌握这些基础并拓展到更复杂的层次。书中特别提到了关于 iostreams 的章节，这被评价为迄今为止最全面且易于理解的讲解。iostreams 是 C++ 标准库中的重要组成部分，负责输入/输出操作，这对于任何 C++ 开发者来说都是不可或缺的知识。评论家们对这本书给予了高度赞扬。Al Stevens，Doctor Dobb's Journal 的贡献编辑，认为这是一本每个 C++ 学习者都应该拥有的书籍，其对 iostreams 的处理尤其值得推荐。Andrew Binstock，Unix Review 的编辑，称赞 Ecker 的洞察力和他对 C++ 的深入理解，称《Thinking in C++》为一本解答复杂问题的杰出参考书。 Gary Entsminger，The Tao of Objects 的作者，更是对 Thinking in C++ 的深度和实用性赞不绝口，他形容这本书是 Ecker 最佳思想集合，对于想要系统掌握 C++ 的读者而言，是一本耐心且极具价值的学习资源。《Thinking in C++ 第二版 Volume 2》不仅提供了一个强大的工具箱来探索 C++ 的世界，而且通过深入浅出的讲解，引导读者重构思维，以适应面向对象的编程方式。无论是初学者还是经验丰富的开发者，都可以从中受益匪浅。如果你正寻找一本能解答疑惑、提升 C++ 技能的权威指南，这本书无疑是值得投资的宝贵资产。

Preface 16

Goals

My goals in this book are to:

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

each concept before moving on.

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 sometimes receive criticism for using “toy

examples,” but I’m willing to accept that in favor of producing something

pedagogically useful.

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.

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 that would just confuse people 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.

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.

Provide the reader 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).

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

Preface 17

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

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 that came from audiences as I taught it.

This course was designed with one thing in mind: to streamline the process of learning 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 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:

(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.

(15) Multiple inheritance

. This sounds simple at first: A new class is inherited from more

than one existing class. However, you can end up with ambiguities and multiple copies of

base-class objects. That problem is solved with virtual base classes, but the bigger issue

remains: When do you use it? Multiple inheritance is only essential when you need to

manipulate an object through more than one common base class. This chapter explains the

syntax for multiple inheritance, and shows alternative approaches – in particular, how

templates solve one common problem. The use of multiple inheritance to repair a “damaged”

class interface is demonstrated as a genuinely valuable use of this feature.

Preface 18

(16) Exception handling

. Error handling has always been a problem in programming. Even if

you dutifully return error information or set a flag, the function caller may simply ignore it.

Exception handling is a primary feature in C++ that solves this problem by allowing you to

“throw” an object out of your function when a critical error happens. You throw different

types of objects for different errors, and the function caller “catches” these objects in separate

error handling routines. If you throw an exception, it cannot be ignored, so you can guarantee

that

something

will happen in response to your error.

(17) Run-time type identification

Run-time type identification (RTTI) lets you find the

exact type of an object when you only have a pointer or reference to the base type. Normally,

you’ll want to intentionally ignore the exact type of an object and let the virtual function

mechanism implement the correct behavior for that type. But occasionally it is very helpful to

know the exact type of an object for which you only have a base pointer; often this

information allows you to perform a special-case operation more efficiently. This chapter

explains what RTTI is for and how to use it.

Exercises

I’ve discovered that simple exercises are exceptionally useful during a seminar to complete a

student’s understanding, so you’ll find a set at the end of each chapter.

These are fairly simple, so they can be finished in a reasonable amount of time in a classroom

situation while the instructor observes, making sure all the students are absorbing the material.

Some exercises are a bit more challenging to keep advanced students entertained. They’re all

designed to be solved in a short time and are only there to test and polish your knowledge

rather than present major challenges (presumably, you’ll find those on your own – or more

likely they’ll find you).

Exercise solutions

Solutions to exercises can be found in the electronic document

The C++ Annotated Solution

Guide

, Volume 2 by Chuck Allison, available for a small fee from www.BruceEckel.com. [[

Note this is not yet available ]]

Source code

The source code for this book is copyrighted freeware, distributed via the web site

http://www.BruceEckel.com. The copyright prevents you from republishing the code in print

media without permission.

Although the code is available in a zipped file on the above web site, you can also unpack the

code yourself by downloading the text version of the book and running the program

ExtractCode

(from Volume 2 of this book), the source for which is also provided on the Web

Preface 19

site. The program will create a directory for each chapter and unpack the code into those

directories. In the starting directory where you unpacked the code you will find the following

//:! :CopyRight.txt

Source code file from the book "Thinking in C++"

following statements: You can freely use this file

for your own work (personal or commercial),

including modifications and distribution in

executable form only. Permission is granted to use

this file in classroom situations, including its

use in presentation materials, as long as the book

"Thinking in C++" is cited as the source.

Except in classroom situations, you cannot copy

and distribute this code; instead, the sole

distribution point is http://www.BruceEckel.com

(and official mirror sites) where it is

freely available. You cannot remove this

modified versions of the source code in this

package. You cannot use this file in printed

media without the express permission of the

author. Bruce Eckel makes no representation about

the suitability of this software for any purpose.

It is provided "as is" without express or implied

warranty of any kind, including any implied

warranty of merchantability, fitness for a

particular purpose or non-infringement. The entire

risk as to the quality and performance of the

software is with you. Bruce Eckel and the

publisher shall not be liable for any damages

suffered by you or any third party as a result of

using or distributing software. In no event will

Bruce Eckel or the publisher be liable for any

lost revenue, profit, or data, or for direct,

indirect, special, consequential, incidental, or

punitive damages, however caused and regardless of

the theory of liability, arising out of the use of

or inability to use software, even if Bruce Eckel

and the publisher have been advised of the

possibility of such damages. Should the software

prove defective, you assume the cost of all

剩余591页未读，继续阅读

WangLanguager

粉丝: 1w+
资源: 297

深入理解C++第2版：标准库与高级主题

Thinking in C++中文版

C++编程思想(Thinking in C++)完美版pdf

Thinking in C++.pdf

Thinking.In.C++.Second Edition.Volume 1.Prentice.Hall.Bruce.Eckel.pdf

Core.Python.Programming.2nd.Edition.Prentice.Hall.(英文版.Wesley J. Chun).pdf

[Bruce.Eckel编程思想系列丛书].PRENTICE-HALL-Thinking-In-Python-177ye

Prentice.Hall.Core.Java.Volume.2.Advanced.Features.8th.Edition.

[深入理解计算机系统].Computer.Systems.2003.Prentice.Hall.djvu

Embedded.Linux.Primer.A.Practical.Real-World.Approach.2006.Prentice-Hall

Prentice.Hall.Core.Java.Volume.II.Advanced.Features.8th.Edition.Apr.2008.part2.rar

最新资源