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

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 - 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)