Learn from Blogs and Tutorials:

You can create any type of product documentation with Docy

Get Started
Updated on January 12, 2026

C++

Estimated reading: 1 minute 45 views

C++ Tutorial from Basics to Advanced

A complete and friendly C plus plus guide. Each topic includes the core concept, a fresh example, and a short explanation.

1. What is C++

Concept C plus plus is a compiled language that supports both low level control and high level abstractions. It is used for systems, games, high performance services, and more.

Why it matters

  • You get fine grained control over memory and performance
  • You can build safe abstractions with zero overhead
  • A rich standard library saves time

Hello program

#include 
<iostream>

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

Explanation #include imports library declarations. main is the entry point. std::cout prints text. std::endl flushes output.

2. Compile and Run

Concept You compile source files into an executable. The compiler translates code and the linker combines objects and libraries.

Example with g plus plus

g++ -std=c++20 hello.cpp -o hello
./hello

Explanation -std=c++20 selects the standard. The output file hello runs your program.

3. Program Structure and Namespaces

Concept Code lives in source files with functions, classes, and namespaces that group related names.

Example

#include 
<iostream>

namespace greet {
    void say(const std::string& who) {
        std::cout << "Hi " << who << "\n";
    }
}

int main() {
    greet::say("Aarav");
}

Explanation Use namespace::name to refer to items in a namespace. Avoid using namespace std in headers.

4. Variables and Basic Types

Concept Types define the shape and size of data. C plus plus types include integers, floating point, booleans, and characters.

Example

#include 
<iostream>
#include 
<cstdint>

int main() {
    int count = 42;
    unsigned long uid = 1000000UL;
    std::int32_t x = 123;
    double rate = 2.75;
    bool active = true;
    char initial = 'K';
    std::cout << count << " " << rate << " " << active << " " << initial << "\n";
}

Explanation Fixed width types like std::int32_t give predictable size. Choose signed or unsigned carefully.

5. Constants and Type Deduction

Concept Constants prevent changes. auto lets the compiler deduce types from initializers.

Example

#include 
<iostream>

int main() {
    const double pi = 3.141592653589793;
    constexpr int max_size = 1024;
    auto message = std::string("ready");
    auto ratio = 1.0f; // float
    std::cout << pi << " " << max_size << " " << message << " " << ratio << "\n";
}

Explanation const is run time constant. constexpr is compile time constant when possible. auto keeps code clear and avoids repetition.

6. Input and Output

Concept Use iostreams for text I O and iomanip for formatting.

Example

#include 
<iostream>
#include 
<iomanip>
#include 
<string>

int main() {
    std::string name;
    int age{};
    std::cout << "Name and age: ";
    std::cin >> name >> age;
    std::cout << std::fixed << std::setprecision(2);
    std::cout << "Welcome " << name << ", age " << age << ", score " << 95.6789 << "\n";
}

Explanation Streams use << and >> operators. Manipulators like std::setprecision control formatting.

7. Control Flow

Concept Conditionals and loops direct execution.

Example

#include 
<iostream>

int main() {
    int temp = 33;
    if (temp >= 40) {
        std::cout << "Too hot\n";
    } else if (temp >= 30) {
        std::cout << "Warm\n";
    } else {
        std::cout << "Cool\n";
    }

    for (int i = 0; i < 5; ++i) {
        if (i == 2) continue;
        if (i == 4) break;
        std::cout << "i " << i << "\n";
    }

    int n = 3;
    while (n > 0) {
        std::cout << n << "\n";
        --n;
    }
}

Explanation if else branches by condition. for counts or iterates. while repeats until a condition changes.

8. Functions and Overloading

Concept Functions group logic. You can define multiple functions with the same name but different parameter lists.

Example

#include 
<iostream>
#include 
<string>

int add(int a, int b) { return a + b; }
double add(double a, double b) { return a + b; }
std::string add(const std::string& a, const std::string& b) { return a + b; }

int main() {
    std::cout << add(2, 3) << "\n";
    std::cout << add(2.5, 1.25) << "\n";
    std::cout << add(std::string("ab"), "cd") << "\n";
}

Explanation Overload resolution picks the best match. Return type alone cannot differentiate overloads.

9. References and Pointers

Concept References alias an object and must bind to a valid object. Pointers hold addresses and can be null.

Example

#include 
<iostream>

void bump(int& v) { v += 1; }
void maybe_bump(int* p) { if (p) *p += 1; }

int main() {
    int x = 10;
    bump(x);
    std::cout << x << "\n";
    maybe_bump(&x);
    std::cout << x << "\n";
}

Explanation Use references for required arguments. Use pointers for optional or nullable parameters.

10. Strings and String Views

Concept std::string owns text. std::string_view is a cheap non owning view of text.

Example

#include 
<iostream>
#include 
<string>
#include 
<string_view>

void shout(std::string_view sv) {
    for (char c : sv) std::cout << char(std::toupper(static_cast<unsigned char>(c)));
    std::cout << "\n";
}

int main() {
    std::string name = "Meera";
    shout(name);
    shout("hello world");
}

Explanation Prefer string_view for read only parameters to avoid copies. Keep the view from outliving the data.

11. Arrays and Vectors

Concept Fixed size arrays live on the stack. std::vector is a dynamic array that can grow.

Example

#include 
<iostream>
#include 
<vector>
#include 
<numeric>

int main() {
    int fixed[3] = {3, 5, 7};
    std::vector
<int> scores = {82, 91, 76, 88, 95};
    scores.push_back(99);
    int total = std::accumulate(scores.begin(), scores.end(), 0);
    double avg = double(total) / scores.size();
    std::cout << fixed[0] << " avg " << avg << "\n";
}

Explanation Vectors manage memory automatically. Iterators provide standard access to elements.

12. Range based for and Iterators

Concept Range based for loops simplify iteration. Iterators are generalized pointers used by containers.

Example

#include 
<iostream>
#include 
<map>

int main() {
    std::map<std::string, int> freq{{"apple", 3}, {"banana", 2}, {"cherry", 5}};
    for (const auto& [word, count] : freq) {
        std::cout << word << " " << count << "\n";
    }
}

Explanation Structured bindings unpack pairs. Iteration uses begin and end under the hood.

13. Classes and Objects

Concept Classes combine data and behavior. Use access control to protect invariants.

Example

#include 
<iostream>
#include 
<stdexcept>

class BankAccount {
    std::string owner_;
    double balance_{};
public:
    BankAccount(std::string owner, double initial)
        : owner_(std::move(owner)), balance_(initial) {}

    void deposit(double amount) {
        if (amount <= 0) throw std::invalid_argument("amount must be positive");
        balance_ += amount;
    }

    void withdraw(double amount) {
        if (amount > balance_) throw std::runtime_error("insufficient funds");
        balance_ -= amount;
    }

    double balance() const { return balance_; }
};

int main() {
    BankAccount acct("Neel", 500);
    acct.deposit(200);
    std::cout << acct.balance() << "\n";
}
``]
Explanation  
Constructors initialize state. `const` methods promise not to modify the object.

## 14. Constructors, Destructors, and RAII
Concept  
RAII means Resource Acquisition Is Initialization. Manage resources by tying them to object lifetimes.

Example
```cpp
#include 
<iostream>
#include 
<cstdio>

class File {
    std::FILE* f_{};
public:
    explicit File(const char* path, const char* mode) {
        f_ = std::fopen(path, mode);
        if (!f_) throw std::runtime_error("open failed");
    }
    ~File() {
        if (f_) std::fclose(f_);
    }
    void write_line(const std::string& line) {
        std::fprintf(f_, "%s\n", line.c_str());
    }
};

int main() {
    File out("log.txt", "w");
    out.write_line("hello");
}

Explanation The destructor releases resources automatically even on exceptions. This pattern prevents leaks.

15. Copy and Move Semantics

Concept Copy duplicates state. Move transfers ownership from one object to another to avoid expensive copies.

Example

#include 
<iostream>
#include 
<vector>

struct Buffer {
    std::vector
<int> data;
    Buffer() = default;
    explicit Buffer(std::size_t n) : data(n) {}

    Buffer(const Buffer& other) = default;              // copy
    Buffer(Buffer&& other) noexcept = default;          // move
    Buffer& operator=(const Buffer& other) = default;   // copy assign
    Buffer& operator=(Buffer&& other) noexcept = default; // move assign
};

int main() {
    Buffer a(1'000'000);
    Buffer b = std::move(a); // moves data
    std::cout << b.data.size() << "\n";
}

Explanation Move avoids allocation and copying. After a move the source remains valid but unspecified.

16. Operator Overloading

Concept You can define how operators work for your types to improve readability.

Example

#include 
<iostream>

struct Point {
    int x{}, y{};
    Point operator+(const Point& rhs) const { return {x + rhs.x, y + rhs.y}; }
    bool operator==(const Point& rhs) const { return x == rhs.x && y == rhs.y; }
};

std::ostream& operator<<(std::ostream& os, const Point& p) {
    return os << "(" << p.x << "," << p.y << ")";
}

int main() {
    Point a{2, 3}, b{4, 1};
    Point c = a + b;
    std::cout << c << " equal " << std::boolalpha << (c == Point{6, 4}) << "\n";
}

Explanation Prefer nonmember operators when the left operand should allow implicit conversions.

17. Templates and Generic Programming

Concept Templates allow writing code that works with many types while staying fast and type safe.

Example

#include 
<iostream>
#include 
<type_traits>

template <class T>
T clamp(T v, T lo, T hi) {
    if (v < lo) return lo;
    if (v > hi) return hi;
    return v;
}

int main() {
    std::cout << clamp(15, 0, 10) << "\n";
    std::cout << clamp(2.5, 0.0, 1.0) << "\n";
}

Explanation Code is generated for each type used. Constraints can improve error messages and safety.

18. Concepts in C++

Concept Concepts constrain template parameters with readable rules.

Example

#include 
<concepts>
#include 
<iostream>

template <std::totally_ordered T>
T midpoint(T a, T b) {
    return a + (b - a) / 2;
}

int main() {
    std::cout << midpoint(2, 8) << "\n";
    std::cout << midpoint(2.0, 8.0) << "\n";
}

Explanation If a type does not meet the concept the error is clear. You can write custom concepts.

19. Exceptions and Error Handling

Concept Use exceptions for exceptional conditions. Use error codes or std::expected like patterns where exceptions are not desired.

Example

#include 
<iostream>
#include 
<stdexcept>

double divide(double a, double b) {
    if (b == 0) throw std::runtime_error("division by zero");
    return a / b;
}

int main() {
    try {
        std::cout << divide(10, 2) << "\n";
        std::cout << divide(1, 0) << "\n";
    } catch (const std::exception& e) {
        std::cout << "error " << e.what() << "\n";
    }
}

Explanation Throw by value catch by reference. Keep exceptions for unexpected failures.

20. Smart Pointers

Concept Smart pointers manage dynamic memory automatically.

Example

#include 
<iostream>
#include 
<memory>

struct Node {
    int v{};
    std::unique_ptr
<Node> next;
    explicit Node(int x) : v{x} {}
};

int main() {
    auto head = std::make_unique
<Node>(1);
    head->next = std::make_unique
<Node>(2);
    std::cout << head->v << " " << head->next->v << "\n";

    auto shared = std::make_shared
<int>(42);
    std::weak_ptr
<int> weak = shared;
    std::cout << *shared << "\n";
}

Explanation unique_ptr has single ownership. shared_ptr has shared ownership with reference counting. weak_ptr observes without owning.

21. Standard Library Containers

Concept Pick the right container for your access pattern.

Example

#include 
<iostream>
#include 
<vector>
#include 
<list>
#include 
<deque>
#include 
<unordered_map>

int main() {
    std::vector
<int> a{1, 2, 3};           // contiguous
    std::list
<int> b{4, 5, 6};             // stable iterators
    std::deque
<int> c{7, 8, 9};            // fast push front and back
    std::unordered_map<std::string, int> count{{"cat", 2}, {"dog", 3}};

    a.push_back(4);
    b.push_front(3);
    c.push_front(6);
    count["fish"] = 1;

    std::cout << a.back() << " " << b.front() << " " << c.front() << " " << count["dog"] << "\n";
}

Explanation Vectors are default choice. Use unordered map for average constant time key access.

22. Algorithms and Lambdas

Concept Standard algorithms work with iterators. Lambdas are inline functions for quick operations.

Example

#include 
<algorithm>
#include 
<iostream>
#include 
<vector>

int main() {
    std::vector
<int> v{9, 2, 7, 4, 5};
    std::sort(v.begin(), v.end(), [](int a, int b) { return a < b; });
    auto it = std::find_if(v.begin(), v.end(), [](int x) { return x % 2 == 0; });
    for (int x : v) std::cout << x << " ";
    std::cout << "\nfirst even " << (it != v.end() ? std::to_string(*it) : "none") << "\n";
}

Explanation Algorithms separate what from how. Lambdas capture variables if needed with capture lists.

23. Ranges in C plus plus 20

Concept Ranges provide composable views and pipeline style algorithms.

Example

#include 
<iostream>
#include 
<vector>
#include 
<ranges>

int main() {
    std::vector
<int> v{1, 2, 3, 4, 5, 6};
    auto even_squares = v
        | std::views::filter([](int x){ return x % 2 == 0; })
        | std::views::transform([](int x){ return x * x; });

    for (int x : even_squares) std::cout << x << " ";
    std::cout << "\n";
}

Explanation Views are lazy and cheap. Compose filters and transforms without intermediate containers.

24. Filesystem and I O

Concept Use `

` to work with paths and files in a portable way. Example “`cpp #include #include #include int main() { namespace fs = std::filesystem; fs::path p = “notes.txt”; std::ofstream out(p); out << "learn cplusplus daily\n"; std::cout << "size " << fs::file_size(p) << "\n"; } “` Explanation `std::filesystem` offers path joins, iteration, status queries, and operations like copy and remove. ## 25. Time and Chrono Concept `std::chrono` provides strong typed time points and durations. Example “`cpp #include #include #include int main() { using namespace std::chrono; auto start = steady_clock::now(); std::this_thread::sleep_for(150ms); auto elapsed = duration_cast (steady_clock::now() – start).count(); std::cout << "elapsed " << elapsed << " ms\n"; } “` Explanation Use `steady_clock` for measuring intervals. Use duration types instead of raw integers. ## 26. Concurrency with Threads Concept Threads run tasks in parallel. Use mutexes to protect shared data and futures for results. Example “`cpp #include #include #include #include int main() { std::mutex m; int counter = 0; auto worker = [&] { for (int i = 0; i < 100000; ++i) { std::scoped_lock lock(m); ++counter; } }; std::thread t1(worker), t2(worker); t1.join(); t2.join(); std::cout << counter << "\n"; } “` Explanation `std::scoped_lock` releases the mutex automatically. Always join or detach threads. ## 27. Async and Task based Concurrency Concept `std::async` runs work potentially on another thread and returns a `std::future`. Example “`cpp #include #include #include #include long sum_range(const std::vector & v) { return std::accumulate(v.begin(), v.end(), 0L); } int main() { std::vector data(1’000’000, 1); auto fut = std::async(std::launch::async, sum_range, std::cref(data)); std::cout << fut.get() << "\n"; } “` Explanation `future.get()` waits for the result. Use launch policies to control execution. ## 28. std optional and variant and any Concept Use `std::optional` for maybe values, `std::variant` for tagged unions, `std::any` for type erasure. Example “`cpp #include #include #include #include std::optional parse_int(std::string_view s) { int v{}; try { size_t pos{}; v = std::stoi(std::string{s}, &pos); if (pos != s.size()) return std::nullopt; return v; } catch (…) { return std::nullopt; } } int main() { auto res = parse_int(“123”); std::cout << (res ? *res : -1) << "\n"; std::variant v = std::string(“ok”); std::visit([](auto&& x){ std::cout << x << "\n"; }, v); std::any a = 42; std::cout << std::any_cast(a) << "\n"; } “` Explanation Optional signals absence without sentinel values. Variant enforces exhaustive handling. ## 29. Regular Expressions Concept Regex searches and matches text patterns. Example “`cpp #include #include #include int main() { std::string s = “Order AB1234 Ref XY987″; std::regex r(R”([A-Z]{2}\d{3,4})”); for (std::sregex_iterator it(s.begin(), s.end(), r), end; it != end; ++it) { std::cout <str() << "\n"; } } “` Explanation Use raw string literals for readability. Iterators collect all matches. ## 30. Memory Management Basics Concept Prefer automatic storage and standard containers. Use new and delete only when necessary. Example ~~~cpp #include #include int main() { int stack_value = 5; auto heap_value = std::make_unique (7); std::cout << stack_value << " " << *heap_value << "\n"; } “] Explanation Smart pointers are safer than raw owning pointers. Avoid manual delete. ## 31. Compile time Programming with constexpr Concept `constexpr` allows evaluation at compile time for speed and safety. Example “`cpp #include #include constexpr int fib(int n) { return n <= 1 ? n : fib(n – 1) + fib(n – 2); } int main() { constexpr int n = fib(10); std::array arr{}; // size known at compile time std::cout << n << " " << arr.size() << "\n"; } ~~~ Explanation Functions and values marked `constexpr` can be computed at compile time when given constant arguments. ## 32. Modules in C ++ Concept Modules replace textual includes with compiled partitions for faster and cleaner builds. Note Tool support varies. Example uses pseudo portable syntax. Example split “`cpp // mathx.ixx export module mathx; export int square(int x) { return x * x; } // main.cpp import mathx; #include int main() { std::cout << square(7) << "\n"; } “` Explanation `export` makes names visible to importers. Build settings depend on your compiler. ## 33. Formatting with std format C plus plus 20 Concept `std::format` provides Python like formatting with type safety. Example “`cpp #include #include #include int main() { std::string s = std::format(“Hello {} score {:.2f}”, “Asha”, 93.456); std::cout << s << "\n"; } “` Explanation Placeholders use braces. Format specifiers control precision and alignment. ## 34. Building with CMake Concept CMake is a meta build system that generates native build files. Example CMakeLists txt “`cmake cmake_minimum_required(VERSION 3.20) project(demo LANGUAGES CXX) set(CMAKE_CXX_STANDARD 20) add_executable(app main.cpp) “` Build “`bash cmake -S . -B build cmake –build build “` Explanation Configure once then build. Add libraries with `target_link_libraries`. ## 35. Testing with Catch2 Concept Unit tests verify behavior and prevent regressions. Example “`cpp // CMake fetch or vendor Catch2 v3 #define CATCH_CONFIG_MAIN #include int add(int a, int b) { return a + b; } TEST_CASE(“add works”) { REQUIRE(add(2, 3) == 5); REQUIRE(add(-1, 1) == 0); } “` Explanation Tests are easy to write and read. Integrate into CI to run on each change. ## 36. Performance Tips Concept Measure before optimizing. Choose the right data structures and algorithms. Guidelines – Use `-O2` or `-O3` for release builds – Prefer `std::array` or `std::vector` for cache friendly layout – Avoid virtual dispatch in tight loops when possible – Use move semantics to reduce copies – Profile with tools like perf or VTune or Instruments Explanation Focus on hot paths identified by profiling. Micro optimizations without data rarely help. ## 37. Common Pitfalls and Safety Concept Avoid undefined behavior and resource leaks. Checklist – Initialize variables – Respect lifetime of references and views – Do not dereference null or dangling pointers – Keep exception safe code with RAII – Enable warnings and sanitizers during development Explanation Use flags like `-Wall -Wextra -Werror` and sanitizers like AddressSanitizer and UndefinedBehaviorSanitizer. ## 38. Mini Project Putting It All Together Concept Combine parsing, containers, algorithms, and filesystem. Task Read a CSV file of items with price and quantity then compute total revenue and list top N by revenue. Example “`cpp #include #include #include #include #include #include #include #include struct Item { std::string name; double price{}; int qty{}; double revenue() const { return price * qty; } }; std::vector read_csv(const std::filesystem::path& p) { std::vector out; std::ifstream in(p); std::string line; // expected header: name,price,qty std::getline(in, line); while (std::getline(in, line)) { std::stringstream ss(line); std::string name, price, qty; std::getline(ss, name, ‘,’); std::getline(ss, price, ‘,’); std::getline(ss, qty, ‘,’); if (!name.empty()) out.push_back({name, std::stod(price), std::stoi(qty)}); } return out; } int main() { auto items = read_csv(“sales.csv”); double total = 0.0; for (const auto& it : items) total += it.revenue(); std::sort(items.begin(), items.end(), [](const Item& a, const Item& b) { return a.revenue() > b.revenue(); }); std::cout << "total revenue " << total << "\n"; std::cout << "top 3\n"; for (size_t i = 0; i < std::min(3, items.size()); ++i) { std::cout << items[i].name << " " << items[i].revenue() << "\n"; } } “` Explanation Parses CSV with string streams. Uses a struct for records, algorithms for sorting, and a simple aggregation.

Leave a Comment

Share this Doc

C++

Or copy link

CONTENTS

Powered By EazyDocs