Explore the full potential of C++ by mastering the standard library.

Become a C++ Programmer

The C++ standard library is a collection of all the tools and utilities available in C++. It received its latest update in 2017, known as C++17. The update introduces many new features that further optimize our code. This module will help us fully grasp C++ and use it to its full potential.

C++ Standard Library

The function [`std::move`](http://en.cppreference.com/w/cpp/utility/move), defined in the header `<utility>`, empowers the compiler to move its resource. In the so-called *move semantic*, the values from the source object are moved to the new object. Afterward, the source is in a *well-defined* but not specified state. Most of the times that is the default state of the source. By using `std::move`, the compiler converts the source `arg` to a rvalue reference: `static_cast<std::remove_reference<decltype(arg)>::type&&> (arg)`. 

The subtle difference is that if we create a new object based on an existing one, the copy semantic will copy the elements of the existing resource, whereas the move semantic will move the elements of the resource. So, of course, copying is expensive and moving is cheap. But there are additional serious consequences.

1. With the copy semantic, it is possible that a [std::bad_alloc](https://en.cppreference.com/w/cpp/memory/new/bad_alloc) will be thrown because our program is out of memory.
2. The source of the move operation is in a *"valid but unspecified state"* afterward.

The second point can be explained well by `std::string` example below. 

If the compiler can not apply the *move semantic*, it falls back to the *copy semantic*.

## Vector elements

The function [`std::move`](http://en.cppreference.com/w/cpp/utility/move), defined in the header `<utility>`, empowers the compiler to move its resource. In the so-called *move semantic*, the values from the source object are moved to the new object. Afterward, the source is in a *well-defined* but not specified state. Most of the times that is the default state of the source. By using `std::move`, the compiler converts the source `arg` to a rvalue reference: `static_cast<std::remove_reference<decltype(arg)>::type&&> (arg)`. 

The subtle difference is that if we create a new object based on an existing one, the copy semantic will copy the elements of the existing resource, whereas the move semantic will move the elements of the resource. So, of course, copying is expensive and moving is cheap. But there are additional serious consequences.

1. With the copy semantic, it is possible that a [std::bad_alloc](https://en.cppreference.com/w/cpp/memory/new/bad_alloc) will be thrown because our program is out of memory.
2. The source of the move operation is in a *"valid but unspecified state"* afterward.

The second point can be explained well by `std::string` example below. 

If the compiler can not apply the *move semantic*, it falls back to the *copy semantic*.

# Vector elements

In this lesson we'll see how the std::move utility proves more efficient than copying.

The Standard Library

Overview

Application of Libraries

Useful Functions

Adaptors for Functions

Pairs and Tuples

Reference Wrappers

Smart Pointers

Type Traits

Time Library

std::any, std::optional, and std::variant

Containers in General

Sequential Containers

Associative Containers in General

Ordered Associative Containers

Unordered Associative Containers

Adaptors for Containers

Iterators

Callable Units

Algorithms

Non-Modifying Algorithms

Modifying Algorithms

More Algorithms

New Algorithms with C++17

Numeric

Strings

String View

Regular Expressions

Input and Output Streams

Conclusion

Move vs. Copy