C++ Core Guidelines house style

Contract

When you emit C++, name and shape every token the way the C++ Core Guidelines (isocpp.github.io/CppCoreGuidelines) do: lowercase snake_case everywhere, trailing-underscore private members, no ALL_CAPS outside macros, scoped enums, brace initialization, '\n' for newlines, using aliases, guarded headers. The defaults a general model reaches for (PascalCase types, MAX_SIZE constants, std::endl) are the wrong house style here.

Rules

This is the closed rule set. Apply every rule that the snippet touches.

1. snake_case identifiers (NL.8/NL.10). Namespaces, types (class /

struct / enum / alias), free functions, member functions, variables, and parameters are all lowercase words joined by underscores. Never PascalCase, never camelCase. class http_client, void send_request(), int retry_count. A single-word name is simply lowercase: socket, not Socket.

1. Trailing underscore on private data members. Each non-static private

or protected data member ends with exactly one trailing underscore: buffer_, host_, byte_count_. Do not use an m_ prefix, a _ prefix, or Hungarian tags. Public data members of an aggregate struct are snake_case without the trailing underscore.

1. ALL_CAPS is for macros only (NL.9). A named const/constexpr

object is snake_case, never uppercase. Write constexpr int max_retries, not MAX_RETRIES. Reserve ALL_CAPS exclusively for #define macro names (which you should avoid anyway, ES.45/Enum.1).

1. Enumerators are lowercase (Enum.5). Enumerator names are snake_case

lowercase: red, not_found, in_progress. Never RED / NOT_FOUND.

1. Scoped enum class, never plain enum (Enum.3). Declare every

enumeration as enum class name { ... };. A bare unscoped enum { ... } leaks its names into the surrounding scope and is forbidden.

1. using aliases, never typedef (T.43). Type aliases use

using node_id = std::uint64_t;. Never typedef.

1. Brace-initialize at the point of declaration (ES.20/ES.23). Every

object is initialized where it is declared, and scalars / strings / aggregates use brace {} initialization: int count{0};, std::string name{"x"};. Never leave a variable uninitialized; prefer {} over =.

1. '\n', never std::endl (SL.io.50). End a line of stream output

with the character '\n'. std::endl forces a flush and must not appear.

1. Guard every header (SF.8). A header file begins with #pragma once

or a matching #ifndef X / #define X pair closed by #endif.

1. No using namespace at file scope in a header (SF.7). Never place a

using namespace ...; directive at global or namespace scope inside a header; it pollutes every translation unit that includes it.

Worked examples (before -> after)

Rule 1 — snake_case types and functions

cpp
// BEFORE (general-model default)
class HttpClient {
public:
    Response SendRequest(const std::string& url);
};

// AFTER (Core Guidelines house style)
class http_client {
public:
    response send_request(const std::string& url);
};

Rule 2 — trailing underscore on private members

cpp
// BEFORE
class ring_buffer {
private:
    std::vector<int> data;
    std::size_t head;
    std::size_t m_tail;   // m_ prefix
};

// AFTER
class ring_buffer {
private:
    std::vector<int> data_;
    std::size_t head_;
    std::size_t tail_;
};

Rule 3 — constants are not ALL_CAPS

cpp
// BEFORE
const int MAX_RETRIES = 3;
constexpr double TIMEOUT_SECONDS = 2.5;

// AFTER
constexpr int max_retries{3};
constexpr double timeout_seconds{2.5};

Rules 4 & 5 — scoped enum, lowercase enumerators

cpp
// BEFORE
enum Color { RED, GREEN, BLUE };

// AFTER
enum class color { red, green, blue };

Rule 6 — using, not typedef

cpp
// BEFORE
typedef std::vector<std::vector<int>> Matrix;

// AFTER
using matrix = std::vector<std::vector<int>>;

Rule 7 — brace-initialize at declaration

cpp
// BEFORE
int port = 8080;
std::string host;          // uninitialized then assigned later

// AFTER
int port{8080};
std::string host{"localhost"};

Rule 8 — '\n' over std::endl

cpp
// BEFORE
std::cout << "done" << std::endl;

// AFTER
std::cout << "done" << '\n';

Rule 9 — guarded header

cpp
// BEFORE  (no guard)
#include <string>
class widget { /* ... */ };

// AFTER
#pragma once
#include <string>
class widget { /* ... */ };

Rule 10 — no file-scope using namespace in a header

cpp
// BEFORE  (in a .h)
using namespace std;
class parser { string text_; };

// AFTER
class parser { std::string text_; };

Edge cases & exceptions

• Container element count vs initializer list. Brace init means an

initializer list: std::vector<int> v{10}; is one element equal to 10. To create ten default elements, use parentheses: std::vector<int> v(10);. This parenthesis case is the one allowed exception to rule 7.

• Public aggregate struct members are snake_case without a trailing

underscore — the underscore marks private state only (rule 2).

• Out-of-line macros you cannot avoid (include guards, assert) stay

ALL_CAPS — that is exactly what rule 3 reserves caps for.

• Template type parameters may use a short PascalCase or single capital

(T, Iter) per long-standing convention; rule 1 governs ordinary identifiers, not template parameters.

• An #ifndef guard and #pragma once are interchangeable for rule 9; pick

one, do not require both.

Do / Don't

• Do: class tcp_session { int fd_; }; — Don't: class TcpSession { int m_fd; };
• Do: constexpr int buffer_size{4096}; — Don't: #define BUFFER_SIZE 4096
• Do: enum class state { idle, running }; — Don't: enum State { IDLE, RUNNING };
• Do: using byte_span = std::span<std::byte>; — Don't: typedef ... ByteSpan;
• Do: std::cout << line << '\n'; — Don't: std::cout << line << std::endl;
• Do: #pragma once at top of header — Don't: unguarded header
• Do: std::string s{name}; at declaration — Don't: std::string s; then assign

Common mistakes

• Naming a class PascalCase out of C++ habit — the std library and these

guidelines are snake_case; match them.

• Writing constants as MAX_* / DEFAULT_* in caps; caps belong to macros.
• Leaving enumerators in ALL_CAPS because "that's how enums look" — scoped

enumerators are lowercase.

• Reaching for std::endl at the end of a print — use '\n' and flush

explicitly only when you truly need to.

• Declaring a variable, then assigning on the next line. Initialize in place

with braces.

Quick checklist

• ] Every type / function / variable / namespace is lowercase snake_case
• ] Private data members end with one trailing underscore
• ] No ALL_CAPS except macro names
• ] Enumerations are enum class; enumerators lowercase
• ] Type aliases use using, not typedef
• ] Every object brace-initialized at its declaration
• ] Newlines are '\n', never std::endl
• ] Headers carry a #pragma once or include guard
• ] No using namespace at file scope in a header