Nanodegree key: nd213
Version: 2.0.0
Locale: en-us
Learn C++, a high-performance programming language used in the world's most exciting engineering jobs -- from self-driving cars and robotics, to web browsers, media platforms, servers, and even video
Content
Part 01 : Introduction
-
Module 01: Introduction
-
Lesson 02: Get Help with Your Account
What to do if you have questions about your account or general questions about the program.
Part 02 : Foundations
-
Module 01: Foundations
-
Lesson 02: Introduction to the C++ Language
- Concept 01: Intro
- Concept 02: Motion Planning
- Concept 03: Maze
- Concept 04: Maze 2
- Concept 05: Coding the Shortest Path Algorithm
- Concept 06: CODE: Write Your First C++ Program
- Concept 07: Compiled Languages vs Scripted Languages
- Concept 08: C++ Output and Language Basics
- Concept 09: CODE: Sending Output to the Console
- Concept 10: How to Store Data
- Concept 11: Bjarne Discusses C++ Types
- Concept 12: Storing Primitive Types
- Concept 13: What is a Vector?
- Concept 14: Storing Vectors
- Concept 15: C++ Comments
- Concept 16: Using Auto
- Concept 17: CODE: Store a Grid in Your Program
- Concept 18: Getting Ready for Printing
- Concept 19: Working with Vectors
- Concept 20: For Loops
- Concept 21: Functions
- Concept 22: CODE: Print the Board
- Concept 23: If Statements and While Loops
- Concept 24: Reading from a File
- Concept 25: CODE: Read the Board from a File
- Concept 26: Processing Strings
- Concept 27: Adding Data to a Vector
- Concept 28: CODE: Parse Lines from the File
- Concept 29: CODE: Use the ParseLine Function
- Concept 30: Formatting the Printed Board
- Concept 31: CODE: Formatting the Printed Board
- Concept 32: CODE: Store the Board using the State Enum
- Concept 33: Great Work!
-
Lesson 03: A* Search
- Concept 01: Intro
- Concept 02: A* Search
- Concept 03: CODE: Starting A* Search
- Concept 04: CODE: Writing the A* Heuristic
- Concept 05: Pass by Reference in C++
- Concept 06: CODE: Adding Nodes to the Open Vector
- Concept 07: CODE: Initialize the Open Vector
- Concept 08: CODE: Create a Comparison Function
- Concept 09: CODE: Write a While Loop for the A* Algorithm
- Concept 10: CODE: Check for Valid Neighbors
- Concept 11: Constants
- Concept 12: CODE: Expand the A* Search to Neighbors
- Concept 13: Arrays
- Concept 14: CODE: Adding a Start and End to the Board
- Concept 15: Congratulations!!
- Concept 16: How to Become More Proficient at C++
-
Lesson 04: Writing Larger Programs
- Concept 01: Intro
- Concept 02: Header Files
- Concept 03: Using Multiple Files
- Concept 04: Bjarne on Build Systems
- Concept 05: CMake and Make
- Concept 06: References
- Concept 07: Pointers
- Concept 08: Pointers Continued
- Concept 09: References vs Pointers
- Concept 10: Classes and Object-Oriented Programming
- Concept 11: Classes and OOP Continued
- Concept 12: Outro
-
Lesson 05: Extending the OpenStreetMap Data Model
- Concept 01: Intro
- Concept 02: OpenStreetMap Data
- Concept 03: IO2D Starter Code
- Concept 04: CODE: Building, Running, and Testing
- Concept 05: Upcoming Exercise and Project Format
- Concept 06: CODE: The RouteModel Class
- Concept 07: CODE: The Node Class
- Concept 08: This Pointer
- Concept 09: CODE: Create RouteModel Nodes
- Concept 10: CODE: Write the Distance Function
- Concept 11: What Are the Most Important Containers to Learn?
- Concept 12: Hash Tables
- Concept 13: CODE: Create Node to Road Hash Table
- Concept 14: CODE: Write FindNeighbor
- Concept 15: CODE: Write FindNeighbors
- Concept 16: CODE: Find the Closest Node
- Concept 17: Outro
-
Lesson 06: A* with OpenStreetMap Data
- Concept 01: Intro
- Concept 02: How Long Does it Take to Learn C++?
- Concept 03: CODE: The RoutePlanner Header
- Concept 04: CODE: The RoutePlanner Constructor
- Concept 05: CODE: Construct the Final Path
- Concept 06: CODE: Write the A* Search Stub
- Concept 07: CODE: Calculate H Values
- Concept 08: CODE: Get the Next Node
- Concept 09: CODE: Add New Neighbors
- Concept 10: CODE: Complete A* Search
- Concept 11: CODE: Add User Input
- Concept 12: Outro
Part 03 : Object Oriented Programming
-
Module 01: Object Oriented Programming
-
Lesson 02: Intro to OOP
In this lesson, you will explore some of the basic object oriented functionality of the C++ language.
- Concept 01: Classes and OOP
- Concept 02: Bjarne on Classes in C++
- Concept 03: Jupyter Notebooks
- Concept 04: Structures
- Concept 05: Classes
- Concept 06: Access Modifiers
- Concept 07: Classes in C++
- Concept 08: Encapsulation and Abstraction
- Concept 09: Bjarne on Encapsulation
- Concept 10: Encapsulation
- Concept 11: Exercise: Bank Account Class
- Concept 12: Exercise: Car Class
- Concept 13: Exercise: Pyramid Class
- Concept 14: Exercise: Student Class
- Concept 15: Encapsulation in C++
- Concept 16: Bjarne on Abstraction
- Concept 17: Abstraction
- Concept 18: Exercise: Abstraction Class
- Concept 19: Exercise: Sphere Class
- Concept 20: Exercise: Private Method
- Concept 21: Exercise: Static Attribute
- Concept 22: Exercise: Static Method
- Concept 23: Abstraction in C++
- Concept 24: Bjarne on Thinking about Classes Conceptually
-
Lesson 03: Advanced OOP
In this lesson, we'll get into some of the more advanced topics in object oriented programming, including inheritance, polymorphism and templates.
- Concept 01: Polymorphism and Inheritance
- Concept 02: Bjarne on Inheritance
- Concept 03: Inheritance
- Concept 04: Access Modifiers and Inheritance
- Concept 05: Exercise: Animal Class
- Concept 06: Exercise: Line Class
- Concept 07: Exercise: Multiple Inheritance
- Concept 08: Exercise: Class Hierarchy
- Concept 09: Exercise: Friends
- Concept 10: Polymorphism: Overloading
- Concept 11: Polymorphism: Overriding
- Concept 12: Exercise: Virtual Functions
- Concept 13: Exercise: Operator Overload
- Concept 14: Exercise: Function Overload
- Concept 15: Exercise: Runtime Polymorphism
- Concept 16: Generic Programming
- Concept 17: Bjarne on Generic Programming
- Concept 18: Templates
- Concept 19: Bjarne on Templates
- Concept 20: Exercise: Comparison Operation
- Concept 21: Exercise: Function Template
- Concept 22: Exercise: Deduction
- Concept 23: Exercise: Multiple Generic Types
- Concept 24: Exercise: Class Template
- Concept 25: Constructors
- Concept 26: Initialization List
- Concept 27: Exercise: Constructor Syntax
- Concept 28: Exercise: User Defined Attributes
- Concept 29: Summary
- Concept 30: Bjarne on Best Practices with Classes
-
Lesson 04: Project: System Monitor
Time to build the project! In this lesson, you'll get the tools you need to build the project for this course, a system monitor application similar to htop!
- Concept 01: Introduction
- Concept 02: Project Overview
- Concept 03: Project Objectives
- Concept 04: Project File Structure
- Concept 05: Cloud Workspace Intro
- Concept 06: Project Workspace
- Concept 07: constants.h
- Concept 08: util.h
- Concept 09: ProcessParser.h
- Concept 10: RAM Usage
- Concept 11: CPU Usage
- Concept 12: Process Up Time
- Concept 13: System Up Time
- Concept 14: Process User
- Concept 15: PID List
- Concept 16: Get Command
- Concept 17: Number of Cores
- Concept 18: System CPU Percent
- Concept 19: CPU Stats
- Concept 20: RAM Percent
- Concept 21: System Info
- Concept 22: Process Class
- Concept 23: Process Container
- Concept 24: Display Info
- Concept 25: Congratulations!
- Concept 26: Bonus: Ncurses Introduction
- Concept 27: Bonus: Ncurses Basic Setup
- Concept 28: Bonus: Ncurses Print and Modify
- Concept 29: Bonus: Ncurses Windowing Lab Part 1
- Concept 30: Bonus: Ncurses Windowing Lab Part 2
- Concept 31: Bonus: Ncurses Windowing Part 1
- Concept 32: Bonus: Ncurses Windowing Part 2
Part 04 : Memory Management
-
Module 01: Memory Management
-
Lesson 01: Introduction
Learn about stack and heap in C++, get ready for memory management in C++!
-
Lesson 02: Pointers and References
Learn about pointers, the primitive data type for store, manipulation and initialization of memory and memory addresses in C++.
- Concept 01: Introduction to Pointers
- Concept 02: Bjarne on pointers
- Concept 03: Pointers Example
- Concept 04: Pointers Exercise 1
- Concept 05: Pointers Exercise 2
- Concept 06: Pointers Exercise 3
- Concept 07: Pointers Exercise 4
- Concept 08: Pointers Project Lab
- Concept 09: Introduction to References
- Concept 10: Bjarne on References
- Concept 11: References Example
- Concept 12: References Exercise 1
- Concept 13: References Exercise 2
-
Lesson 03: new and delete
Learn about memory allocation in C++, which is technique of memory management where programs and services are assigned to use host computer memory!
- Concept 01: Introduction
- Concept 02: Bjarne on new and delete
- Concept 03: new
- Concept 04: new - Example
- Concept 05: delete
- Concept 06: delete - Example
- Concept 07: new and delete Exercise 1
- Concept 08: new and delete Exercise 2
- Concept 09: new and delete Exercise 3
- Concept 10: new and delete Project Exercise
- Concept 11: Bjarne on Memory Leaks
- Concept 12: memset and malloc
- Concept 13: memset
- Concept 14: memset - Example
- Concept 15: malloc
- Concept 16: malloc - Example
-
Lesson 04: Smart Pointers
Learn about smart pointers, designed in C++ to improve native safety and performance of memory management of this language.
- Concept 01: Bjarne on Smart Pointer
- Concept 02: Bjarne on Pointer Best Practices
- Concept 03: Smart Pointers
- Concept 04: Smart Pointer Exercise 1
- Concept 05: Smart Pointer Exercise 2
- Concept 06: Resource Scope
- Concept 07: Bjarne on Scope
- Concept 08: Resource Scope Exercise 1
- Concept 09: Resource Scope Exercise 2
- Concept 10: Bjarne on Importance of Scope
-
Lesson 05: Garbage Collector
Implement your own smart pointer with garbage collection functionality and master memory management in C++!
- Concept 01: Project Introduction
- Concept 02: Project Overview
- Concept 03: Pointer Lab
- Concept 04: Reference Lab
- Concept 05: "New" and "Delete" Lab
- Concept 06: Smart Pointer Explanation
- Concept 07: Smart Pointer Lab
- Concept 08: Resource Scope Lab
- Concept 09: Garbage Collector: TODO
- Concept 10: Project Workspace
-
Part 05 : Concurrency
-
Module 01: Concurrency
-
Lesson 01: Introduction and Running Threads
Learn the difference between processes and threads, and write your own concurrent program running multiple threads at the same time.
-
Lesson 02: Passing Data Between Threads
Learn to use promises and futures to create safe communication between threads. Also learn about tasks as an alternative to threads. Finally, understand data races and how to avoid them.
-
Lesson 03: Mutexes and Locks
Use mutexes and locks to safely access shared data from various threads.
-
Lesson 04: Condition Variables and Message Queues
Use condition variables as a basic synchronization tool between threads. Understand and implement a concurrent message queue for flexible inter-thread communication
-
Lesson 05: Program a Concurrent Traffic Simulation
Build a multithreaded traffic simulator using a real urban map. Run each vehicle on a separate thread, and manage intersections to facilitate traffic flow and avoid collisions.
Project Description - Program a Concurrent Traffic Simulation
-
Part 06 : Capstone