The C++ Tutorial

LearnCpp.com is a free website devoted to teaching you how to program in C++. Whether you’ve had any prior programming experience or not, the tutorials on this site will walk you through all the steps to write, compile, and debug your C++ programs, all with plenty of examples.

Becoming an expert won’t happen overnight, but with a little patience, you’ll get there. And LearnCpp.com will show you the way.




Chapter 0
Introduction / Getting Started
0.1
Introduction to these tutorials
0.2
Introduction to programming languages
0.3
Introduction to C/C++
0.4
Introduction to C++ development
0.5
Introduction to the compiler, linker, and libraries
0.6
Installing an Integrated Development Environment (IDE)
0.7
Compiling your first program
0.8
A few common C++ problems
0.9
Configuring your compiler: Build configurations
0.10
Configuring your compiler: Compiler extensions
0.11
Configuring your compiler: Warning and error levels
0.12
Configuring your compiler: Choosing a language standard
Chapter 1
C++ Basics
1.1
Statements and the structure of a program
1.2
Comments
1.3
Introduction to objects and variables
1.4
Variable assignment and initialization
1.5
Introduction to iostream: cout, cin, and endl
1.6
Uninitialized variables and undefined behavior
1.7
Keywords and naming identifiers
1.8
Whitespace and basic formatting
1.9
Introduction to literals and operators
1.10
Introduction to expressions
1.11
Developing your first program
1.x
Chapter 1 summary and quiz




Chapter 2
C++ Basics: Functions and Files
2.1
Introduction to functions
2.2
Function return values (value-returning functions)
Split
2.3
Void functions (non-value returning functions)
New
2.4
Introduction to function parameters and arguments
2.5
Introduction to local scope
2.6
Why functions are useful, and how to use them effectively
2.7
Forward declarations and definitions
2.8
Programs with multiple code files
2.9
Naming collisions and an introduction to namespaces
2.10
Introduction to the preprocessor
2.11
Header files
2.12
Header guards
2.13
How to design your first programs
2.x
Chapter 2 summary and quiz
Chapter 3
Debugging C++ Programs
3.1
Syntax and semantic errors
3.2
The debugging process
3.3
A strategy for debugging
3.4
Basic debugging tactics
3.5
More debugging tactics
3.6
Using an integrated debugger: Stepping
3.7
Using an integrated debugger: Running and breakpoints
3.8
Using an integrated debugger: Watching variables
3.9
Using an integrated debugger: The call stack
3.10
Finding issues before they become problems
3.x
Chapter 3 summary and quiz
Chapter 4
Fundamental Data Types
4.1
Introduction to fundamental data types
4.2
Void
4.3
Object sizes and the sizeof operator
4.4
Signed integers
4.5
Unsigned integers, and why to avoid them
4.6
Fixed-width integers and size_t
4.7
Introduction to scientific notation
4.8
Floating point numbers
4.9
Boolean values
4.10
Introduction to if statements
4.11
Chars
4.12
Introduction to type conversion and static_cast
4.13
Const variables and symbolic constants
Updated
4.14
Compile-time constants, constant expressions, and constexpr
Split
4.15
Literals
Updated
4.16
Numeral systems (decimal, binary, hexadecimal, and octal)
New
4.17
Introduction to std::string
Updated
4.18
Introduction to std::string_view
Moved
4.x
Chapter 4 summary and quiz
Chapter 5
Operators
5.1
Operator precedence and associativity
5.2
Arithmetic operators
5.3
Modulus and Exponentiation
5.4
Increment/decrement operators, and side effects
5.5
Comma and conditional operators
5.6
Relational operators and floating point comparisons
5.7
Logical operators
5.x
Chapter 5 summary and quiz
Chapter O
Bit Manipulation (optional chapter)
O.1
Bit flags and bit manipulation via std::bitset
O.2
Bitwise operators
O.3
Bit manipulation with bitwise operators and bit masks
O.4
Converting between binary and decimal
Chapter 6
Scope, Duration, and Linkage
6.1
Compound statements (blocks)
6.2
User-defined namespaces and the scope resolution operator
6.3
Local variables
6.4
Introduction to global variables
6.5
Variable shadowing (name hiding)
6.6
Internal linkage
6.7
External linkage and variable forward declarations
6.8
Why (non-const) global variables are evil
6.9
Sharing global constants across multiple files (using inline variables)
6.10
Static local variables
6.11
Scope, duration, and linkage summary
6.12
Using declarations and using directives
6.13
Inline functions
Moved
6.14
Constexpr and consteval functions
New
6.15
Unnamed and inline namespaces
6.x
Chapter 6 summary and quiz
Chapter 7
Control Flow and Error Handling
7.1
Control flow introduction
7.2
If statements and blocks
7.3
Common if statement problems
7.4
Switch statement basics
7.5
Switch fallthrough and scoping
7.6
Goto statements
7.7
Intro to loops and while statements
7.8
Do while statements
7.9
For statements
7.10
Break and continue
7.11
Halts (exiting your program early)
7.12
Introduction to testing your code
7.13
Code coverage
7.14
Common semantic errors in C++
7.15
Detecting and handling errors
7.16
std::cin and handling invalid input
7.17
Assert and static_assert
7.18
Introduction to random number generation
Updated
7.19
Generating random numbers using Mersenne Twister
Updated
7.x
Chapter 7 summary and quiz
Updated
Chapter 8
Type Conversion and Function Overloading
8.1
Implicit type conversion (coercion)
8.2
Floating-point and integral promotion
8.3
Numeric conversions
8.4
Arithmetic conversions
8.5
Explicit type conversion (casting) and static_cast
8.6
Typedefs and type aliases
8.7
Type deduction for objects using the auto keyword
8.8
Type deduction for functions
8.9
Introduction to function overloading
8.10
Function overload differentiation
8.11
Function overload resolution and ambiguous matches
8.12
Default arguments
8.13
Function templates
8.14
Function template instantiation
8.15
Function templates with multiple template types
8.x
Chapter 8 summary and quiz
Chapter 9
Compound Types: References and Pointers
9.1
Introduction to compound data types
9.2
Value categories (lvalues and rvalues)
9.3
Lvalue references
9.4
Lvalue references to const
9.5
Pass by lvalue reference
9.6
Introduction to pointers
9.7
Null pointers
9.8
Pointers and const
9.9
Pass by address
9.10
Pass by address (part 2)
9.11
Return by reference and return by address
9.12
Type deduction with pointers, references, and const
9.x
Chapter 9 summary and quiz

The second half of chapter 9 has been moved to chapter 10.

Chapter 10
Compound Types: Enums and Structs
10.1
Introduction to program-defined (user-defined) types
10.2
Unscoped enumerations
10.3
Unscoped enumeration input and output
10.4
Scoped enumerations (enum classes)
10.5
Introduction to structs, members, and member selection
10.6
Struct aggregate initialization
10.7
Default member initialization
10.8
Struct passing and miscellany
10.9
Member selection with pointers and references
10.10
Class templates
New
10.11
Class template argument deduction (CTAD) and deduction guides
New
10.x
Chapter 10 summary and quiz
Updated
10.y
Using a language reference

Lessons in prior chapters 10-13 have been moved to chapters 11-14 to make room for chapter 9 being split.

Chapter 11
Arrays, Strings, and Dynamic Allocation
11.1
Arrays (Part I)
11.2
Arrays (Part II)
11.3
Arrays and loops
11.4
Sorting an array using selection sort
11.5
Multidimensional Arrays
11.6
C-style strings
11.7
std::string_view (part 2)
11.8
Pointers and arrays
11.9
Pointer arithmetic and array indexing
11.10
C-style string symbolic constants
11.11
Dynamic memory allocation with new and delete
11.12
Dynamically allocating arrays
11.13
For-each loops
11.14
Void pointers
11.15
Pointers to pointers and dynamic multidimensional arrays
11.16
An introduction to std::array
11.17
An introduction to std::vector
11.18
Introduction to iterators
11.19
Introduction to standard library algorithms
11.x
Chapter 11 comprehensive quiz
Chapter 12
Functions
12.1
Function Pointers
12.2
The stack and the heap
12.3
std::vector capacity and stack behavior
12.4
Recursion
12.5
Command line arguments
12.6
Ellipsis (and why to avoid them)
12.7
Introduction to lambdas (anonymous functions)
12.8
Lambda captures
12.x
Chapter 12 comprehensive quiz
Chapter 13
Basic Object-oriented Programming
13.1
Welcome to object-oriented programming
13.2
Classes and class members
13.3
Public vs private access specifiers
13.4
Access functions and encapsulation
13.5
Constructors
13.6
Constructor member initializer lists
13.7
Non-static member initialization
13.8
Overlapping and delegating constructors
13.9
Destructors
13.10
The hidden “this” pointer
13.11
Class code and header files
13.12
Const class objects and member functions
13.13
Static member variables
13.14
Static member functions
13.15
Friend functions and classes
13.16
Anonymous objects
13.17
Nested types in classes
13.18
Timing your code
13.x
Chapter 13 comprehensive quiz
Chapter 14
Operator overloading
14.1
Introduction to operator overloading
14.2
Overloading the arithmetic operators using friend functions
14.3
Overloading operators using normal functions
14.4
Overloading the I/O operators
14.5
Overloading operators using member functions
14.6
Overloading unary operators +, -, and !
14.7
Overloading the comparison operators
14.8
Overloading the increment and decrement operators
14.9
Overloading the subscript operator
14.10
Overloading the parenthesis operator
14.11
Overloading typecasts
14.12
The copy constructor
14.13
Copy initialization
14.14
Converting constructors, explicit, and delete
14.15
Overloading the assignment operator
14.16
Shallow vs. deep copying
14.17
Overloading operators and function templates
14.x
Chapter 14 comprehensive quiz
Chapter 15
Reserved for Future Reorganization
Chapter 16
An Introduction to Object Relationships
16.1
Object relationships
16.2
Composition
16.3
Aggregation
16.4
Association
16.5
Dependencies
16.6
Container classes
16.7
std::initializer_list
16.x
Chapter 16 comprehensive quiz
Chapter 17
Inheritance
17.1
Introduction to inheritance
17.2
Basic inheritance in C++
17.3
Order of construction of derived classes
17.4
Constructors and initialization of derived classes
17.5
Inheritance and access specifiers
17.6
Adding new functionality to a derived class
17.7
Calling inherited functions and overriding behavior
17.8
Hiding inherited functionality
17.9
Multiple inheritance
17.x
Chapter 17 comprehensive quiz
Chapter 18
Virtual Functions
18.1
Pointers and references to the base class of derived objects
18.2
Virtual functions and polymorphism
18.3
The override and final specifiers, and covariant return types
18.4
Virtual destructors, virtual assignment, and overriding virtualization
18.5
Early binding and late binding
18.6
The virtual table
18.7
Pure virtual functions, abstract base classes, and interface classes
18.8
Virtual base classes
18.9
Object slicing
18.10
Dynamic casting
18.11
Printing inherited classes using operator<<
18.x
Chapter 18 comprehensive quiz
Chapter 19
Templates and Classes
19.1
Template classes
19.2
Template non-type parameters
19.3
Function template specialization
19.4
Class template specialization
19.5
Partial template specialization
19.6
Partial template specialization for pointers
19.x
Chapter 19 comprehensive quiz
Chapter 20
Exceptions
20.1
The need for exceptions
20.2
Basic exception handling
20.3
Exceptions, functions, and stack unwinding
20.4
Uncaught exceptions and catch-all handlers
20.5
Exceptions, classes, and inheritance
20.6
Rethrowing exceptions
20.7
Function try blocks
20.8
Exception dangers and downsides
20.9
Exception specifications and noexcept
20.x
Chapter 20 comprehensive quiz

Chapter M
Move Semantics and Smart Pointers
M.1
Intro to smart pointers and move semantics
M.2
R-value references
M.3
Move constructors and move assignment
M.4
std::move
M.5
std::move_if_noexcept
M.6
std::unique_ptr
M.7
std::shared_ptr
M.8
Circular dependency issues with std::shared_ptr, and std::weak_ptr
M.x
Chapter M comprehensive review
Chapter 21
The Standard Template Library
21.1
The Standard Library
21.2
STL containers overview
21.3
STL iterators overview
21.4
STL algorithms overview
Chapter 22
std::string
22.1
std::string and std::wstring
22.2
std::string construction and destruction
22.3
std::string length and capacity
22.4
std::string character access and conversion to C-style arrays
22.5
std::string assignment and swapping
22.6
std::string appending
22.7
std::string inserting
Chapter 23
Input and Output (I/O)
23.1
Input and output (I/O) streams
23.2
Input with istream
23.3
Output with ostream and ios
23.4
Stream classes for strings
23.5
Stream states and input validation
23.6
Basic file I/O
23.7
Random file I/O
Appendix A
Miscellaneous Subjects
A.1
Static and dynamic libraries
A.2
Using libraries with Visual Studio
A.3
Using libraries with Code::Blocks
A.4
C++ FAQ
Appendix B
C++ Updates
B.1
Introduction to C++11
B.2
Introduction to C++14
B.3
Introduction to C++17
B.4
Introduction to C++20
Appendix C
The End
C.1
The end?