Best Practices and Coding Standards — C++ Core Guidelines, Naming Conventions, Code Review, Modern C++ Style

// Types: PascalCase
class BankAccount {};
struct Point2D {};
enum class Color {};
using StringList = std::vector<std::string>;
template <typename ValueType>
class Container {};

// Functions, variables, members: snake_case
int get_account_balance() const;
double calculate_total(const std::vector<double>& prices);
std::string user_name;           // local variable
int file_descriptor_;            // class member (trailing _)
static constexpr int k_max_size = 1024;  // constants: k prefix

// Macros: UPPER_SNAKE_CASE (minimize use)
#define DEBUG_LOG(msg) std::cerr << msg << "\n"
#define MAX_BUFFER_SIZE 4096

// Template parameters: PascalCase or Capital letters
template <typename T, typename Allocator>
class Vector;

// Namespaces: lowercase
namespace networking { namespace http { class Request {}; }}
using namespace networking::http;

#include <iostream>
#include <vector>
#include <string>

// Const parameters
void print(const std::string& text, int times);  // text won't be modified

// Const member functions
class Person {
    std::string name_;
    int age_;
public:
    // Getter: const because it doesn't modify the object
    const std::string& name() const { return name_; }
    int age() const { return age_; }

    // Setter: not const
    void set_age(int age) { age_ = age; }
};

// Const iterators for read-only access
void print_all(const std::vector<int>& v) {
    for (const auto& elem : v) {
        std::cout << elem << " ";
    }
}

// Const pointers vs pointer to const
const int* ptr_to_const;  // Cannot modify what ptr points to
int* const const_ptr;     // Cannot modify ptr itself
const int* const const_ptr_to_const;  // Both

// Constexpr for compile-time values
constexpr double PI = 3.14159;
constexpr int factorial(int n) { return n <= 1 ? 1 : n * factorial(n - 1); }

// 1. Smart pointers vs raw pointers
// OLD:
Object* ptr = new Object();
delete ptr;

// MODERN:
auto ptr = std::make_unique<Object>();     // Unique ownership
auto shared = std::make_shared<Object>();  // Shared ownership

// 2. Algorithms vs manual loops
// OLD:
std::vector<int> v = {3, 1, 4, 1, 5};
std::vector<int> evens;
for (size_t i = 0; i < v.size(); ++i) {
    if (v[i] % 2 == 0) evens.push_back(v[i]);
}

// MODERN:
auto evens = v | std::views::filter([](int x) { return x % 2 == 0; });

// 3. nullptr vs NULL/0
// OLD: int* ptr = NULL;
// MODERN:
int* ptr = nullptr;

// 4. Range-for vs index
// OLD:
for (int i = 0; i < v.size(); ++i) std::cout << v[i];
// MODERN:
for (const auto& elem : v) std::cout << elem;

// 5. Override keyword
class Base { virtual void func() {}; };
class Derived : public Base {
    // OLD: void func();
    // MODERN:
    void func() override;  // Compiler checks it overrides
};

// 6. enum class vs plain enum
// OLD:
enum Color { RED, GREEN, BLUE };  // Pollutes namespace
// MODERN:
enum class Color { Red, Green, Blue };  // Scoped

// 7. auto for type deduction
// OLD:
std::vector<int>::iterator it = v.begin();
// MODERN:
auto it = v.begin();

// 8. Lambda vs functor
// OLD: struct Adder { int operator()(int a, int b) { return a + b; } };
// MODERN:
auto adder = [](int a, int b) { return a + b; };

// 1. No raw new/delete
void bad() {
    auto* p = new int(5);
    // ... if something throws: leak!
    delete p;
}

// 2. No C-style casts
double pi = 3.14;
// int x = (int)pi;           // BAD
int x = static_cast<int>(pi); // GOOD

// 3. No #define for constants
// #define MAX_SIZE 100       // BAD
constexpr int k_max_size = 100; // GOOD

// 4. No using namespace std in headers
using namespace std; // BAD in headers — pollutes all includers

// 5. No macros for functions
// #define SQUARE(x) x*x      // BAD (x+1)*(x+1)? No!
template <typename T>
constexpr T square(T x) { return x * x; } // GOOD

// 6. No trailing underscores for local variables
int count_; // BAD: looks like member variable
int count;  // GOOD

// 7. No global mutable state (unless absolutely necessary)
int global_counter = 0;  // BAD: thread-unsafe, unpredictable

// 8. No manual memory management
// std::vector<int>* vec = new std::vector<int>();  // BAD
std::vector<int> vec;  // GOOD

# clang-tidy — static analysis
clang-tidy --checks='modernize-*,cppcoreguidelines-*' source.cpp

# clang-format — code formatting
clang-format -i --style=Google source.cpp

# AddressSanitizer (ASan) — memory errors
g++ -fsanitize=address -g -O1 -o program program.cpp

# UndefinedBehaviorSanitizer (UBSan)
g++ -fsanitize=undefined -g -O1 -o program program.cpp

# ThreadSanitizer (TSan) — data races
g++ -fsanitize=thread -g -O1 -o program -lpthread program.cpp

# Valgrind — comprehensive memory analysis
valgrind --leak-check=full ./program

# Include What You Use
iwyu source.cpp

// .clang-format — Google style
BasedOnStyle: Google
IndentWidth: 4
ColumnLimit: 100
AllowShortFunctionsOnASingleLine: Inline

// review_me.cpp — find and fix all guideline violations
#include <iostream>
#include <vector>
#include <string>

#define MAX_SIZE 100

class data {
public:
    char* buffer;
    int size;
    data(int s) { buffer = new char[s]; size = s; }
    ~data() { delete buffer; }
};

int* get_ptr() {
    int x = 42;
    return &x;
}

void process(data d) {
    for (int i = 0; i <= d.size; i++) {
        d.buffer[i] = 'a';
    }
}

int main() {
    data d(10);
    process(d);

    int* p = get_ptr();
    std::cout << *p << "\n";

    std::vector<int> v;
    for (int i = 0; i < 100; i++) v[i] = i;

    return 0;
}