Core Syntax

Basic program shape

#include <iostream>

int main() {
    std::cout << "Hello, C++\n";
    return 0;
}

Common fundamental types

• bool
• char, wchar_t, char8_t, char16_t, char32_t
• short, int, long, long long
• Unsigned versions of integer types
• float, double, long double
• void

Variables and initialization

int a = 1;          // copy initialization
int b(2);           // direct initialization
int c{3};           // brace initialization
const int d = 4;    // immutable
constexpr int e = 5; // compile-time constant
auto name = std::string{"Ada"};

References and qualifiers

int value = 10;
int& ref = value;          // lvalue reference
const int& cref = value;   // read-only reference
int&& rref = 42;           // rvalue reference

Operators

• Arithmetic: + - * / %
• Comparison: == != < <= > >=
• Logical: && || !
• Bitwise: & | ^ ~ << >>
• Assignment: = += -= *= /= %=
• Member access: ., ->, ::
• Ternary: condition ? a : b

int total = price * count;
bool ready = total > 0 && connected;
auto label = ready ? "ok" : "pending";

These are not just symbols to memorize. They are the core vocabulary for state updates, branching, and object access.

Casts

double x = 3.9;
int i = static_cast<int>(x);
Base* base = dynamic_cast<Base*>(ptr);
const char* raw = reinterpret_cast<const char*>(buffer);

• static_cast: normal explicit conversions
• dynamic_cast: safe downcasts in polymorphic hierarchies
• const_cast: add or remove constness only when the underlying object really permits it
• reinterpret_cast: last-resort low-level bit reinterpretation

Prefer the narrowest cast that expresses the intended boundary.

Namespaces and aliases

namespace math {
    int square(int x) { return x * x; }
}

using Index = std::size_t;
namespace fs = std::filesystem;

Aliases help when a type or namespace is verbose, but keep them local enough that readers can still tell what they refer to.

Best-practice reminders

• Prefer auto when the type is obvious from the initializer.
• Prefer brace initialization to reduce narrowing.
• Use const by default.
• Use constexpr for values known at compile time.
• Avoid C-style casts.

auto, decltype, and deduction

std::vector<int> values{1, 2, 3};
auto it = values.begin();          // iterator type deduced
decltype(values.size()) count = values.size();

• auto follows the initializer and usually drops top-level const.
• auto& keeps reference semantics.
• decltype(expr) asks the compiler for the exact type of an expression.

const int value = 42;
auto copy = value;   // int
auto& ref = value;   // const int&

This is one of the first deduction rules worth remembering because it affects mutation and copying.

Useful modern keywords and attributes

[[nodiscard]] int parse(std::string_view text);
constinit inline int global_counter = 0;

consteval int version() {
    return 23;
}

• [[nodiscard]] catches ignored results that probably matter.
• constinit guarantees static initialization without forcing constness.
• consteval requires evaluation at compile time.

Comparison and aggregate improvements

struct Point {
    int x{};
    int y{};
    auto operator<=>(const Point&) const = default;
};

Point p{.x = 3, .y = 4};

• Defaulted <=> can generate all comparison operators.
• Designated initializers work for aggregates and make field intent explicit.

Declaration vocabulary to remember

• storage duration: automatic, static, thread, dynamic
• qualifiers: const, volatile, mutable
• linkage: internal, external, no linkage
• value categories: lvalue, xvalue, prvalue

Understanding those terms makes later topics such as templates, move semantics, and linkage errors much easier to reason about.

Translation units and headers

#include <vector>
#include "widget.hpp"

• a source file plus the headers it includes becomes a translation unit
• declarations tell the compiler what exists
• definitions provide storage or full function/class bodies
• one-definition-rule bugs often come from putting definitions in the wrong place

Operator groups that matter in real code

• arithmetic and bitwise operators for numeric work
• comparison operators for ordering and equality
• assignment and compound assignment for state updates
• member access, call, and subscript operators for object interaction
• casts and conversion operators for explicit boundary changes

Syntax habits worth keeping

• prefer brace initialization when narrowing would be a bug
• prefer const and constexpr when a value should not change
• avoid C-style casts because they hide intent
• keep declarations close to first use instead of piling them at the top of a block