Become a C Plus Plus Developer
Posted by Superadmin on January 10 2019 03:58:04

Become a C Plus Plus Developer

 

 

C++ is one of the most popular programming languages in the world. It is used for everything from systems-level programming to mobile app development, and is a solid foundation for every programmer's skill set. Become a C++ developer with our expert-led tutorials.
Learn the fundamentals of programming with C++.
Explore solutions to common C++ programming challenges.
Build development environments, create applications, and program templates.

1
 

Programming Foundations: Algorithms with Joe Marini
Course Contents
  • Introduction : Algorithms power the world 1m 2s What you should know 1m 35s
  • Overview What are algorithms? 2m 44s Common algorithms in programming 5m 42s Measuring algorithm performance 3m 47s
  • Common Data Structures Introduction to data structures 1m 56s Arrays 2m 29s Linked lists 2m 36s Linked lists walkthrough 7m 35s Stacks and queues 2m 43s Stacks and queues walkthrough 6m 2s Hash tables 7m 59s
  • Recursion Understanding recursion 3m 38s Simple recursion example 3m 9s Power and factorial 4m 14s
  • Sorting Data Overview of sorting 2m 4s The bubble sort5m 8s The merge sort 2m 24s Implement the merge sort 5m 10s The quicksort 3m 31s Implement the quicksort 5m 39s
  • Searching Data Unordered list search 3m 45s Ordered list search 5m 30s Determine if a list is sorted 3m 37s
  • Other Algorithms Unique filtering with hash table 3m 25s Value counting with hash table 3m 4s Find max value recursively 3m 44s
  • Conclusions Next steps 1m 18s

    • 2
     

    Learning C++ with Erin Colvin
    Course Contents
  • Introduction Fun with C++ 43s What you should know 25s
  • Getting Started IDE setup 1m 21s Algorithms and pseudocode 3m 14s How to create a simple program 3m 13s Challenge: Hello World 40s Solution: Hello World 1m 9s
  • Data Representation Declaring simple data types as variables 4m 2s Declaration of variables 1m 31s Storage of data in memory 8m 16s Constants 4m 53s Arrays 3m 16s Challenge: Random number generator 45s Solution: Random number generator 57s
  • Flow Control If statements 6m 2s Conditional checking 2m 50s Switch statement 3m 53s For loop 4m 43s While loops 2m Do… while loop 12m 51s Challenge: Add loop to game 1m 55s Solution: Add loop to game 4m 47s
  • Functions What is a function? 3m 15s Creating a function 5m 8s Function parameters 7m 34s Calling, prototypes, and defining functions 6m 6s Using functions in our program 4m 35s Challenge: Move gameplay to function 1m 27s Solution: Move gameplay to function 4m 45s
  • File I/O Opening and reading from a text file 6m 41s Open a text file to write to 3m 31s Challenge: Write order to file 44s Solution: Write order to file 1m 52s
  • Data Structures Structs 6m 17s Classes 7m 46s Pointers 4m 36s Linked lists 5m 52s Challenge: Orders in a linked list 43s Solution: Orders in a linked list 1m 49s
  • Conclusion Next steps 16s
    		•

    3
     

    C++ Design Patterns: Creational with Olivia Chiu Stone
    Course Contents
  • Introduction Welcome 1m 8s What you should know 2m 22s Installing Visual Studio for Windows 1m 51s Installing Visual Studio for Mac 1m 35s How to use exercise files 52s Challenges explained 46s
  • Design Patterns Overview The need for a design pattern 4m 5s What are design patterns? 3m 39s Creational patterns overview 1m 48s
  • Creational Patterns Inheritance vs. composition 4m Composite object example 6m 39s Concrete vs. abstract 1m 59s Understanding UML 2m 55s
  • Factory Method Factory method concept 5m 36s Factory method implementation 5m 12s Running the Factory method example 4m 11s Factory variations 1m 43s
  • Abstract Factory Abstract Factory concept 4m 50s Abstract Factory pattern implementation 6m 3s Using the Abstract Factory 4m 14s Running the Abstract Factory 3m 44s Extending the Abstract Factory 2m 47s Challenge 4m 1s Solution 8m 57s
  • Builder Builder concept 3m 36s Builder pattern setup 4m 10s Builder pattern implementation 5m 35s Running the Builder example 6m 49s Steps in the Builder pattern 2m 5s
  • Prototype Prototype concept 4m 15s Prototype pattern implementation 5m 57s Running the Prototype example 4m 29s Shallow copy vs. deep copy 2m 14s
  • Singleton Singleton concept 3m 2s Singleton implementation 4m 8s Running the Singleton pattern 3m 54s Is the Singleton a good pattern? 5m 29s Comparing creational patterns 4m 36s
  • Conclusion Next steps 1m 7s
    		•

    4
     

    C++ Essential Training (2014) with Bill Weinman
    Course Contents
  • Introduction Welcome 53s Using Xcode with the exercises 9m 10s Using Microsoft Visual Studio with the exercises 14m 20s
  • Basic Syntax What is C++? 5m 20s Introduction to basic syntax 1m 57s Anatomy of a C++ program 9m 5s Statements and expressions 4m 1s Identifiers 2m 14s Defining variables 3m 4s Pointers 4m 57s References 3m 48s Arrays and strings 7m 11s Conditionals 5m 32s The branching conditional 4m 7s Looping with while and do 2m 29s Iterating with for 4m Using the range-based for loop 3m 35s Using stdout 7m 1s
  • Defining Functions Overview of C++ functions 3m 15s Defining a function 4m 8s Passing values to a function 7m 52s Using automatic and static variables 3m 5s Returning values from a function 3m 19s Using function pointer 8m 7s Overloading function names 2m 39s Overloading operators with functions 5m 23s Defining a variable number of arguments 4m 23s Using recursion 2m 28s
  • The Preprocesser About the preprocessor 2m 29s Using macros as constants 3m 30s Including files 2m 31s Conditional compilation 1m 52s Defining macros 4m 2s Macro caveats 3m 12s Line continuation with backslash 3m 9s Including files only once 4m 6s
  • Classes and Objects Overview of classes and objects 2m 14s Defining a class 5m 5s Data members 5m 15s Function members 6m 30s Constructors and destructors 9m 3s Implicit vs. explicit constructors 4m 32s Namespaces 4m 8s Pointing to the current object with *this 1m 52s Overloading operators with member functions 12m 35s Overloading operators with nonmember functions 5m 53s Conversion operators 5m 8s Creating and destroying objects with new and delete 4m 14s Reporting errors with exceptions 2m 56s Creating function objects 1m 55s Converting numbers to words 13m 45s
  • Data Types Overview of data types 2m 49s Integral types 9m 50s Floating-point types 3m 57s Characters and strings 2m 47s Character-escape sequences 2m 10s Qualifiers 5m 32s The C++ reference type 4m 59s Structured data 1m 56s Bit fields 2m 34s Enumerations 3m 50s Unions 2m 15s Defining types with typedef 2m 5s The void type 2m 26s The auto type 4m 20s The unambiguous null pointer constant 3m 32s
  • Operators Common operators 3m 29s Compound assignment operators 4m 42s Increment and decrement operators 5m 43s Comparison (relational) operators 2m Logical operators 2m 48s Bitwise operators 3m 51s The ternary conditional operator 2m 5s Determining the size of a type with sizeof 2m 22s Determining the type of an object with typeid 2m 21s Operator precedence 2m 1s
  • Object Inheritance Overview of class inheritance 1m 45s Simple inheritance 3m 48s Accessing the base class 2m 26s Friendship 3m 23s Multiple inheritance 3m 33s Overloading methods and exploring polymorphism 3m 33s
  • Templates Understanding templates 2m 18s Template functions 4m 20s Template classes 4m 13s Type inference 6m 20s
  • Standard Library Overview of the Standard Library 3m 27s File input and output (I/O) with stdio 9m 20s File management with stdio 2m 35s Unformatted character I/O with stdio 6m 4s Formatted character I/O with stdi 6m 39s String functions 9m Handling system errors 2m 8s Time and date functions 4m 6s
  • Standard Template Library Overview of the STL 2m 30s Vectors 8m 41s Strings 4m 38s I/O streams 8m 10s Iterators 5m 33s Lists 4m Pairs 1m 58s Sets 4m 29s Maps 3m 56s Stacks and queues 6m 20s Handling exceptions 4m 58s
  • Conclusion Goodbye 57s

    • 5
     

    Code Clinic: C++with Bill Weinman
    Course Contents
  • Introduction Welcome 1m 8s About C++ 2m 39s Using the exercise files 49s The C++ classes used in this course 5m 16s Getting the most from Code Clinic 52s
  • Problem One : Exploring Lake Pend Oreille Exploring Lake Pend Oreille 4m 9s Solution overview 2m 51s My solution: Fetching the data 9m 23s My solution: Storing the data 6m 33s My solution: Building a report 4m 37s
  • Problem Two : Image analysis Image analysis 2m 48s Solution overview 2m 3s My solution: Using libjpeg 4m 7s My solution: Fuzzy matching 6m 46s
  • Problem Three : Eight Queens Introduction 1m 51s Overview of the solution 1m 26s Command line interface 9m 17s Implementation 2m 10s Presentation and display 3m 1s
  • Problem Four : Accessing Peripherals Introduction 1m 21s Overview of the solution 3m 50s Interface design 2m 37s Creating the waveform 3m 21s Capturing the touch position 1m 52s
  • Problem Five : Accessing Peripherals Introduction 2m 3s Overview of the solution 6m Searching for files 2m 56s Finding the caption 2m 19s Displaying results 2m 20s
  • Problem Six : Building the Web Introduction 1m 34s Overview of the solution6m 6s Parsing the CSV file 6m 15s Generating XML 3m 45s Processing the HTML file 6m 14s

    • 6
     

    C++: Move Semantics with Bill Weinman
    Course Contents
  • Introduction Welcome 1m 9s Exercise files 3m 37s
  • Concepts What is move semantics? 2m 10s Understanding lvalues and rvalues 1m 33s
  • Using Move Semantics Using std::move 4m 55s Creating a move constructor 5m 38s Creating a move assignment operator 3m 33s Using the copy-and-swap idiom 5m 41s Further considerations 3m 30s Goodbye 42s
    • 7
     

    C++: Smart Pointers with Bill Weinman
    Course Contents
  • Introduction Welcome 1m 5s Exercise files 3m 28s
  • 1. Concepts Why smart pointers? 2m 16s Creating a unique pointer 6m 39s Creating a shared pointer 5m 31s Using a weak pointer 4m 12s Using a custom deleter 3m 41s Choosing a smart pointer 1m 38s
  • Conclusion Goodbye 36s
    • 8
     

    C++: Building a String Librarywith Bill Weinman
    Course Contents
  • Introduction Welcome 1m 21s Using the exercise files 3m 20s Why build a string library? 2m 34s
  • 1. The Basics Overview of BWString 6m 36s Using constructors 6m 13s Exploring memory management 5m 5s Building operators 3m 35s Writing utility methods 2m 18s
  • 2. Adding Features Building find and replace methods 1m 50s Implementing split methods 6m 31s
  • Conclusion Goodbye 45s

    •  

     

    Programming Foundations: Algorithms

     

    Algorithms are the universal building blocks of programming. They power the software you use every day, whether it's a spreadsheet, a social network, or a driving assistant. Algorithms offer a way to think about programming challenges in plain English, before they are translated into a specific language like C# or JavaScript. In this course, author and developer Joe Marini explains some of the most popular and useful algorithms for searching and sorting information, working with techniques like recursion, and understanding common data structures. He also discusses the performance implications of different algorithms and how to evaluate the performance of a given algorithm. Each algorithm is shown in practice in Python, but the lessons can be applied to any programming language.

     

     

     

    Course Contents

     

    Introduction

    Algorithms power the world 1m 2s

    What you should know 1m 35s

     

    Overview

    What are algorithms? 2m 44s

    Common algorithms in programming 5m 42s

    Measuring algorithm performance 3m 47s

     

    Common Data Structures

    Introduction to data structures 1m 56s

    Arrays 2m 29s

    Linked lists 2m 36s

    Linked lists walkthrough 7m 35s

    Stacks and queues 2m 43s

    Stacks and queues walkthrough 6m 2s

    Hash tables 7m 59s

     

    Recursion

    Understanding recursion 3m 38s

    Simple recursion example 3m 9s

    Power and factorial 4m 14s

     

    Sorting Data

    Overview of sorting 2m 4s

    The bubble sort5m 8s

    The merge sort 2m 24s

    Implement the merge sort 5m 10s

    The quicksort 3m 31s

    Implement the quicksort 5m 39s

     

    Searching Data

    Unordered list search 3m 45s

    Ordered list search 5m 30s

    Determine if a list is sorted 3m 37s

     

    Other Algorithms

    Unique filtering with hash table 3m 25s

    Value counting with hash table 3m 4s

    Find max value recursively 3m 44s

     

    Conclusions

    Next steps 1m 18s


    01. Introduction



     
     
    01 - Algorithms power the world
    02 - What you should know



    02. Overview



     
     
     
    03 - What are algorithms
    04 - Common algorithms in programming
    05 - Measuring algorithm performance



    03. Common Data Structures



     
     
     
     
    06 - Introduction to data structures
    07 - Arrays
    08 - Linked lists
    09 - Linked lists walkthrough
     
     
     
    10 - Stacks and queues
    11 - Stacks and queues walkthrough
    12 - Hash tables



    04. Recursion



     
     
     
    13 - Understanding recursion
    14 - Simple recursion example
    15 - Power and factorial



    05. Sorting Data



     
     
     
     
    16 - Overview of sorting
    17 - The bubble sort
    18 - The merge sort
    19 - Implement the merge sort
     
     
    20 - The quicksort
    21 - Implement the quicksort



    06. Searching Data



     
     
     
    22 - Unordered list search
    23 - Ordered list search
    24 - Determine if a list is sorted



    07. Other Algorithms



     
     
     
     
    25 - Unique filtering with hash table
    26 - Value counting with hash table
    27 - Find max value recursively
    28 - Next steps.en



    Learning C++

     

    C++ is an efficient and versatile programming language. C++ powers systems software, desktop applications, and even video games, and it's the language that helped land humans on the moon. Simply put, C++ is a must-know for any modern-day programmer—and it's a great place to get started if you're programming for the first time. This course will get you up and running fast. Instructor Erin Colvin covers simple data types, including numbers and strings; flow-control features like loops and if, else, and switch statements; and functions, the code that encapsulates tasks your program performs. Dr. Colvin also covers working with files and special data structures such as classes and linked lists. Each chapter is full of practical code examples and challenges to help you practice your C++ skills.

     

     

     

    Course Contents

     

    Introduction

    Fun with C++ 43s

    What you should know 25s

     

    Getting Started

    IDE setup 1m 21s

    Algorithms and pseudocode 3m 14s

    How to create a simple program 3m 13s

    Challenge: Hello World 40s

    Solution: Hello World 1m 9s

     

     

    Data Representation

    Declaring simple data types as variables 4m 2s

    Declaration of variables 1m 31s

    Storage of data in memory 8m 16s

    Constants 4m 53s

    Arrays 3m 16s

    Challenge: Random number generator 45s

    Solution: Random number generator 57s

     

    Flow Control

    If statements 6m 2s

    Conditional checking 2m 50s

    Switch statement 3m 53s

    For loop 4m 43s

    While loops 2m

    Do… while loop 12m 51s

    Challenge: Add loop to game 1m 55s

    Solution: Add loop to game 4m 47s

     

    Functions

    What is a function? 3m 15s

    Creating a function 5m 8s

    Function parameters 7m 34s

    Calling, prototypes, and defining functions 6m 6s

    Using functions in our program 4m 35s

    Challenge: Move gameplay to function 1m 27s

    Solution: Move gameplay to function 4m 45s

     

    File I/O

    Opening and reading from a text file 6m 41s

    Open a text file to write to 3m 31s

    Challenge: Write order to file 44s

    Solution: Write order to file 1m 52s

     

    Data Structures

    Structs 6m 17s

    Classes 7m 46s

    Pointers 4m 36s

    Linked lists 5m 52s

    Challenge: Orders in a linked list 43s

    Solution: Orders in a linked list 1m 49s

     

    Conclusion

    Next steps 16s

     

     

     


    01. Introduction



     
     
    01. Fun with C++
    02. What you should know



    2 - 1. Getting Started



     
     
     
     
    03. IDE setup
    04. Algorithms and pseudocode
    05. How to create a simple program
    06. Challenge: Hello World
     
    07. Solution: Hello World



    3 - 2. Data Representation



     
     
     
     
    08. Declaring simple data types as variables
    09. Declaration of variables
    10. Storage of data in memory
    11. Constants
     
     
     
    12. Arrays
    13. Challenge: Random number generator
    14. Solution: Random number generator



    4 - 3. Flow Control



     
     
     
     
    15. If statements
    16. Conditional checking
    17. Switch statement
    18. For loop
     
     
     
     
    19. While loops
    20. Do… while loop
    21. Challenge: Add loop to game
    22. Solution: Add loop to game



    5 - 4. Functions



     
     
     
     
    23. What is a function?
    24. Creating a function
    25. Function parameters
    26. Calling, prototypes, and defining functions
     
     
     
    27. Using functions in our program
    28. Challenge: Move gameplay to function
    29. Solution: Move gameplay to function



    6 - 5. File I/O



     
     
     
     
    30. Opening and reading from a text file
    31. Open a text file to write to
    32. Challenge: Write order to file
    33. Solution: Write order to file



    7 - 6. Data Structures



     
     
     
    https://drive.google.com/open?id=
     
    34. Structs
    35. Classes
    36. Pointers
    37. Linked lists/div>
     
     
     
    38. Challenge: Orders in a linked list
    39. Solution: Orders in a linked list
    40. Next steps



     

    C++ Design Patterns: Creational with Olivia Chiu Stone

    Course details

    Design patterns solve the challenges software developers face over and over again. They are reusable, proven solutions that make your software more reliable and flexible to change. Creational design patterns move the creation of objects out of the main codebase and into separate classes-a best practice known as encapsulation. This course explores the five most popular creational design patterns for C++. To convince you of their merits, instructor Olivia Chiu first explains why we use design patterns in the first place, and what problems that creational patterns can help you solve. She then reviews the core concepts, implementation instructions, and examples for each pattern: Factory, Abstract Factory, Builder, Prototype, and Singleton. She also shows how to extend patterns and compare patterns to find the best fit for your applications.

    Instructor

     

     

     

     

     

     

     

    Course Contents

     

    Introduction

    Welcome 1m 8s

    What you should know 2m 22s

    Installing Visual Studio for Windows 1m 51s

    Installing Visual Studio for Mac 1m 35s

    How to use exercise files 52s

    Challenges explained 46s

     

     

    Design Patterns Overview

    The need for a design pattern 4m 5s

    What are design patterns? 3m 39s

    Creational patterns overview 1m 48s

     

    Creational Patterns

    Inheritance vs. composition 4m

    Composite object example 6m 39s

    Concrete vs. abstract 1m 59s

    Understanding UML 2m 55s

     

    Factory Method

    Factory method concept 5m 36s

    Factory method implementation 5m 12s

    Running the Factory method example 4m 11s

    Factory variations 1m 43s

     

    Abstract Factory

    Abstract Factory concept 4m 50s

    Abstract Factory pattern implementation 6m 3s

    Using the Abstract Factory 4m 14s

    Running the Abstract Factory 3m 44s

    Extending the Abstract Factory 2m 47s

    Challenge 4m 1s

    Solution 8m 57s

     

    Builder

    Builder concept 3m 36s

    Builder pattern setup 4m 10s

    Builder pattern implementation 5m 35s

    Running the Builder example 6m 49s

    Steps in the Builder pattern 2m 5s

     

    Prototype

    Prototype concept 4m 15s

    Prototype pattern implementation 5m 57s

    Running the Prototype example 4m 29s

    Shallow copy vs. deep copy 2m 14s

     

    Singleton

    Singleton concept 3m 2s

    Singleton implementation 4m 8s

    Running the Singleton pattern 3m 54s

    Is the Singleton a good pattern? 5m 29s

    Comparing creational patterns 4m 36s

     

    Conclusion

    Next steps 1m 7s

     

     


    01. Introduction



     
     
     
     
    01. Welcome
    02. What you should know
    03. Installing Visual Studio for Windows
    04. Installing Visual Studio for Mac
     
     
    05. How to use exercise files
    06. Challenges explained



    2 - 1. Design Patterns Overview



     
     
     
    07. The need for a design pattern
    08. What are design patterns
    09. Creational patterns overview



    3 - 2. Creational Patterns



     
     
     
    https://drive.google.com/open?id=
     
    10. Inheritance vs. composition
    11. Composite object example
    12. Concrete vs. abstract
    13. Understanding UML



    4 - 3. Factory Method



     
     
     
     
    14. Factory method concept
    15. Factory method implementation
    16. Running the Factory method example
    17. Factory variations



    5 - 4. Abstract Factory



     
     
     
    h
     
    18. Abstract Factory concept
    19. Abstract Factory pattern implementation
    20. Using the Abstract Factory
    21. Running the Abstract Factory
     
     
     
    22. Extending the Abstract Factory
    23. Challenge
    24. Solution



    6 - 5. Builder



     
     
     
     
    25. Builder concept
    26. Builder pattern setup
    27. Builder pattern implementation
    28. Running the Builder example
     
    29. Steps in the Builder pattern



    7 - 6. Prototype



     
     
     
     
    30. Prototype concept
    31. Prototype pattern implementation
    32. Running the Prototype example
    33. Shallow copy vs. deep copy/div>



    8 - 7. Singleton



     
     
     
     
    34. Singleton concept
    35. Singleton implementation
    36. Running the Singleton pattern
    37. Is the Singleton a good pattern



    9 - Conclusion



     
     
    38. Comparing creational patterns
    39. Next steps



    2 C++ Essential Training with Bill Weinman
    C++ is a workhorse. Widely used for both systems and applications development, C++ is available for virtually every operating system and has influenced and informed many derivative languages, including C# and Java. In this course, Bill Weinman guides you through the nuts and bolts of this essential language. He starts with the basics—syntax, operators, loops, and functions—and moves on to data structures, objects, and templates. He explains inheritance and operator overloads, and dives into the powerful container classes in the Standard Template Library (STL). These exhaustive C++ tutorials will provide a solid reference for both experienced programmers and those who are brand-new to the language.

    Course Contents

     

     

    Introduction

    Welcome 53s

    Using Xcode with the exercises 9m 10s

    Using Microsoft Visual Studio with the exercises 14m 20s

     

    Basic Syntax

    What is C++? 5m 20s

    Introduction to basic syntax 1m 57s

    Anatomy of a C++ program 9m 5s

    Statements and expressions 4m 1s

    Identifiers 2m 14s

    Defining variables 3m 4s

    Pointers 4m 57s

    References 3m 48s

    Arrays and strings 7m 11s

    Conditionals 5m 32s

    The branching conditional 4m 7s

    Looping with while and do 2m 29s

    Iterating with for 4m

    Using the range-based for loop 3m 35s

    Using stdout 7m 1s

     

    Defining Functions

    Overview of C++ functions 3m 15s

    Defining a function 4m 8s

    Passing values to a function 7m 52s

    Using automatic and static variables 3m 5s

    Returning values from a function 3m 19s

    Using function pointer 8m 7s

    Overloading function names 2m 39s

    Overloading operators with functions 5m 23s

    Defining a variable number of arguments 4m 23s

    Using recursion 2m 28s

     

    The Preprocesser

    About the preprocessor 2m 29s

    Using macros as constants 3m 30s

    Including files 2m 31s

    Conditional compilation 1m 52s

    Defining macros 4m 2s

    Macro caveats 3m 12s

    Line continuation with backslash 3m 9s

    Including files only once 4m 6s

     

     

    Classes and Objects

    Overview of classes and objects 2m 14s

    Defining a class 5m 5s

    Data members 5m 15s

    Function members 6m 30s

    Constructors and destructors 9m 3s

    Implicit vs. explicit constructors 4m 32s

    Namespaces 4m 8s

    Pointing to the current object with *this 1m 52s

    Overloading operators with member functions 12m 35s

    Overloading operators with nonmember functions 5m 53s

    Conversion operators 5m 8s

    Creating and destroying objects with new and delete 4m 14s

    Reporting errors with exceptions 2m 56s

    Creating function objects 1m 55s

    Converting numbers to words 13m 45s

     

     

    Data Types

    Overview of data types 2m 49s

    Integral types 9m 50s

    Floating-point types 3m 57s

    Characters and strings 2m 47s

    Character-escape sequences 2m 10s

    Qualifiers 5m 32s

    The C++ reference type 4m 59s

    Structured data 1m 56s

    Bit fields 2m 34s

    Enumerations 3m 50s

    Unions 2m 15s

    Defining types with typedef 2m 5s

    The void type 2m 26s

    The auto type 4m 20s

    The unambiguous null pointer constant 3m 32s

     

     

    Operators

    Common operators 3m 29s

    Compound assignment operators 4m 42s

    Increment and decrement operators 5m 43s

    Comparison (relational) operators 2m

    Logical operators 2m 48s

    Bitwise operators 3m 51s

    The ternary conditional operator 2m 5s

    Determining the size of a type with sizeof 2m 22s

    Determining the type of an object with typeid 2m 21s

    Operator precedence 2m 1s

     

    Object Inheritance

    Overview of class inheritance 1m 45s

    Simple inheritance 3m 48s

    Accessing the base class 2m 26s

    Friendship 3m 23s

    Multiple inheritance 3m 33s

    Overloading methods and exploring polymorphism 3m 33s

     

    Templates

    Understanding templates 2m 18s

    Template functions 4m 20s

    Template classes 4m 13s

    Type inference 6m 20s

     

    Standard Library

    Overview of the Standard Library 3m 27s

    File input and output (I/O) with stdio 9m 20s

    File management with stdio 2m 35s

    Unformatted character I/O with stdio 6m 4s

    Formatted character I/O with stdi 6m 39s

    String functions 9m

    Handling system errors 2m 8s

    Time and date functions 4m 6s

     

    Standard Template Library

    Overview of the STL 2m 30s

    Vectors 8m 41s

    Strings 4m 38s

    I/O streams 8m 10s

    Iterators 5m 33s

    Lists 4m

    Pairs 1m 58s

    Sets 4m 29s

    Maps 3m 56s

    Stacks and queues 6m 20s

    Handling exceptions 4m 58s

     

    Conclusion

    Goodbye 57s




     


    00. Introduction



     
     
     
    00_00 Welcome
    00_01 Using Xcode with the exercises
    00_02 Using Microsoft Visual Studio with the exercises



    01. Basic Syntax



     
     
     
     
    01_01 What is C++
    01_02 Introduction to basic syntax
    01_03 Anatomy of a C++ program
    01_04 Statements and expressions
     
     
     
     
    01_05 Identifiers
    01_06 Defining variables
    01_07 Pointers
    01_08 References
     
     
     
     
    01_09 Arrays and strings
    01_10 Conditionals
    01_11 The branching conditional
    01_12 Looping with while and do
     
     
     
    01_13 Iterating with for
    01_14 Using the range-based for loop
    01_15 Using stdout



    02. Defining Functions



     
     
     
     
    02_01 Overview of C++ functions
    02_02 Defining a function
    02_03 Passing values to a function
    02_04 Using automatic and static variables
     
     
     
     
    02_05 Returning values from a function
    02_06 Using function pointers
    02_07 Overloading function names
    02_08 Overloading operators with functions
     
     
    02_09 Defining a variable number of arguments
    02_10 Using recursion

    here goes to source code for chapter 01



    03. The Preprocessor



     
     
     
     
    03_01 About the preprocessor
    03_02 Using macros as constants
    03_03 Including files
    03_04 Conditional compilation
     
     
     
     
    03_05 Defining macros
    03_06 Macro caveats
    03_07 Line continuation with backslash
    03_08 Including files only once



    04. Classes and Objects



     
     
     
     
    04_01 Overview of classes and objects
    04_02 Defining a class
    04_03 Data members
    04_04 Function members
     
     
     
     
    04_05 Constructors and destructors
    04_06 Implicit vs. explicit constructors
    04_07 Namespaces
    04_08 Pointing to the current object with _this
     
     
     
     
    04_09 Overloading operators with member functions
    04_10 Overloading operators with nonmember functions
    04_11 Conversion operators
    04_12 Creating and destroying objects with new and delete
     
     
     
    04_13 Reporting errors with exceptions
    04_14 Creating function objects
    04_15 Converting numbers to words



    05. Data Types



     
     
     
     
    05_01 Overview of data types
    05_02 Integral types
    05_03 Floating-point types
    05_04 Characters and strings
     
     
     
     
    05_05 Character-escape sequences
    05_06 Qualifiers
    05_07 The C++ reference type
    05_08 Structured data
     
     
     
     
    05_09 Bit fields
    05_10 Enumerations
    05_11 Unions
    05_12 Defining types with typedef
     
     
     
    05_13 The void type
    05_14 The auto type
    05_15 The unambiguous null pointer constant



    06. Operators



     
     
     
     
    06_01 Common operators
    06_02 Compound assignment operators
    06_03 Increment and decrement operators
    06_04 Comparison (relational) operators
     
     
     
     
    06_05 Logical operators
    06_06 Bitwise operators
    06_07 The ternary conditional operator
    06_08 Determining the size of a type with sizeof
     
     
    06_09 Determining the type of an object with typeid
    06_10 Operator precedence



    07. Object Inheritance



     
     
     
     
    07_01 Overview of class inheritance
    07_02 Simple inheritance
    07_03 Accessing the base class
    07_04 Friendship
     
     
    07_05 Multiple inheritance
    07_06 Overloading methods and exploring polymorphism



    08. Templates



     
     
     
     
    08_01 Understanding templates
    08_02 Template functions
    08_03 Template classes
    08_04 Type inference



    09. The Standard Library



     
     
     
     
    09_01 Overview of the Standard Library
    09_02 File input and output (I_O) with stdio
    09_03 File management with stdio
    09_04 Unformatted character I_O with stdio
     
     
     
     
    09_05 Formatted character I_O with stdio
    09_06 String functions
    09_07 Handling system errors
    09_08 Time and date functions



    10. The Standard Library Template



     
     
     
     
    10_01 Overview of the STL
    10_02 Vectors
    10_03 Strings
    10_04 I_O streams
     
     
     
     
    10_05 Iterators
    10_06 Lists
    10_07 Pairs
    10_08 Sets
     
     
     
     
    10_09 Maps
    10_10 Stacks and queues
    10_11 Handling exceptions
    11_01 Goodbye



    Code Clinic: C++

     

     

    Many successful programmers know more than just a computer language. They also know how to think about solving problems. They use "computational thinking": breaking a problem down into segments that lend themselves to technical solutions. Code Clinic is a series of six courses where lynda.com authors solve the same problems using different programming languages. Here, Bill Weinman works with C++.

    Bill introduces challenges and provides an overview of his solutions in C++. Challenges include topics such as statistical analysis, searching directories for images, and accessing peripheral devices.

    Visit other courses in the series to see how to solve the exact same challenges in languages like C#, Java, PHP, Python, and Ruby.

    Instructor

    Skills covered in this course

     

    Course Contents

     

    Introduction

    Welcome 1m 8s

    About C++ 2m 39s

    Using the exercise files 49s

    The C++ classes used in this course 5m 16s

    Getting the most from Code Clinic 52s

     

     

    Problem One : Exploring Lake Pend Oreille

    Exploring Lake Pend Oreille 4m 9s

    Solution overview 2m 51s

    My solution: Fetching the data 9m 23s

    My solution: Storing the data 6m 33s

    My solution: Building a report 4m 37s

     

     

    Problem Two : Image analysis

    Image analysis 2m 48s

    Solution overview 2m 3s

    My solution: Using libjpeg 4m 7s

    My solution: Fuzzy matching 6m 46s

     

    Problem Three : Eight Queens

    Introduction 1m 51s

    Overview of the solution 1m 26s

    Command line interface 9m 17s

    Implementation 2m 10s

    Presentation and display 3m 1s

     

    Problem Four : Accessing Peripherals

    Introduction 1m 21s

    Overview of the solution 3m 50s

    Interface design 2m 37s

    Creating the waveform 3m 21s

    Capturing the touch position 1m 52s

     

    Problem Five : Recursion and Directories

    Introduction 2m 3s

    Overview of the solution 6m

    Searching for files 2m 56s

    Finding the caption 2m 19s

    Displaying results 2m 20s

     

    Problem Six : Building the Web

    Introduction 1m 34s

    Overview of the solution6m 6s

    Parsing the CSV file 6m 15s

    Generating XML 3m 45s

    Processing the HTML file 6m 14s

    Start learning today.


     

     

     

     


    00. Introduction



     
     
     
     
    01. Welcome
    02. About C++
    03. Using the exercise files
    04. The C++ classes used in this course
     
    05. Getting the most from Code Clinic



    01. Problem One : Exploring Lake Pend Oreille



     
     
     
     
    06. Exploring Lake Pend Oreille
    07. Solution overview
    08. My solution - Fetching the data
    09. My solution - Storing the data
     
    10. My solution - Building a report



    02. Problem Two : Image analysis



     
     
     
     
    11. Image analysis
    12. Solution overview
    13. My solution - Using libjpeg
    14. My solution - Fuzzy matching



    03. Problem Three : Eight Queens



     
     
     
     
    15. Introduction
    16. Overview of the solution
    17. Command line interface
    18. Implementation
     
    19. Presentation and display



    04. Problem Four : Accessing Peripherals



     
     
     
     
    20. Introduction
    21. Overview of the solution
    22. Interface design
    23. Creating the waveform
     
    24. Capturing the touch position



    05. Problem Five : Recursion and Directories



     
     
     
     
    25. Introduction
    26. Overview of the solution
    27. Searching for files
    28. Finding the caption
     
    29. Displaying results



    06. Problem Six : Building the Web



     
     
     
     
    30. Introduction
    31. Overview of the solution
    32. Parsing the CSV file
    33. Generating XML
     
    34. Processing the HTML file



    C++: Move Semantics

     

     

    Course details

    Dive deeper into C++ with move semantics, a key component of C++ resource management. Move semantics allow you to optimize the transfer of data and reallocate memory without extra copy operations. In this course, Bill Weinman helps you understand rvalues (temporary values that are the key to move semantics); create move constructors and operations; and use the copy-and-swap idiom to "swap in" new data while destroying the old.

     

     

     

    Introduction

    Welcome 1m 9s

    Exercise files 3m 37s

     

    Concepts

    What is move semantics? 2m 10s

    Understanding lvalues and rvalues 1m 33s

     

    Using Move Semantics

    Using std::move 4m 55s

    Creating a move constructor 5m 38s

    Creating a move assignment operator 3m 33s

    Using the copy-and-swap idiom 5m 41s

    Further considerations 3m 30s

    Goodbye 42s


    01. Inntroduction



     
     
    01. Welcome
    02. Exercise files-417133



    02. Concepts



     
     
    03. What is move semantics
    04. Understanding lvalues and rvalues



    03. Using Move Semantics



     
     
     
     
    05. Using std - -move
    06. Creating a move constructor
    07. Creating a move assignment operator
    08. Using the copy-and-swap idiom
     
     
    09. Further considerations
    10. Goodbye



    C++: Smart Pointers

     

     

    Dive deeper into C++ with smart pointers: intelligent objects that ensure memory and other resources are allocated appropriately and efficiently. Smart pointers are a key component of C++ resource management and a valuable skill for any developer. In this course, Bill Weinman shows how to create unique and shared pointers, use weak and custom pointers, and choose the right smart pointer for your programming objective.

    Instructor

    Skills covered in this course

    Course Contents

     

     

     

    01. Introduction



     
     
     
    01. Welcome
    02. Using Exercise files
    03. Why Smart Pointers



    02. Concepts



     
     
     
     
    04. Creating a unique pointer
    05. Creating a shared pointer
    06. Using a weak pointer
    07. Using a custom deleter
     
     
    08. Choosing a smart pointer
    09. Goodbye



    C++: Building a String Library

     

    Course details

    Adapt your C++ projects to provide the best resource management with custom string libraries. In this short course, Bill Weinman provides an overview of an example string library, BWString, and its key components: constructors, operators, utility methods, and memory management features. He'll also show you how to build find and replace methods and implement split methods.

    Course Contents

    •  

     

    01. Introduction



     
     
     
    01. Welcome
    02. Using Exercise files
    03 Why build a string library



    02. Basics



     
     
     
     
    04. Overview of BWString
    05. Using Constructors
    06. Exploring Memory Management
    07. Building Operators
     
    08. Writing Utility Methods



    03. Adding Features



     
     
     
    09. Building Find and Replace Methods
    10. Implementing Split Methods
    11. Goodbye