| 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_;
};
}
#endif
Class Declaration Order
class MyClass {
public:
using ValueType = int;
static constexpr int kMaxSize = 100;
MyClass();
MyClass(const MyClass&) = default;
MyClass& operator=(const MyClass&) = default;
~MyClass();
void Process();
protected:
private:
void InternalHelper();
int value_;
};
Function Comments
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)