Ruminations on C++: A Decade of Programming Insight and Experience (Paperback)
暫譯: C++的思考：十年的程式設計洞察與經驗 (平裝本)

Andrew Koenig, Barbara E. Moo

Ruminations on C++: A Decade of Programming Insight and Experience (Paperback)

買這商品的人也買了...

相關主題

商品描述


Table Of Contents

Preface.
Prelude.
First Try.
Doing it without Classes.
Why was it Easier in C++?
A Bigger Example.
Conclusion.

I. MOTIVATION.


1. Why I Use C++.
The Problem.
History and Context.
Automatic Software Distribution.
Enter C++.
Recycled Software.
Postscript.

2. Why I Work on C++.
The Success of Small Projects.
Abstraction.
Machines Should Work for People.

3. Living in the Real World.

II. CLASSES aND INHERITANCE.

4. Checklist for Class Authors.
5. Surrogate Classes.
The Problem.
The Classical Solution.
Virtual Copy Functions.
Defining a Surrogate Class.
Summary.

6. Handles: Part 1.
The Problem.
A Simple Class.
Attaching a Handle.
Getting at the Object.
Simple Implementation.
Use-Counted Handles.
Copy on Write.
Discussion.

7. Handles: Part 2.
Review.
Separating the use Count.
Abstraction of use Counts.
Access Functions and Copy on Write.
Discussion.

8. An Object-Oriented Program.
The Problem.
An Object-Oriented Solution.
Handle Classes.
Extension 1: New Operations.
Extension 2: New Node Types.
Reflections.

9. Analysis of a Classroom Exercise: Part 1.
The Problem.
Designing the Interface.
A Few Loose Ends.
Testing the Interface.
Strategy.
Tactics.
Combining Pictures.
Conclusion.

10. Analysis of a Classroom Exercise: Part 2.
Strategy.
Exploiting the Structure.
Conclusion.

11. When not to use Virtual Functions.
The Case For.
The Case Against.
Destructors are Special.
Summary.

III. TEMPLATES.


12. Designing a Container Class.
What Does it Contain?
What Does Copying the Container Mean?
How Do You Get at Container Elements?
How Do You Distinguish Reading from Writing?
How Do You Handle Container Growth?
What Operations Does the Container Provide?
What Do You Assume about the Container Element Type?
Containers and Inheritance.
Designing an Arraylike Class.

13. Accessing Container Elements.
Imitating a Pointer.
Getting at the Data.
Remaining Problems.
Pointer to Const Array.
Useful Additions.

14. Iterators.
Completing the Pointer Class.
What is an Iterator?
Deleting an Element.
Deleting the Container.
Other Design Considerations.
Discussion.

15. Sequences.
The State of the Art.
A Radical Old Idea.
Well, Maybe a Few Extras.
Example of Use.
Maybe a Few More.
Food for Thought.

16. Templates as Interfaces.
The Problem.
The First Example.
Separating the Iteration.
Iterating Over Arbitrary Types.
Adding Other Types.
Abstracting the Storage Technique.
The Proof of the Pudding.
Summary.

17. Templates and Generic Algorithms.
A Specific Example.
Generalizing the Element Type.
Postponing the Count.
Address Independence.
Searching a Nonarray.
Discussion.

18. Generic Iterators.
A Different Algorithm.
Categories of Requirements.
Input Iterators.
Output Iterators.
Forward Iterators.
Bidirectional Iterators.
Random-Access Iterators.
Inheritance?
Performance.
Summary.

19. Using Generic Iterators.
Iterator Types.
Virtual Sequences.
An Output-Stream Iterator.
An Input-Stream Iterator.
Discussion.

20. Iterator Adaptors.
An Example.
Directional Asymmetry.
Consistency and Asymmetry.
Automatic Reversal.
Discussion.

21. Function Objects.
An Example.
Function Pointers.
Function Objects.
Function-Object Templates.
Hiding Intermediate Types.
One Type Covers Many.
Implementation.
Discussion.

22. Function Adaptors.
Why Function Objects?
Function Objects For Built-In Operators.
Binders.
A Closer Look.
Interface Inheritance.
Using These Classes.
Discussion.

IV. LIBRARIES.


23. Libraries in Everyday Use.
The Problem.
Understanding the Problem—Part 1.
Implementation—Part 1.
Understanding the Problem—Part 2.
Implementation—Part 2.
Discussion.

24. An Object Lesson in Library-Interface Design.
Complications.
Improving the Interface.
Taking Stock.
Writing the Code.
Conclusion.

25. Library Design is Language Design.
Character Strings.
Memory Exhaustion.
Copying.
Hiding the Implementation.
Default Constructor.
Other Operations.
Substrings.
Conclusion.

26. Language Design is Library Design.
Abstract Data Types.
Libraries and Abstract Data Types.
Memory Allocation.
Memberwise Assignment and Initialization.
Exception Handling.
Summary.

V. TECHNIQUE.


27. Classes that Keep Track of Themselves.
Design of a Trace Class.
Creating Dead Code.
Generating Audit Trails for Objects.
Verifying Container Behavior.
Summary.

28. Allocating Objects in Clusters.
The Problem.
Designing the Solution.
Implementation.
Enter Inheritance.
Summary.

29. Applicators, Manipulators, and Function Objects.
The Problem.
A Solution.
A Different Solution.
Multiple Arguments.
An Example.
Abbreviations.
Musings.
Historical Notes, References, and Acknowledgments.

30. Decoupling Application Libraries from Input-Output.
The Problem.
Solution 1: Trickery and Brute Force.
Solution 2: Abstract Output.
Solution 3: Trickery without Brute Force.
Remarks.

VI. WRAPUP.


31. Simplicity through Complexity.
The World is Complicated.
Complexity Becomes Hidden.
Computers are no Different.
Computers Solve Real Problems.
Class Libraries and Language Semantics.
Making Things Easy is Hard.
Abstraction and Interface.
Conservation of Complexity.

32. What Do You Do After You Say Hello World?
Find the Local Experts.
Pick a Tool Kit and Become Comfortable with it.
Some Parts of C are Essential.
But Others are not.
Set Yourself a Series of Problems.
Conclusion.

Index. 0201423391T04062001


Back to Top

商品描述(中文翻譯)

```
目錄

前言
序章
第一次嘗試
不使用類別的實作
為什麼在 C++ 中更容易？
一個更大的範例
結論

I. 動機
1. 為什麼我使用 C++？
問題
歷史與背景
自動化軟體分發
C++ 的出現
回收軟體
後記

2. 為什麼我從事 C++ 的工作？
小型專案的成功
抽象化
機器應該為人類服務

3. 生活在現實世界中

II. 類別與繼承
4. 類別作者檢查清單

5. 代理類別
問題
傳統解決方案
虛擬複製函數
定義代理類別
總結

6. 處理器：第一部分
問題
一個簡單的類別
附加處理器
獲取物件
簡單實作
使用計數的處理器
寫時複製
討論

7. 處理器：第二部分
回顧
分離使用計數
使用計數的抽象化
存取函數與寫時複製
討論

8. 一個物件導向的程式
問題
物件導向的解決方案
處理器類別
擴展 1：新操作
擴展 2：新節點類型
反思

9. 課堂練習分析：第一部分
問題
設計介面
一些未解決的問題
測試介面
策略
戰術
結合圖片
結論

10. 課堂練習分析：第二部分
策略
利用結構
結論

11. 何時不使用虛擬函數
支持的案例
反對的案例
解構函數是特殊的
總結

III. 模板
12. 設計容器類別
它包含什麼？
複製容器意味著什麼？
如何獲取容器元素？
如何區分讀取與寫入？
如何處理容器增長？
容器提供什麼操作？
你對容器元素類型的假設是什麼？
容器與繼承
設計類似陣列的類別

13. 存取容器元素
模擬指標
獲取數據
剩餘問題
指向常量陣列的指標
有用的附加功能

14. 迭代器
完成指標類別
什麼是迭代器？
刪除元素
刪除容器
其他設計考量
討論

15. 序列
當前技術
一個激進的舊想法
好吧，也許還有一些額外的
使用範例
也許還有更多
思考的食物

16. 模板作為介面
問題
第一個範例
分離迭代
迭代任意類型
添加其他類型
抽象存儲技術
證明
總結

17. 模板與通用演算法
一個具體範例
對元素類型的概括
延遲計數
地址獨立性
搜索非陣列
討論

18. 通用迭代器
不同的演算法
要求的類別
輸入迭代器
輸出迭代器
前向迭代器
雙向迭代器
隨機存取迭代器
繼承？
性能
總結

19. 使用通用迭代器
迭代器類型
虛擬序列
輸出流迭代器
輸入流迭代器
討論

20. 迭代器適配器
一個範例
方向不對稱
一致性與不對稱
自動反轉
討論

21. 函數物件
一個範例
函數指標
函數物件
函數物件模板
隱藏中間類型
一種類型涵蓋多種
實作
討論

22. 函數適配器
為什麼使用函數物件？
內建運算子的函數物件
綁定器
更深入的了解
介面繼承
使用這些類別
討論

IV. 函式庫
23. 日常使用的函式庫
問題
理解問題—第一部分
實作—第一部分
理解問題—第二部分
實作—第二部分
討論

24. 函式庫介面設計的實例教訓
複雜性
改進介面
盤點
編寫代碼
結論

25. 函式庫設計即語言設計
字符串
記憶體耗盡
複製
隱藏實作
預設建構函數
其他操作
子字符串
結論

26. 語言設計即函式庫設計
抽象數據類型
函式庫與抽象數據類型
記憶體分配
成員賦值與初始化
異常處理
總結

V. 技術
27. 自我追蹤的類別
追蹤類的設計
創建死代碼
為物件生成審計追蹤
驗證容器行為
總結

28. 在集群中分配物件
問題
設計解決方案
實作
進入繼承
總結

29. 應用器、操控器與函數物件
問題
一個解決方案
另一個解決方案
多個參數
一個範例
縮寫
思考
歷史註記、參考與致謝

30. 將應用函式庫與輸入輸出解耦
問題
解決方案 1：詭計與蛮力
解決方案 2：抽象輸出
解決方案 3：不使用蛮力的詭計
備註

VI. 總結
31. 透過複雜性達到簡單
世界是複雜的
複雜性變得隱藏
電腦並無不同
電腦解決真實問題
類別函式庫與語言語義
使事情變得簡單是困難的
抽象與介面
複雜性的保留

32. 說完 Hello World 後你該做什麼？
找當地專家
選擇一個工具包並熟悉它
C 的某些部分是必要的
但其他部分則不是
設定一系列問題
結論

索引
```

類似商品