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
2.3
Introduction to function parameters and arguments
2.4
Introduction to local scope
2.5
Why functions are useful, and how to use them effectively
2.6
Forward declarations and definitions
2.7
Programs with multiple code files
2.8
Naming collisions and an introduction to namespaces
2.9
Introduction to the preprocessor
2.10
Header files
2.11
Header guards
2.12
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
New
4.13
An introduction to std::string
Moved
4.14
Literals
4.15
Const, constexpr, and symbolic constants
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
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
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.x
Chapter 7 summary and quiz

Jun 18: Chapter 8 is newly added.

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 (under construction)
9.1
Using a language reference
9.2
Enumerated types
9.3
Enum classes
9.4
Structs
9.5
Random number generation
9.x
Chapter 9 summary and quiz
Chapter 10
Arrays, Strings, Pointers, and References
10.1
Arrays (Part I)
10.2
Arrays (Part II)
10.3
Arrays and loops
10.4
Sorting an array using selection sort
10.5
Multidimensional Arrays
10.6
C-style strings
10.7
An introduction to std::string_view
10.8
Introduction to pointers
10.9
Null pointers
10.10
Pointers and arrays
10.11
Pointer arithmetic and array indexing
10.12
C-style string symbolic constants
10.13
Dynamic memory allocation with new and delete
10.14
Dynamically allocating arrays
10.15
Pointers and const
10.16
Reference variables
10.17
References and const
10.18
Member selection with pointers and references
10.19
For-each loops
10.20
Void pointers
10.21
Pointers to pointers and dynamic multidimensional arrays
10.22
An introduction to std::array
10.23
An introduction to std::vector
10.24
Introduction to iterators
10.25
Introduction to standard library algorithms
10.x
Chapter 10 comprehensive quiz
Chapter 11
Functions
11.1
Function parameters and arguments
11.2
Passing arguments by value
11.3
Passing arguments by reference
11.4
Passing arguments by address
11.5
Returning values by value, reference, and address
11.6
Inline functions
11.7
Function Pointers
11.8
The stack and the heap
11.9
std::vector capacity and stack behavior
11.10
Recursion
11.11
Command line arguments
11.12
Ellipsis (and why to avoid them)
11.13
Introduction to lambdas (anonymous functions)
11.14
Lambda captures
11.x
Chapter 11 comprehensive quiz
Chapter 12
Basic Object-oriented Programming
12.1
Welcome to object-oriented programming
12.2
Classes and class members
12.3
Public vs private access specifiers
12.4
Access functions and encapsulation
12.5
Constructors
12.6
Constructor member initializer lists
12.7
Non-static member initialization
12.8
Overlapping and delegating constructors
Updated
12.9
Destructors
12.10
The hidden “this” pointer
12.11
Class code and header files
12.12
Const class objects and member functions
12.13
Static member variables
12.14
Static member functions
12.15
Friend functions and classes
12.16
Anonymous objects
12.17
Nested types in classes
12.18
Timing your code
12.x
Chapter 12 comprehensive quiz
Chapter 13
Operator overloading
13.1
Introduction to operator overloading
13.2
Overloading the arithmetic operators using friend functions
13.3
Overloading operators using normal functions
13.4
Overloading the I/O operators
13.5
Overloading operators using member functions
13.6
Overloading unary operators +, -, and !
13.7
Overloading the comparison operators
13.8
Overloading the increment and decrement operators
13.9
Overloading the subscript operator
13.10
Overloading the parenthesis operator
13.11
Overloading typecasts
13.12
The copy constructor
13.13
Copy initialization
13.14
Converting constructors, explicit, and delete
13.15
Overloading the assignment operator
13.16
Shallow vs. deep copying
13.17
Overloading operators and function templates
13.x
Chapter 13 comprehensive quiz
Chapter 14
Reserved for Future Reorganization
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
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?