C++

助教微信
image.png
udacity公众号
image.png
Nanodegree key: nd213 需要项目参考答案跟一对一VIP服务请扫描上面二维码
Version: 6.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
image.png

Content

Prior knowledge 01: Intro to Python, Part 1

Learn Python, a versatile programming language, to build your skills as a developer. In this first part, you will use Python statements and functions to draw colorful designs on the screen.

  • Module 01: Intro to Python, Part 1

    • Lesson 01: Turtles and CodeGet started learning core programming concepts with Python, while writing instructions to make a virtual “turtle” robot draw colorful shapes on the screen.
      • Concept 01: Welcome!
      • Concept 02: Starting out
      • Concept 03: Drawing with turtles
      • Concept 04: Variables
      • Concept 05: Practice — Variables and more
      • Concept 06: Changing colors
      • Concept 07: Changing shapes
      • Concept 08: Finding errors
      • Concept 09: Modules and methods
      • Concept 10: Practice — Draw a square
      • Concept 11: Comments
      • Concept 12: Practice — Order matters
      • Concept 13: Using variables
      • Concept 14: Practice — Using variables (1/2)
      • Concept 15: Practice — Using variables (2/2)
      • Concept 16: Looping
      • Concept 17: Practice — Basic loops
      • Concept 18: Practice — Assigning lists to variables
      • Concept 19: Lists and loops
      • Concept 20: Practice — Loop variables
      • Concept 21: Mystery shape
      • Concept 22: Loops within loops
      • Concept 23: Practice — Turtle methods
      • Concept 24: Practice — More loop variables (1/2)
      • Concept 25: Practice — More loop variables (2/2)
      • Concept 26: Practice — Nested loops
      • Concept 27: Thinking about errors
      • Concept 28: Rainbow turtles
      • Concept 29: Review
    • Lesson 02: Functions, Part 1Expand your knowledge of Python by learning to write functions and conditional statements.
      • Concept 01: Welcome to lesson 2!
      • Concept 02: Statements
      • Concept 03: The range function
      • Concept 04: Crunching numbers (1/2)
      • Concept 05: Crunching numbers (2/2)
      • Concept 06: What’s a function? (1/2)
      • Concept 07: What’s a function? (2/2)
      • Concept 08: Defining functions
      • Concept 09: Parameters and arguments
      • Concept 10: draw_square (definition)
      • Concept 11: draw_square (one parameter)
      • Concept 12: draw_square (multiple parameters)
      • Concept 13: draw_shape
      • Concept 14: Make your own function
      • Concept 15: Variable scope (1/2)
      • Concept 16: Variable scope (2/2)
      • Concept 17: Indent with care!
      • Concept 18: Which data type?
      • Concept 19: Two turtles
      • Concept 20: By any other name …
      • Concept 21: Square flower (1/3)
      • Concept 22: Square flower (2/3)
      • Concept 23: Square flower (3/3)
    • Lesson 03: Functions, Part 2Learn more advanced functions, conditional statements, and loops.
      • Concept 01: If this equals that
      • Concept 02: Conditionals in loops
      • Concept 03: if / else
      • Concept 04: Modulo (1/3)
      • Concept 05: Modulo (2/3)
      • Concept 06: Modulo (3/3)
      • Concept 07: Fizz Buzz, turtle style
      • Concept 08: Nice work!
      • Concept 09: Returning a value (1/3)
      • Concept 10: Returning a value (2/3)
      • Concept 11: Returning a value (3/3)
      • Concept 12: Passing arguments in loops (1/3)
      • Concept 13: Passing arguments in loops (2/3)
      • Concept 14: Passing arguments in loops (3/3)
      • Concept 15: The random module
      • Concept 16: Comparison operators
      • Concept 17: True or False
      • Concept 18: if and elif
      • Concept 19: Logical operators
      • Concept 20: Staying in bounds
      • Concept 21: Self-driving turtle
      • Concept 22: Congratulations!

        Prior knowledge 02: Shell Workshop

        The Unix shell is a powerful tool for developers of all sorts. In this lesson, you’ll get a quick introduction to the very basics of using it on your own computer.

  • Module 01: Shell Workshop

    • Lesson 01: Shell WorkshopThe Unix shell is a powerful tool for developers of all sorts. In this lesson, you’ll get a quick introduction to the very basics of using it on your own computer.
      • Concept 01: Welcome!
      • Concept 02: Windows: Installing Git Bash
      • Concept 03: Opening a terminal
      • Concept 04: Your first command (echo)
      • Concept 05: Variables
      • Concept 06: Navigating directories (1/2)
      • Concept 07: Navigating directories (2/2)
      • Concept 08: Options
      • Concept 09: Organizing your files (mkdir, mv)
      • Concept 10: Downloading (curl)
      • Concept 11: Viewing files (cat, less)
      • Concept 12: Removing things (rm, rmdir)
      • Concept 13: Review
      • Concept 14: Keep learning!

        Prior knowledge 03: Intro to Python, Part 2

        Learn Python, a versatile programming language, to build your skills as a developer. In this second part, you will install Python on your computer, and learn to work with textual data in strings.

  • Module 01: Intro to Python, Part 2

    • Lesson 01: Python at HomeInstall Python on your own computer so you can write code anytime!
      • Concept 01: Installing Python
      • Concept 02: Windows
      • Concept 03: Mac
      • Concept 04: Python in the terminal
      • Concept 05: The input function
      • Concept 06: The print function
      • Concept 07: Interactive mode
      • Concept 08: Compound statements in interactive mode
      • Concept 09: Using print to debug
      • Concept 10: Functions revisited
      • Concept 11: Functions in interactive mode
      • Concept 12: Type errors
      • Concept 13: Line numbers and tracebacks
      • Concept 14: Importing things
    • Lesson 02: Strings & Lists, Part 1Learn to work with strings and lists in your Python code.
      • Concept 01: Welcome back!
      • Concept 02: Variables vs. literals
      • Concept 03: More complex strings
      • Concept 04: Length
      • Concept 05: Looping over things
      • Concept 06: Counting things (1/2)
      • Concept 07: Counting things (2/2)
      • Concept 08: Indexing
      • Concept 09: The range function, revisited
      • Concept 10: Length and indexing
      • Concept 11: IndexError
      • Concept 12: Slicing (1/2)
      • Concept 13: Slicing (2/2)
      • Concept 14: Concatenation (1/2)
      • Concept 15: Concatenation (2/2)
      • Concept 16: f-strings
      • Concept 17: Strings to numbers to strings
      • Concept 18: starts_with (1/3)
      • Concept 19: starts_with (2/3)
      • Concept 20: starts_with (3/3)
      • Concept 21: Methods on strings
      • Concept 22: Boolean values
    • Lesson 03: Strings & Lists, Part 2Expand your understanding of strings and lists, and learning how to use a new kind of loop.
      • Concept 01: Operations on lists
      • Concept 02: Methods on lists
      • Concept 03: Mutable vs. immutable
      • Concept 04: Augmented assignments
      • Concept 05: while loops (1/5)
      • Concept 06: while loops (2/5)
      • Concept 07: while loops (3/5)
      • Concept 08: while loops (4/5)
      • Concept 09: while loops (5/5)
      • Concept 10: Infinite loops and breaking out
      • Concept 11: Finding substrings (1/4)
      • Concept 12: Finding substrings (2/4)
      • Concept 13: Finding substrings (3/4)
      • Concept 14: Finding substrings (4/4)
      • Concept 15: More methods on strings
      • Concept 16: Joining
      • Concept 17: Find and replace (1/2)
      • Concept 18: Find and replace (2/2)
      • Concept 19: Silly sentences
      • Concept 20: Way to go!
    • Lesson 04: Style & StructureGet practice writing longer programs, and improving their structure and style.
      • Concept 01: Welcome!
      • Concept 02: Pycodestyle
      • Concept 03: Multi-line strings (1/2)
      • Concept 04: Multi-line strings (2/2)
      • Concept 05: Breakfast bot — Specifications
      • Concept 06: Breakfast bot — Input and conditionals
      • Concept 07: Breakfast bot — Getting valid input (1/2)
      • Concept 08: Breakfast bot — Getting valid input (2/2)
      • Concept 09: Breakfast bot — More flexible input
      • Concept 10: Breakfast bot — Intro
      • Concept 11: Breakfast bot — Pausing
      • Concept 12: Breakfast bot — Order again
      • Concept 13: Breakfast bot — Refactoring (1/5)
      • Concept 14: Breakfast bot — Refactoring (2/5)
      • Concept 15: Breakfast bot — Refactoring (3/5)
      • Concept 16: Breakfast bot — Refactoring (4/5)
      • Concept 17: Breakfast bot — Refactoring (5/5)
      • Concept 18: Repeating with functions (1/2)
      • Concept 19: Repeating with functions (2/2)
      • Concept 20: Elevator — Simple version (1/2)
      • Concept 21: Elevator — Simple version (2/2)
      • Concept 22: Elevator — Advanced version
      • Concept 23: Elevator — First floor
      • Concept 24: Elevator — Second floor
      • Concept 25: Elevator — Third floor
      • Concept 26: Elevator — Refactoring (1/4)
      • Concept 27: Elevator — Refactoring (2/4)
      • Concept 28: Elevator — Refactoring (3/4)
      • Concept 29: Elevator — Refactoring (4/4)
      • Concept 30: Elevator — Scope
      • Concept 31: 100 lines!
    • Lesson 05: Adventure GameDemonstrate your Python skills by coding a simple version of an old-fashioned text-based adventure game.Project Description - Adventure GameProject Rubric - Adventure Game
      • Concept 01: Project Overview and Instructions
      • Concept 02: Project Rubric
      • Concept 03: Project Rubric - Checklist

        Prior knowledge 04: Intro to Python, Part 3

        Learn Python, a versatile programming language, to build your skills as a developer. In this third part, you will use Python to work with files on your computer’s disk, as well as learning the fundamentals of Object-Oriented Programming with classes and methods.

  • Module 01: Intro to Python, Part 3

    • Lesson 01: Working with FilesLearn to work with files on your disk using Python code: listing files in a directory, moving files around, and reading & writing the contents of text files.
      • Concept 01: Important note
      • Concept 02: Files with Python
      • Concept 03: The photos problem
      • Concept 04: Planning the solution to the photos problem
      • Concept 05: The os module
      • Concept 06: Functions on files and directories
      • Concept 07: Relative paths, and the current working directory
      • Concept 08: os functions and shell commands
      • Concept 09: Get a list of the file names
      • Concept 10: Extract the place names (1/2)
      • Concept 11: Extract the place names (2/2)
      • Concept 12: Make place directories (1/2)
      • Concept 13: Make place directories (2/2)
      • Concept 14: Move the files
      • Concept 15: Organize photos
      • Concept 16: The script footer
      • Concept 17: Pycodestyle
      • Concept 18: The profanity filter problem
      • Concept 19: Planning the solution to the profanity filter problem
      • Concept 20: Opening and reading a file
      • Concept 21: Closing a file
      • Concept 22: A slow solution
      • Concept 23: One word at a time
      • Concept 24: Fixing the punctuation bug
      • Concept 25: Fixing the capitalization bug
      • Concept 26: Writing output to a file
      • Concept 27: All done!
    • Lesson 02: Web APIsLearn to interact with Web APIs using the requests module, manipulate JSON, and use dictionaries.
      • Concept 01: Welcome to Web APIs
      • Concept 02: Getting the weather
      • Concept 03: The requests module
      • Concept 04: Making a request
      • Concept 05: What can go wrong?
      • Concept 06: Try and exceptions
      • Concept 07: What is JSON?
      • Concept 08: Dictionaries (1/2)
      • Concept 09: Dictionaries (2/2)
      • Concept 10: Looping over lists (review)
      • Concept 11: Looping over dictionaries (1/4)
      • Concept 12: Looping over dictionaries (2/4)
      • Concept 13: Looping over dictionaries (3/4)
      • Concept 14: Looping over dictionaries (4/4)
      • Concept 15: Nested data structures
      • Concept 16: Looping over nested structures (1/3)
      • Concept 17: Looping over nested structures (2/3)
      • Concept 18: Looping over nested structures (3/3)
      • Concept 19: Simple weather report
      • Concept 20: Getting the data
      • Concept 21: Making sense of the data
      • Concept 22: Getting the forecasts
      • Concept 23: Review
      • Concept 24: Weather report
      • Concept 25: Outro
    • Lesson 03: Objects & ClassesLearn to create new kinds of data object using classes, including creating your own methods.
      • Concept 01: Welcome to objects and classes
      • Concept 02: Objects belong to classes
      • Concept 03: Python classes versus CSS classes
      • Concept 04: Defining a new class (1/2)
      • Concept 05: Defining a new class (2/2)
      • Concept 06: The self parameter
      • Concept 07: Using class-level variables
      • Concept 08: Using instance-level variables
      • Concept 09: Initializers (1/2)
      • Concept 10: Initializers (2/2)
      • Concept 11: Storing information on instances
      • Concept 12: Inheritance
      • Concept 13: “Is-a” vs. “Has-a”
      • Concept 14: Using super
      • Concept 15: Congratulations!
      • Concept 16: Optional bonus project!

        Part 01 : Welcome

  • Module 01: Orientation

    • Lesson 01: Welcome to the C++ Developer Nanodegree Program
      • Concept 01: Intro
      • Concept 02: Prerequisites
      • Concept 03: Courses
      • Concept 04: Projects
      • Concept 05: David Silver
      • Concept 06: Stephen Welch
      • Concept 07: Andreas Haja
      • Concept 08: Bjarne Stroustrup
      • Concept 09: Reviews
      • Concept 10: Knowledge
      • Concept 11: Student Hub
    • Lesson 02: Introduction to C++C++ is one of the most important programming languages in the world. It is particularly important for high-performance software.
      • Concept 01: C++
      • Concept 02: C++ History
      • Concept 03: C++ Today
      • Concept 04: Modern C++
      • Concept 05: C++ Core Guidelines
      • Concept 06: Standard Library
      • Concept 07: Compilation
      • Concept 08: Build Tools
      • Concept 09: Installation
      • Concept 10: Editors
      • Concept 11: Style
      • Concept 12: Debugging
    • Lesson 03: WorkspacesLean about the in-browser coding environments that are available to you as you go through the Nanodegree program.
      • Concept 01: Introduction to Workspaces
      • Concept 02: Notebook Workspaces
      • Concept 03: Terminal Workspaces
      • Concept 04: Desktop Workspaces
      • Concept 05: Submitting Projects
      • Concept 06: Resetting and Refreshing Workspaces

  • Module 02: Career Support

    • Lesson 01: Get Help with Your AccountWhat to do if you have questions about your account or general questions about the program.
      • Concept 01: FAQ
      • Concept 02: Support
    • Lesson 02: Knowledge, Community, and CareersYou are starting a challenging but rewarding journey! Take 5 minutes to read how to get help with projects and content.
      • Concept 01: Getting Help
      • Concept 02: Knowledge
      • Concept 03: Student Hub
      • Concept 04: Community Initiatives
      • Concept 05: Career Services

        Part 02 : Foundations

  • Module 01: Foundations

    • Lesson 01: WelcomeMeet your instructors, David and Stephen, and hear from the inventor of C++, Bjarne Stroustrup.
      • Concept 01: Welcome!
      • Concept 02: Bjarne Talks About the C++ Language
      • Concept 03: Bjarne on How to Learn C++
      • Concept 04: The Core Guidelines
    • Lesson 02: Introduction to the C++ LanguageIn this lesson, you will build on your previous programming experience to learn the basics of the C++ language.
      • Concept 01: Intro
      • Concept 02: CODE: Write and Run Your First C++ Program
      • Concept 03: Compiled Languages vs Scripted Languages
      • Concept 04: C++ Output and Language Basics
      • Concept 05: CODE: Send Output to the Console
      • Concept 06: How to Store Data
      • Concept 07: Bjarne Introduces C++ Types
      • Concept 08: Primitive Variable Types
      • Concept 09: What is a Vector?
      • Concept 10: C++ Vectors
      • Concept 11: C++ Comments
      • Concept 12: Using Auto
      • Concept 13: CODE: Store a Grid in Your Program
      • Concept 14: Getting Ready for Printing
      • Concept 15: Working with Vectors
      • Concept 16: For Loops
      • Concept 17: Functions
      • Concept 18: CODE: Print the Board
      • Concept 19: If Statements and While Loops
      • Concept 20: Reading from a File
      • Concept 21: CODE: Read the Board from a File
      • Concept 22: Processing Strings
      • Concept 23: Adding Data to a Vector
      • Concept 24: CODE: Parse Lines from the File
      • Concept 25: CODE: Use the ParseLine Function
      • Concept 26: Formatting the Printed Board
      • Concept 27: CODE: Formatting the Printed Board
      • Concept 28: CODE: Store the Board using the State Enum
      • Concept 29: Great Work!
    • Lesson 03: A SearchIn this lesson, you will learn about the A search algorithm. Over a sequence of exercises, you will use your A* search implementation to plan a path through the obstacles in the ASCII board.
      • Concept 01: Intro
      • Concept 02: Motion Planning
      • Concept 03: Maze
      • Concept 04: Maze 2
      • Concept 05: Coding the Shortest Path Algorithm
      • Concept 06: A* Search
      • Concept 07: Lesson Code Structure
      • Concept 08: CODE: Starting A* Search
      • Concept 09: CODE: Writing the A* Heuristic
      • Concept 10: Pass by Reference in C++
      • Concept 11: CODE: Adding Nodes to the Open Vector
      • Concept 12: CODE: Initialize the Open Vector
      • Concept 13: CODE: Create a Comparison Function
      • Concept 14: CODE: Write a While Loop for the A* Algorithm
      • Concept 15: CODE: Check for Valid Neighbors
      • Concept 16: Constants
      • Concept 17: CODE: Expand the A* Search to Neighbors
      • Concept 18: Arrays
      • Concept 19: CODE: Adding a Start and End to the Board
      • Concept 20: Congratulations!!
      • Concept 21: How to Become More Proficient at C++
    • Lesson 04: Writing Multifile ProgramsIn this lesson, you will learn the syntax for C++ language features that you will need for the next steps in the course. This includes an overview of header files, pointers, build tools, and classes.
      • Concept 01: Intro
      • Concept 02: Header Files
      • Concept 03: Using Headers with 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: Bjarne on pointers
      • Concept 10: References vs Pointers
      • Concept 11: Bjarne on References
      • Concept 12: Maps
      • Concept 13: Classes and Object-Oriented Programming
      • Concept 14: Classes and OOP Continued
      • Concept 15: This Pointer
      • Concept 16: How Long Does it Take to Learn C++?
      • Concept 17: Outro
    • Lesson 05: Build an OpenStreetMap Route PlannerIn this project you will extend the IO2D map display code to use A*, so your program will be able to find a path between two points on the map.Project Description - Build an OpenStreetMap Route PlannerProject Rubric - Build an OpenStreetMap Route Planner
      • Concept 01: Project Intro
      • Concept 02: The OpenStreetMap Project
      • Concept 03: Building and Running
      • Concept 04: Testing
      • Concept 05: Project Code Overview
      • Concept 06: Project Starter Repository
      • Concept 07: The src Directory
      • Concept 08: The src Directory Additional Files
      • Concept 09: Steps to Complete the Project
      • Concept 10: Project Submission and Workspace
    • Lesson 06: Course Outro
      • Concept 01: Outro
      • Concept 02: Career Advice from Bjarne

        Part 03 : Object-Oriented Programming

  • Module 01: Object-Oriented Programming

    • Lesson 01: Welcome
      • Concept 01: Overview
      • Concept 02: Bjarne on the Creation of C++ and Classes
      • Concept 03: System Monitor Project
      • Concept 04: Let’s Get Started!
    • Lesson 02: Intro to OOPIn 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: Member Initialization
      • Concept 06: Access Specifiers
      • Concept 07: Classes
      • Concept 08: Encapsulation and Abstraction
      • Concept 09: Bjarne on Encapsulation
      • Concept 10: Constructors
      • Concept 11: Scope Resolution
      • Concept 12: Initializer Lists
      • Concept 13: Initializing Constant Members
      • Concept 14: Encapsulation
      • Concept 15: Accessor Functions
      • Concept 16: Mutator Functions
      • Concept 17: Quiz: Classes in C++
      • Concept 18: Exercise: Pyramid Class
      • Concept 19: Exercise: Student Class
      • Concept 20: Encapsulation in C++
      • Concept 21: Bjarne On Abstraction
      • Concept 22: Abstraction
      • Concept 23: Exercise: Sphere Class
      • Concept 24: Exercise: Private Method
      • Concept 25: Exercise: Static Members
      • Concept 26: Exercise: Static Methods
      • Concept 27: Bjarne On Solving Problems
    • Lesson 03: Advanced OOPIn 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 Specifiers
      • Concept 05: Exercise: Animal Class
      • Concept 06: Composition
      • Concept 07: Exercise: Class Hierarchy
      • Concept 08: Exercise: Friends
      • Concept 09: Polymorphism: Overloading
      • Concept 10: Polymorphism: Operator Overloading
      • Concept 11: Virtual Functions
      • Concept 12: Polymorphism: Overriding
      • Concept 13: Override
      • Concept 14: Multiple Inheritance
      • Concept 15: Generic Programming
      • Concept 16: Bjarne on Generic Programming
      • Concept 17: Templates
      • Concept 18: Bjarne on Templates
      • Concept 19: Exercise: Comparison Operation
      • Concept 20: Deduction
      • Concept 21: Exercise: Class Template
      • Concept 22: Summary
      • Concept 23: Bjarne on Best Practices with Classes
    • Lesson 04: Project: System MonitorTime 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!Project Description - System MonitorProject Rubric - System Monitor
      • Concept 01: Introduction
      • Concept 02: htop
      • Concept 03: Starter Code
      • Concept 04: Project Structure
      • Concept 05: Build Tools
      • Concept 06: System Class
      • Concept 07: System Data
      • Concept 08: LinuxParser Namespace
      • Concept 09: String Parsing
      • Concept 10: Processor Class
      • Concept 11: Processor Data
      • Concept 12: Process Class
      • Concept 13: Process Data
      • Concept 14: Goal
      • Concept 15: Project Workspace

        Part 04 : Memory Management

  • Module 01: Memory Management

    • Lesson 01: Introduction
      • Concept 01: Welcome
      • Concept 02: Course Overview
      • Concept 03: Bjarne on Memory Management
    • Lesson 02: Overview of Memory TypesThis lesson covers basic concepts such as cache, virtual memory, and the structure of memory addresses. In addition, it is demonstrated how the debugger can be used to read data from memory.
      • Concept 01: Memory Addresses and Hexidecimal Numbers
      • Concept 02: Using the Debugger to Analyze Memory
      • Concept 03: Types of Computer Memory
      • Concept 04: Cache Memory
      • Concept 05: Virtual Memory
    • Lesson 03: Variables and MemoryIn this lesson the process memory model is introduced, which contains the two fundamental memory areas heap and stack, which play an important role in C++.
      • Concept 01: The Process Memory Model
      • Concept 02: Automatic Memory Allocation (The Stack)
      • Concept 03: Call-By-Value vs. Call-By-Reference
    • Lesson 04: Dynamic Memory Allocation (The Heap)This lesson introduces dynamic memory allocation on the heap. The commands malloc and free as well as new and delete are introduced for this purpose.
      • Concept 01: Heap Memory
      • Concept 02: Bjarne on Stack and Heap
      • Concept 03: Using malloc and free
      • Concept 04: Using new and delete
      • Concept 05: Bjarne on new and delete
      • Concept 06: Typical Memory Management Problems
      • Concept 07: Bjarne on Memory Leaks
    • Lesson 05: Resource Copying PoliciesThis section describes how to customize resource copying using the Rule of Three. Also, the Rule of Five is introduced, which helps develop a thorough memory management strategy in your code.
      • Concept 01: Copy Semantics
      • Concept 02: Lvalues and Rvalues
      • Concept 03: Move Semantics
    • Lesson 06: Smart PointersIn this lesson the three types of smart pointers in C++ are presented and compared. In addition, it is shown how to transfer ownership from one program part to another using copy and move semantics.
      • Concept 01: Resource Acquisition is Initialization
      • Concept 02: Bjarne on RAII
      • Concept 03: Smart Pointers
      • Concept 04: Bjarne on Smart Pointers
      • Concept 05: Transferring Ownership
      • Concept 06: Bjarne on Importance of Scope
    • Lesson 07: Memory Management ChatbotThe ChatBot project creates a dialogue where users can ask questions about some aspects of memory management in C++. Your task will be to optimize the project with modern memory management in mind.Project Description - Memory Management ChatbotProject Rubric - Memory Management Chatbot
      • Concept 01: Introduction
      • Concept 02: Program Schematic
      • Concept 03: Membot Knowledge Base
      • Concept 04: Project Tasks Overview
      • Concept 05: Code Walkthrough
      • Concept 06: Task Details
      • Concept 07: Project Workspace

        Part 05 : Concurrency

  • Module 01: Concurrency

    • Lesson 01: Introduction and Running ThreadsLearn the difference between processes and threads, and write your own concurrent program running multiple threads at the same time.
      • Concept 01: Introduction
      • Concept 02: Processes and Threads
      • Concept 03: Running a Single Thread
      • Concept 04: Starting a Thread with Function Objects
      • Concept 05: Starting a Thread with Variadic Templates & Member Functions
      • Concept 06: Running Multiple Threads
      • Concept 07: Lesson 1 Exercise
    • Lesson 02: Passing Data Between ThreadsLearn 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.
      • Concept 01: Introduction
      • Concept 02: Promises and Futures
      • Concept 03: Threads vs. Tasks
      • Concept 04: Threads vs. Tasks Quiz
      • Concept 05: Avoiding Data Races
      • Concept 06: Lesson 2 Exercise
    • Lesson 03: Mutexes and LocksUse mutexes and locks to safely access shared data from various threads.
      • Concept 01: Introduction
      • Concept 02: Using a Mutex to Protect Shared Data
      • Concept 03: Using Locks to Avoid Deadlocks
      • Concept 04: Lesson 3 Exercise
    • Lesson 04: Condition Variables and Message QueuesUse condition variables as a basic synchronization tool between threads. Understand and implement a concurrent message queue for flexible inter-thread communication
      • Concept 01: Introduction
      • Concept 02: The Monitor Object Pattern
      • Concept 03: Building a Concurrent Message Queue
    • Lesson 05: Program a Concurrent Traffic SimulationBuild 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 SimulationProject Rubric - Program a Concurrent Traffic Simulation
      • Concept 01: Final Project Intro
      • Concept 02: Final Project Tasks
      • Concept 03: Final Project Code Overview
      • Concept 04: Final Project Workspace

        Part 06 : Career Services

  • Module 01: Career Services

    • Lesson 01: Industry ResearchYou’re building your online presence. Now learn how to share your story, understand the tech landscape better, and meet industry professionals.
      • Concept 01: Self-Reflection: Design Your Blueprint for Success
      • Concept 02: Debrief: Self-Reflection Exercise Part 1
      • Concept 03: Debrief: Self-Reflection Exercise Part 2
      • Concept 04: Map Your Career Journey
      • Concept 05: Debrief: Map Your Career Journey
      • Concept 06: Conduct an Informational Interview
      • Concept 07: How to Request an Informational Interview
      • Concept 08: Ways to Connect
      • Concept 09: Ask Good Questions
      • Concept 10: Debrief: Sample Questions Quiz
      • Concept 11: Keep the Conversation Going
    • Lesson 02: Optimize Your GitHub ProfileOther professionals are collaborating on GitHub and growing their network. Submit your profile to ensure your profile is on par with leaders in your field.Project Description - Optimize Your GitHub ProfileProject Rubric - Optimize Your GitHub Profile
      • Concept 01: Prove Your Skills With GitHub
      • Concept 02: Introduction
      • Concept 03: GitHub profile important items
      • Concept 04: Good GitHub repository
      • Concept 05: Interview with Art - Part 1
      • Concept 06: Identify fixes for example “bad” profile
      • Concept 07: Quick Fixes #1
      • Concept 08: Quick Fixes #2
      • Concept 09: Writing READMEs with Walter
      • Concept 10: Interview with Art - Part 2
      • Concept 11: Commit messages best practices
      • Concept 12: Reflect on your commit messages
      • Concept 13: Participating in open source projects
      • Concept 14: Interview with Art - Part 3
      • Concept 15: Participating in open source projects 2
      • Concept 16: Starring interesting repositories
      • Concept 17: Next Steps
    • Lesson 03: Take 30 Min to Improve your LinkedInFind your next job or connect with industry peers on LinkedIn. Ensure your profile attracts relevant leads that will grow your professional network.Project Description - Improve Your LinkedIn ProfileProject Rubric - Improve Your LinkedIn Profile
      • Concept 01: Get Opportunities with LinkedIn
      • Concept 02: Use Your Story to Stand Out
      • Concept 03: Why Use an Elevator Pitch
      • Concept 04: Create Your Elevator Pitch
      • Concept 05: Use Your Elevator Pitch on LinkedIn
      • Concept 06: Create Your Profile With SEO In Mind
      • Concept 07: Profile Essentials
      • Concept 08: Work Experiences & Accomplishments
      • Concept 09: Build and Strengthen Your Network
      • Concept 10: Reaching Out on LinkedIn
      • Concept 11: Boost Your Visibility
      • Concept 12: Up Next

        Part 07 : Capstone

  • Module 01: Capstone

    • Lesson 01: CapstoneIn this lesson, you will build your own C++ application, following the principles you have learned throughout this Nanodegree Program.Project Description - C++ Capstone ProjectProject Rubric - C++ Capstone Project
      • Concept 01: Capstone Intro
      • Concept 02: Steps to Complete the Capstone
      • Concept 03: Game Programming
      • Concept 04: The SDL Library
      • Concept 05: Snake Game Code Walkthrough
      • Concept 06: Capstone Workspace

【点击购买】