Cpp

Google C++ Style Guide

Official Google C++ coding standards for consistent, maintainable code.

Golden Rules

1. Target C++20 — avoid non-standard extensions 2. 80-character line limit — for readability 3. 2-space indentation — no tabs 4. Use `const` liberally — for correctness and thread safety 5. Avoid exceptions — Google code doesn't use C++ exceptions 6. Smart pointers for ownership — std::unique_ptr and std::shared_ptr 7. Header guards — use PROJECT_PATH_FILE_H_ format

Quick Reference

Naming Conventions

Headers

// ✓ CORRECT - self-contained header with guard
#ifndef FOO_BAR_BAZ_H_
#define FOO_BAR_BAZ_H_

#include <string>
#include "base/basictypes.h"

class Baz {
 public:
  void DoSomething();
};

#endif  // FOO_BAR_BAZ_H_

Include order: related header → C system → C++ stdlib → other libs → your headers.

Classes

// ✓ CORRECT
class MyClass {
 public:
  explicit MyClass(int value);  // explicit for single-arg ctors
  ~MyClass();

  void DoSomething();
  int GetValue() const { return value_; }

 private:
  int value_;
  std::string name_;
};

Smart Pointers

// ✓ CORRECT - unique_ptr for exclusive ownership
std::unique_ptr<Foo> FooFactory();
void FooConsumer(std::unique_ptr<Foo> ptr);

// ✓ CORRECT - shared_ptr for shared ownership
std::shared_ptr<const Foo> immutable_foo;

// ✗ INCORRECT - avoid raw new/delete
Foo* foo = new Foo();  // avoid
delete foo;            // avoid

Modern C++ Features

// ✓ CORRECT - use auto for complex types
auto it = my_map.find(key);
auto widget = std::make_unique<Widget>(arg1, arg2);

// ✓ CORRECT - range-based for loops
for (const auto& item : container) {
  Process(item);
}

// ✓ CORRECT - nullptr, not NULL
Foo* ptr = nullptr;

// ✓ CORRECT - constexpr for compile-time constants
constexpr int kArraySize = 100;

Functions

// ✓ CORRECT - return type on same line
ReturnType ClassName::FunctionName(Type par_name1, Type par_name2) {
  DoSomething();
  return result;
}

// ✓ CORRECT - wrap long parameter lists (4-space indent)
ReturnType LongClassName::ReallyLongFunctionName(
    Type par_name1,
    Type par_name2,
    Type par_name3) {
  DoSomething();
}

Formatting

// ✓ CORRECT - braces and spacing
if (condition) {
  DoSomething();
} else {
  DoSomethingElse();
}

// ✓ CORRECT - pointer/reference alignment (attached to type)
char* c;
const std::string& str;

Common Mistakes

When to Use This Guide

• Writing new C++ code
• Refactoring existing C++
• Code reviews
• Setting up clang-format rules
• Onboarding new team members

Install

npx skills add testdino-hq/google-styleguides-skills/cpp

Full Guide

See cpp.md for complete details, examples, and edge cases.

Google C++ Style Guide

Source: https://google.github.io/styleguide/cppguide.html

Golden Rules

1. Target C++20 — avoid non-standard extensions 2. 80-character line limit — for readability 3. 2-space indentation — no tabs 4. Use `const` liberally — for correctness and thread safety 5. Avoid exceptions — Google code doesn't use C++ exceptions 6. Smart pointers for ownership — std::unique_ptr and std::shared_ptr 7. Header guards — use PROJECT_PATH_FILE_H_ format

---

1. Headers

// CORRECT - self-contained header with guard
#ifndef FOO_BAR_BAZ_H_
#define FOO_BAR_BAZ_H_

#include <string>
#include "base/basictypes.h"

class Baz {
 public:
  void DoSomething();
};

#endif  // FOO_BAR_BAZ_H_

Include Order

1. Related header 2. C system headers 3. C++ standard library headers 4. Other libraries' headers 5. Your project's headers

---

2. Naming

---

3. Classes

// CORRECT
class MyClass {
 public:
  MyClass();  // Constructor
  ~MyClass();  // Destructor
  
  void DoSomething();
  int GetValue() const { return value_; }
  
 private:
  int value_;
  std::string name_;
};

Key Rules

• Declare data members private (except in structs)
• Use trailing underscore for private data members
• Mark single-argument constructors explicit
• Use = delete for uncopyable classes
• Prefer composition over inheritance

---

4. Functions

// CORRECT - return type on same line
ReturnType ClassName::FunctionName(Type par_name1, Type par_name2) {
  DoSomething();
  return result;
}

// CORRECT - wrap long parameter lists
ReturnType LongClassName::ReallyLongFunctionName(
    Type par_name1,  // 4 space indent
    Type par_name2,
    Type par_name3) {
  DoSomething();
}

---

5. Smart Pointers

// CORRECT - use unique_ptr for exclusive ownership
std::unique_ptr<Foo> FooFactory();
void FooConsumer(std::unique_ptr<Foo> ptr);

// CORRECT - use shared_ptr sparingly
std::shared_ptr<const Foo> immutable_foo;

// AVOID - never use auto_ptr
std::auto_ptr<Foo> foo;  // AVOID

---

6. Modern C++ Features

// CORRECT - use auto for complex types
auto it = my_map.find(key);
auto widget = std::make_unique<Widget>(arg1, arg2);

// CORRECT - use range-based for loops
for (const auto& item : container) {
  Process(item);
}

// CORRECT - use nullptr, not NULL
Foo* ptr = nullptr;

// CORRECT - use constexpr for compile-time constants
constexpr int kArraySize = 100;

---

7. Avoid These Features

---

8. Formatting

// CORRECT - braces and spacing
if (condition) {
  DoSomething();
} else {
  DoSomethingElse();
}

// CORRECT - pointer/reference alignment
char* c;
const std::string& str;

// CORRECT - function calls
DoSomething(argument1, argument2, argument3);

// CORRECT - wrap long calls
DoSomething(
    argument1, argument2,  // 4 space indent
    argument3, argument4);

---

Common Mistakes