C++ Standard Template Library in Practice

C++ Standard Template Library in Practice, available at $69.99, has an average rating of 4.57, with 96 lectures, 7 quizzes, based on 246 reviews, and has 1612 subscribers.

You will learn about Efficient and effective ways to store data using STL containers Manage application performance using STL memory allocation classes, and enhance these classes by developing your allocation routines How data is structured and how the structure can be traversed using iterators How algorithms are used to transform data into useful and meaningful information Multitasking and managing shared data using concurrency and parallelism Managing input and output (I/O) using streams and the role of stream buffers How the STL has standardized common tasks This course is ideal for individuals who are If you want to overcome difficult phases of development with C++ and leverage its features using modern programming practices, then this course is for you. It is particularly useful for If you want to overcome difficult phases of development with C++ and leverage its features using modern programming practices, then this course is for you.

Enroll now: C++ Standard Template Library in Practice

Summary

Title: C++ Standard Template Library in Practice

Price: $69.99

Average Rating: 4.57

Number of Lectures: 96

Number of Quizzes: 7

Number of Published Lectures: 96

Number of Published Quizzes: 7

Number of Curriculum Items: 103

Number of Published Curriculum Objects: 103

Original Price: $109.99

Quality Status: approved

Status: Live

What You Will Learn

Efficient and effective ways to store data using STL containers
Manage application performance using STL memory allocation classes, and enhance these classes by developing your allocation routines
How data is structured and how the structure can be traversed using iterators
How algorithms are used to transform data into useful and meaningful information
Multitasking and managing shared data using concurrency and parallelism
Managing input and output (I/O) using streams and the role of stream buffers
How the STL has standardized common tasks

Who Should Attend

If you want to overcome difficult phases of development with C++ and leverage its features using modern programming practices, then this course is for you.

Target Audiences

If you want to overcome difficult phases of development with C++ and leverage its features using modern programming practices, then this course is for you.

C++ is one of the most widely used programming languages. Fast, efficient, and flexible, it is used to solve many problems. In particular, it is the Standard Template Library (STL) that gives C++ its power. In this course, we show you how.

Using real-world examples, we focus on how STL handles and manipulates data. We examine containers and iterators, and how data can be transformed into meaningful information using algorithms. There is coverage of I/O streams, strings and numerical methods, and how performance can be optimized through careful consideration of memory allocation and manipulation. We also demonstrate how multitasking and shared data is handled through concurrency and parallelism classes and utilities.

By the end of the course, you will understand the newer aspects of C++ STL and will be able to overcome tasks that are time-consuming or would break your stride while developing.

About the Author

James Slocum has been a professional developer for over 10 years. He graduated from NJIT with a Bachelor’s degree in Computer Engineering in 2008, and again with a Master’s in Computer Science in 2011. He currently works for Audible as a software engineer and tech lead for the library group. The languages he uses the most are Java, JavaScript, C++, and Dart. In his free time, he enjoys learning about new languages and technology.

Course Curriculum

Chapter 1: Introducing the Standard Template Library (STL)

Lecture 1: The Course Overview

Lecture 2: Introduction to the STL

Lecture 3: General Concepts

Lecture 4: Utilities – Common Utilities

Lecture 5: Utilities – Regex

Lecture 6: Project – Bitcoin Exchange Program

Lecture 7: Project – Coding

Lecture 8: Project – Custom Writer Function

Lecture 9: Review

Chapter 2: Containers

Lecture 1: Understanding Containers

Lecture 2: Vectors

Lecture 3: Standard Array

Lecture 4: Lists

Lecture 5: Stacks and Queues

Lecture 6: Maps and Multimaps – Overview

Lecture 7: Maps – Coding

Lecture 8: Multimaps – Coding

Lecture 9: Sets and Multisets

Lecture 10: Project

Lecture 11: Review

Chapter 3: Iterators – Manipulating Data

Lecture 1: Iterators

Lecture 2: Input Iterators

Lecture 3: Output Iterators

Lecture 4: Forward Iterators

Lecture 5: Bidirectional Iterators

Lecture 6: Random Access Iterators

Lecture 7: Auxiliary Iterator Functions

Lecture 8: Iterator Adaptors

Lecture 9: Writing Generic Functions for Iterators

Lecture 10: User – Defined Iterators

Lecture 11: Project

Lecture 12: Review

Chapter 4: Algorithms – Part One

Lecture 1: Introduction to Algorithms

Lecture 2: Sequence Algorithms – for_each

Lecture 3: Sequence Algorithms – equals

Lecture 4: Copying

Lecture 5: Moving

Lecture 6: Removing

Lecture 7: Sorting and Gathering – std::sort

Lecture 8: Sorting and Gathering – std::partial_sort algorithm

Lecture 9: Sorting and Gathering – std::partition

Lecture 10: Sorting and Gathering – std::partition_copy

Lecture 11: Searching and Finding – std::find

Lecture 12: Sorting and Gathering – std::find_first_of, std::adjacent_find

Lecture 13: Sorting and Gathering – std::search

Lecture 14: Sorting and Gathering – std::binary_search

Lecture 15: Counting

Chapter 5: Algorithms – Part Two

Lecture 1: Replacing and Transforming – std::replace

Lecture 2: Replacing and Transforming – std::replace_copy

Lecture 3: Replacing and Transforming – equals

Lecture 4: Swapping

Lecture 5: Rotating

Lecture 6: Randomizing

Lecture 7: Permutations

Lecture 8: Sampling

Lecture 9: Min

Lecture 10: Max

Lecture 11: Clamp

Lecture 12: Fill and Generate

Lecture 13: Numeric Algorithms – std::accumulate

Lecture 14: Numeric Algorithms – std::partial_sum and std::adjacent_difference

Lecture 15: Numeric Algorithms – std::gcd, and std::lcm

Lecture 16: Numeric Algorithms – std::inner_product and std::iota

Lecture 17: Review

Chapter 6: I/O in C++

Lecture 1: Basic Architecture of the I/O Stream Library

Lecture 2: Console I/O – Interact with a User

Lecture 3: Console I/O – Read Input

Lecture 4: File I/O

Lecture 5: String Streams

Lecture 6: Manipulators and Formatters

Lecture 7: Stream States

Lecture 8: Low Level I/O

Lecture 9: Overloading Stream Operators

Lecture 10: Project – Overview

Lecture 11: Project – Classes and structures

Lecture 12: Project – Implementation

Lecture 13: Review

Chapter 7: Memory

Lecture 1: Unique Pointers

Lecture 2: Shared Pointers

Lecture 3: Allocators

Lecture 4: Defining an Allocator

Lecture 5: Uninitialized Memory

Lecture 6: Review

Chapter 8: Threading

Lecture 1: Introduction to Threading

Lecture 2: Creating Threads

Lecture 3: Locks

Instructors

Packt Publishing
Tech Knowledge in Motion

Rating Distribution

1 stars: 6 votes
2 stars: 7 votes
3 stars: 25 votes
4 stars: 86 votes
5 stars: 122 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!

Menu