google-cpp-style

name google-cpp-style description Google C++ Style Guide rules for writing clean, maintainable C++ code. Use when writing C++, reviewing code, discussing naming conventions, formatting, class design, or any C++ best practices. Covers headers, scoping, classes, functions, naming, comments, and formatting. 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 Optimize for the reader - Code is read more than written Be consistent - Follow existing patterns in the codebase 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 - Include guards, ordering, forward declarations Scoping - Namespaces, linkage, static/global variables Classes - Constructors, inheritance, operator overloading Functions - Parameters, overloading, default arguments C++ Features - Smart pointers, exceptions, RTTI, lambdas Naming - All naming conventions with examples Comments - Documentation style and requirements Formatting - Whitespace, braces, line length Common Patterns Header File Template # 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 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 // 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 )