Learn C++

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)
  • 2.3: Void functions (non-value returning functions)
  • 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: Introduction to std::string
  • 4.14: Literal constants
  • 4.15: Symbolic constants: const and constexpr variables
  • 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 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
  • 6.14: Constexpr and consteval functions
  • 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
  • 7.19: Generating random numbers using Mersenne Twister
  • 7.x: Chapter 7 summary and quiz
• 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
• 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
  • 10.11: Class template argument deduction (CTAD) and deduction guides
  • 10.x: Chapter 10 summary and quiz
  • 10.y: Using a language reference
• 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: An introduction to std::string_view
  • 11.8: Pointers and arrays
  • 11.9: Pointer arithmetic and array indexing
  • 11.10: C-style string symbolic constants
  • 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.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?