google-cpp-style

# Google C++ Style Guide This skill provides the complete Google C++ Style Guide for C++20. Apply these rules when writing or reviewing C++ code. ## Quick Reference | Topic | Key Rules | |-------|-----------| | **Naming** | Types: `PascalCase`, functions: `PascalCase`, variables: `snake_case`, constants: `kPascalCase`, macros: `UPPER_CASE` | | **Formatting** | 80 char lines, 2-space indent, spaces (not tabs), `{` on same line | | **Headers** | Self-contained, `#define` guards, include what you use | | **Classes** | Prefer composition over inheritance, explicit constructors, `private` data members | ## Core Principles 1. **Optimize for the reader** - Code is read more than written 2. **Be consistent** - Follow existing patterns in the codebase 3. **Avoid surprising constructs** - Prefer clear over clever ## Target Version Code should target **C++20**. Do not use C++23 features or non-standard extensions. ## Detailed References For complete rules on specific topics: - [Header Files](headers.md) - Include guards, ordering, forward declarations - [Scoping](scoping.md) - Namespaces, linkage, static/global variables - [Classes](classes.md) - Constructors, inheritance, operator overloading - [Functions](functions.md) - Parameters, overloading, default arguments - [C++ Features](features.md) - Smart pointers, exceptions, RTTI, lambdas - [Naming](naming.md) - All naming conventions with examples - [Comments](comments.md) - Documentation style and requirements - [Formatting](formatting.md) - Whitespace, braces, line length ## Common Patterns ### Header File Template ```cpp #ifndef PROJECT_PATH_FILE_H_ #define PROJECT_PATH_FILE_H_ #include "project/public/header.h" #include <sys/types.h> #include <string> #include <vector> #include "other/library.h" #include "project/internal.h" namespace project { class MyClass { public: MyClass(); explicit MyClass(int value); void DoSomething(); int count() const { return count_; } void set_count(int count) { count_ = count; } private: int count_; }; } // namespace project #endif // PROJECT_PATH_FILE_H_ ``` ### Class Declaration Order ```cpp class MyClass { public: // Types and type aliases using ValueType = int; // Static constants static constexpr int kMaxSize = 100; // Constructors and assignment MyClass(); MyClass(const MyClass&) = default; MyClass& operator=(const MyClass&) = default; // Destructor ~MyClass(); // All other methods void Process(); protected: // Protected members (if needed) private: // Private methods void InternalHelper(); // Data members int value_; }; ``` ### Function Comments ```cpp // Returns an iterator positioned at the first entry >= `start_word`. // Returns nullptr if no such entry exists. // The client must not use the iterator after the table is destroyed. std::unique_ptr<Iterator> GetIterator(absl::string_view start_word) const; ``` ## Critical Rules Summary ### Always Do - Use `#define` guards in all headers - Make single-argument constructors `explicit` - Use `nullptr` (not `NULL` or `0`) for pointers - Use `override` or `final` for virtual function overrides - Declare data members `private` - Initialize variables at declaration ### Never Do - Use `using namespace` directives - Use C-style casts (use `static_cast`, etc.) - Use exceptions (in Google code) - Use non-standard extensions - Define macros in headers (when possible) - Use `std::auto_ptr` (use `std::unique_ptr`)