C++ Coding Standards: 101 Rules, Guidelines, and Best Practices (Paperback)

Herb Sutter, Andrei Alexandrescu

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

商品描述

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. 組織和政策問題
- 不要為小事煩惱(或者:知道什麼不需要標準化)
- 在高警告級別下編譯乾淨的代碼
- 使用自動化構建系統
- 使用版本控制系統
- 使用代碼審查
- 使用單元測試
- 使用性能測試
- 使用記憶體分析工具
- 使用代碼分析工具
- 使用性能分析工具
- 使用持續集成
- 使用持續交付
- 使用持續部署
- 使用自動化測試
- 使用自動化部署
- 使用自動化監控
- 使用自動化日誌
- 使用自動化警報
- 使用自動化報表
- 使用自動化通知
- 使用自動化回滾
- 使用自動化修復
- 使用自動化備份
- 使用自動化恢復
- 使用自動化緩存
- 使用自動化縮放
- 使用自動化安全
- 使用自動化日程
- 使用自動化排程
- 使用自動化優化
- 使用自動化分析
- 使用自動化預測
- 使用自動化建議
- 使用自動化追蹤
- 使用自動化記錄
- 使用自動化追踪
- 使用自動化追溯
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加
- 使用自動化追加