C++ Coding Standards: 101 Rules, Guidelines, and Best Practices (Paperback)
暫譯: C++ 程式設計標準:101 條規則、指導方針與最佳實踐 (平裝本)
Herb Sutter, Andrei Alexandrescu
- 出版商: Addison Wesley
- 出版日期: 2004-11-01
- 定價: $2,100
- 售價: 9.5 折 $1,995
- 語言: 英文
- 頁數: 240
- 裝訂: Paperback
- ISBN: 0321113586
- ISBN-13: 9780321113580
-
相關分類:
C++ 程式語言
-
相關翻譯:
C++ 程式設計規範 : 101條規則 , 準則與最佳實踐 (簡中版)
C++ 編程規範 (C++ Coding Standards: 101 Rules, Guidelines, and Best Practices) (繁中版)
立即出貨
買這商品的人也買了...
-
$2,480$2,356 -
$980$774 -
$920$727 -
$650$514 -
$1,930$1,834 -
$780$741 -
$590$466 -
$750$638 -
$560$476 -
$2,390$2,271 -
$850$723 -
$480$379 -
$750$593 -
$780$616 -
$490$382 -
$890$703 -
$620$490 -
$780$616 -
$675LPIC 1 Exam Cram 2: Linux Professional Institute Certification Exams 101 and 102 (Paperback)
-
$2,550$2,423 -
$650$514 -
$480$379 -
$650$507 -
$450$383 -
$620$490
商品描述
Description:
Consistent, high-quality coding standards improve software quality, reduce time-to-market, promote teamwork, eliminate time wasted on inconsequential matters, and simplify maintenance. Now, two of the world's most respected C++ experts distill the rich collective experience of the global C++ community into a set of coding standards that every developer and development team can understand and use as a basis for their own coding standards.
The authors cover virtually every facet of C++ programming: design and coding style, functions, operators, class design, inheritance, construction/destruction, copying, assignment, namespaces, modules, templates, genericity, exceptions, STL containers and algorithms, and more. Each standard is described concisely, with practical examples. From type definition to error handling, this book presents C++ best practices, including some that have only recently been identified and standardized-techniques you may not know even if you've used C++ for years. Along the way, you'll find answers to questions like
What's worth standardizing--and what isn't?
What are the best ways to code for scalability?
What are the elements of a rational error handling policy?
How (and why) do you avoid unnecessary initialization, cyclic, and definitional dependencies?
When (and how) should you use static and dynamic polymorphism together?
How do you practice "safe" overriding?
When should you provide a no-fail swap?
Why and how should you prevent exceptions from propagating across module boundaries?
Why shouldn't you write namespace declarations or directives in a header file?
Why should you use STL vector and string instead of arrays?
How do you choose the right STL search or sort algorithm?
What rules should you follow to ensure type-safe code?
Whether you're working alone or with others, C++ Coding Standards will help you write cleaner code--and write it faster, with fewer hassles and less frustration.
Table of Contents:
Preface.
1. Organizational and Policy Issues.
Don't sweat the small stuff. (Or: Know what not to standardize.).
Compile cleanly at high warning levels.
Use an automated build system.
Use a version control system.
Invest in code reviews.
2. Design Style.
Give one entity one cohesive responsibility.
Correctness, simplicity, and clarity come first.
Know when and how to code for scalability.
Don't optimize prematurely.
Don't pessimize prematurely.
Minimize global and shared data.
Hide information.
Know when and how to code for concurrency.
Ensure resources are owned by objects. Use explicit RAII and smart pointers.
3. Coding Style.
Prefer compile- and link-time errors to run-time errors.
Use const proactively.
Avoid macros.
Avoid magic numbers.
Declare variables as locally as possible.
Always initialize variables.
Avoid long functions. Avoid deep nesting.
Avoid initialization dependencies across compilation units.
Minimize definitional dependencies. Avoid cyclic dependencies.
Make header files self-sufficient.
Always write internal #include guards. Never write external #include guards.
4. Functions and Operators.
Take parameters appropriately by value, (smart) pointer, or reference.
Preserve natural semantics for overloaded operators.
Prefer the canonical forms of arithmetic and assignment operators.
Prefer the canonical form of ++ and --. Prefer calling the prefix forms.
Consider overloading to avoid implicit type conversions.
Avoid overloading &&, ||, or , (comma).
Don't write code that depends on the order of evaluation of functionarguments.
5. Class Design and Inheritance.
Be clear what kind of class you're writing.
Prefer minimal classes to monolithic classes.
Prefer composition to inheritance.
Avoid inheriting from classes that were not designed to be base classes.
Prefer providing abstract interfaces.
Public inheritance is substitutability.
Inherit, not to reuse, but to be reused.
Practice safe overriding.
Consider making virtual functions nonpublic, and public functions nonvirtual.
Avoid providing implicit conversions.
Make data members private, except in behaviorless aggregates (C-stylestructs).
Don't give away your internals.
Pimpl judiciously.
Prefer writing nonmember nonfriend functions.
Always provide new and delete together.
If you provide any class-specific new, provide all of the standard forms (plain, in-place, and nothrow).
6. Construction, Destruction, and Copying.
Define and initialize member variables in the same order.
Prefer initialization to assignment in constructors.
Avoid calling virtual functions in constructors and destructors.
Make base class destructors public and virtual, or protected and nonvirtual.
Destructors, deallocation, and swap never fail.
Copy and destroy consistently.
Explicitly enable or disable copying.
Avoid slicing. Consider Clone instead of copying in base classes.
Prefer the canonical form of assignment.
Whenever it makes sense, provide a no-fail swap (and provide it correctly).
7. Namespaces and Modules.
Keep a type and its nonmember function interface in the same namespace.
Keep types and functions in separate namespaces unless they're specifically intended to work together.
Don't write namespace usings in a header file or before an #include.
Avoid allocating and deallocating memory in different modules.
Don't define entities with linkage in a header file.
Don't allow exceptions to propagate across module boundaries.
Use sufficiently portable types in a module's interface.
8. Templates and Genericity.
Blend static and dynamic polymorphism judiciously.
Customize intentionally and explicitly.
Don't specialize function templates.
Don't write unintentionally nongeneric code.
9. Error Handling and Exceptions.
Assert liberally to document internal assumptions and invariants.
Establish a rational error handling policy, and follow it strictly.
Distinguish between errors and non-errors.
Design and write error-safe code.
Prefer to use exceptions to report errors.
Throw by value, catch by reference.
Report, handle, and translate errors appropriately.
Avoid exception specifications.
10. STL: Containers.
Use vector by default. Otherwise, choose an appropriate container.
Use vector and string instead of arrays.
Use vector (and string::c_str) to exchange data with non-C++ APIs.
Store only values and smart pointers in containers.
Prefer push_back to other ways of expanding a sequence.
Prefer range operations to single-element operations.
Use the accepted idioms to really shrink capacity and really erase elements.
11. STL: Algorithms.
Use a checked STL implementation.
Prefer algorithm calls to handwritten loops.
Use the right STL search algorithm.
Use the right STL sort algorithm.
Make predicates pure functions.
Prefer function objects over functions as algorithm and comparer arguments.
Write function objects correctly.
12. Type Safety.
Avoid type switching; prefer polymorphism.
Rely on types, not on representations.
Avoid using reinterpret_cast.
Avoid using static_cast on pointers.
Avoid casting away const.
Don't use C-style casts.
Don't memcpy or memcmp non-PODs.
Don't use unions to reinterpret representation.
Don't use varargs (ellipsis).
Don't use invalid objects. Don't use unsafe functions.
Don't treat arrays polymorphically.
Bibliography.
Summary of Summaries.
Index.
商品描述(中文翻譯)
**描述:**
一致且高品質的程式碼標準能提升軟體品質、縮短上市時間、促進團隊合作、消除在不重要事務上浪費的時間,並簡化維護。現在,全球兩位最受尊敬的 C++ 專家將全球 C++ 社群的豐富集體經驗提煉成一套每位開發者和開發團隊都能理解並用作自己程式碼標準基礎的標準。
作者幾乎涵蓋了 C++ 程式設計的每個面向:設計與程式碼風格、函數、運算子、類別設計、繼承、建構/解構、複製、指派、命名空間、模組、模板、泛型、例外、STL 容器和演算法等。每個標準都簡潔地描述,並附有實用範例。從類型定義到錯誤處理,本書呈現 C++ 的最佳實踐,包括一些最近才被識別和標準化的技術,即使你使用 C++ 多年也可能不知曉。在此過程中,你將找到以下問題的答案:
什麼是值得標準化的——什麼是不值得的?
如何編寫可擴展性的最佳程式碼?
合理的錯誤處理政策的要素是什麼?
如何(以及為什麼)避免不必要的初始化、循環和定義依賴?
何時(以及如何)應該一起使用靜態和動態多型?
如何實踐「安全」的覆寫?
何時應提供不失敗的交換?
為什麼以及如何防止例外跨模組邊界傳播?
為什麼不應在標頭檔中撰寫命名空間聲明或指令?
為什麼應該使用 STL 的 vector 和 string 而不是陣列?
如何選擇合適的 STL 搜尋或排序演算法?
應遵循什麼規則以確保類型安全的程式碼?
無論你是獨自工作還是與他人合作,**C++ 程式碼標準**將幫助你編寫更乾淨的程式碼——並更快地編寫,減少麻煩和挫折。
**目錄:**
**前言。**
**1. 組織與政策問題。**
不要為小事煩惱。(或:知道什麼不該標準化。)
在高警告級別下乾淨編譯。
使用自動化建置系統。
使用版本控制系統。
投資於程式碼審查。
**2. 設計風格。**
給予一個實體一個一致的責任。
正確性、簡單性和清晰性優先。
知道何時以及如何編寫可擴展的程式碼。
不要過早優化。
不要過早悲觀化。
最小化全域和共享數據。
隱藏資訊。
知道何時以及如何編寫並發程式碼。
確保資源由物件擁有。使用明確的 RAII 和智能指標。
**3. 程式碼風格。**
偏好編譯時和連結時錯誤而非執行時錯誤。
主動使用 const。
避免使用宏。
避免魔法數字。
盡可能局部地聲明變數。
總是初始化變數。
避免長函數。避免深層嵌套。
避免跨編譯單元的初始化依賴。
最小化定義依賴。避免循環依賴。
使標頭檔自給自足。
總是撰寫內部 #include 保護。永遠不要撰寫外部 #include 保護。
**4. 函數與運算子。**
適當地以值、(智能)指標或參考傳遞參數。
保持重載運算子的自然語義。
偏好算術和指派運算子的標準形式。
偏好 ++ 和 -- 的標準形式。偏好調用前綴形式。
考慮重載以避免隱式類型轉換。
避免重載 &&、|| 或 ,(逗號)。
不要撰寫依賴於函數參數評估順序的程式碼。
**5. 類別設計與繼承。**
清楚你正在撰寫什麼類型的類別。
偏好最小類別而非單體類別。
偏好組合而非繼承。
避免從未設計為基類的類別繼承。
偏好提供抽象介面。
公開繼承是可替代性。
繼承不是為了重用,而是為了被重用。
實踐安全的覆寫。
考慮將虛擬函數設為非公開,將公開函數設為非虛擬。
避免提供隱式轉換。
使數據成員私有,除了在無行為的聚合(C 風格結構)中。
不要洩露你的內部實現。
明智地使用 Pimpl。
偏好撰寫非成員非友元函數。