Types and Data

C++ is statically typed: the type of every value is fixed at compile time. The compiler uses that knowledge both to catch mistakes and to generate fast code. This chapter tours the fundamental types, strings, the most common standard containers, and the ways you define your own types with classes, structs and scoped enums.

Fundamental types

The standard only puts lower bounds on the size of int. When the exact width matters, use the fixed-width aliases from <cstdint> such as std::int32_t or std::uint64_t. The apostrophes inside a number are digit separators, available since C++14.

std::string

Prefer std::string from <string> over raw character arrays. It manages its own memory and knows its length.

#include <iostream>
#include <string>

int main() {
    std::string s{"Hello"};
    s += ", world";                       // append
    std::cout << s.size() << '\n';        // 12
    std::cout << s.substr(0, 5) << '\n';  // "Hello"

    if (auto pos = s.find("world"); pos != std::string::npos) {
        std::cout << "found at " << pos << '\n';
    }
    int n = std::stoi("123");              // string to int
    std::string t = std::to_string(n + 1); // int to string
}

For read-only string parameters, take const std::string& or, since C++17, std::string_view. A string_view does not own its characters; it just points at someone else's, so it must never outlive the string it refers to.

Standard containers

#include <array>
#include <iostream>
#include <map>
#include <string>
#include <vector>

int main() {
    std::vector<int> nums{3, 1, 4};
    nums.push_back(1);
    std::cout << nums.size() << ' ' << nums[0] << '\n'; // 4 3

    std::array<double, 3> point{1.0, 2.0, 3.0};
    std::cout << point.at(2) << '\n';  // at() checks the index

    std::map<std::string, int> stock;
    stock["apple"] = 5;
    stock["banana"] = 2;
    for (const auto& [name, qty] : stock) {   // C++17 structured bindings
        std::cout << name << ": " << qty << '\n';
    }
    if (stock.contains("apple")) { /* C++20 */ }
}

operator[] on a vector does no bounds checking, and an out-of-range index is undefined behavior. Use at() or check the size when you aren't sure. Also note that operator[] on a std::map inserts a default-constructed value when the key is missing, which can surprise you during lookups.

Classes

A class bundles data (member variables) with behavior (member functions). Making the data private means only the class itself can modify it, so it can guarantee that its objects always stay in a valid state.

#include <stdexcept>
#include <string>
#include <utility>

class Account {
public:
    explicit Account(std::string owner, long long balance = 0)
        : owner_{std::move(owner)}, balance_{balance} {   // member initializer list
        if (balance_ < 0) throw std::invalid_argument("negative balance");
    }

    void deposit(long long amount) { balance_ += amount; }
    long long balance() const { return balance_; }         // const member function
    const std::string& owner() const { return owner_; }

private:
    std::string owner_;
    long long balance_;
};

// Account a{"Kim", 1000};
// a.deposit(500);   // a.balance() == 1500

Constructors initialize members through the member initializer list after the colon. explicit stops a single-argument constructor from being used for implicit conversions you didn't ask for. Member functions that don't modify the object are marked const, which lets you call them on const objects and references.

Structs and enum class

The only language difference between struct and class is the default access: members of a struct are public. By convention, struct is used for plain bundles of data with no invariants to protect. For enumerations, prefer enum class: its enumerators are scoped and don't convert silently to integers.

#include <string>

enum class Color { Red, Green, Blue };

struct Pixel {
    int x = 0;
    int y = 0;
    Color color = Color::Red;
};

std::string to_string(Color c) {
    switch (c) {
        case Color::Red:   return "red";
        case Color::Green: return "green";
        case Color::Blue:  return "blue";
    }
    return "unknown";
}

// Pixel p{10, 20, Color::Blue};          // aggregate initialization
// int raw = static_cast<int>(p.color);   // explicit when you need the number

Summary

• Use the <cstdint> fixed-width types when integer size matters.
• Store text in std::string; accept read-only text as const std::string& or std::string_view.
• Reach for std::vector first, std::array for fixed sizes, and std::map or std::unordered_map for key-value data.
• Use a class with private members for types that enforce invariants, and a struct for plain data.
• Prefer enum class over plain enum.