STL efficiency when using big objects - c++

Question

To be more specific let's restrict the scope of the question to libstdc++ and Visual C++.
Consider the case when objects stored in a container have the following properties:
Copying and assignment can be expensive
Moving and swapping is cheap and never throws
Default constructor is cheap and never throws
Some of the containers may and will reallocate/move stored objects when elements are added or removed. In that case do the above mentioned STL implementations avoid copying when reallocating/moving elements?
What about std::sort and other algorithms?
If you think about it there is no need for copying when moving and swapping is available.
As you may know all STL operation provide Big O complexity guaranties. Big O means there is constant multiplied by some function of N. My question could be paraphrased by asking what does that constant include? Does it include the cost of copying or it is proportional to the cost of moving/swapping?
Thanks you.

Answer 1

The only general answer that can be given is that C++ is made by smart people that care a lot about performance so you usually won't find easy optimizations missed out and shouldn't worry too much about your standard library's performance.
You can answer these question type-by-type and function-by-function by reading the specification in the standard, websites like cppreference.com or the documentation that comes with your implementation. For example, if std::vector::push_back has to re-allocate its internal buffer, it will use the move constructor to “copy” over the elements if and only if such constructor exists and is declared noexcept (also see std::move_if_noexcept).
A different approach to reason about what is actually going on inside your standard library is taking it for a test drive. Instrument a simple struct to print out logging messages from its constructors and assignment operators, then put instances of that class into a standard library container and exercise some algorithm on it. The following example uses std::vector and std::sort. You can play with it by using different containers and algorithms. Also see what's happening if you make the changes indicated by the comments.
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <random>
#include <vector>
struct Example
{
int id;
Example(const int id) : id {id}
{
std::cout << __PRETTY_FUNCTION__ << std::endl;
}
Example(const Example& rhs) : id {rhs.id}
{
std::cout << __PRETTY_FUNCTION__ << std::endl;
}
// try commenting out the 'noexcept'
Example(Example&& rhs) noexcept : id {rhs.id}
{
std::cout << __PRETTY_FUNCTION__ << std::endl;
}
Example&
operator=(const Example& rhs)
{
this->id = rhs.id;
std::cout << __PRETTY_FUNCTION__ << std::endl;
return *this;
}
// try commenting out the 'noexcept'
Example&
operator=(Example&& rhs) noexcept
{
this->id = rhs.id;
std::cout << __PRETTY_FUNCTION__ << std::endl;
return *this;
}
~Example() noexcept
{
std::cout << __PRETTY_FUNCTION__ << std::endl;
}
};
int
main()
{
const auto n = 10;
auto rndeng = std::default_random_engine {};
auto rnddst = std::uniform_int_distribution<int> {};
auto elements = std::vector<Example> {};
std::cout << "CONSTRUCTING VECTOR OF " << n << " ELEMENTS...\n\n";
elements.reserve(n); // try commenting this out
for (auto i = 0; i < n; ++i)
elements.emplace_back(rnddst(rndeng)); // try using push_back instead
const auto cmp = [](const Example& lhs, const Example& rhs){
return lhs.id < rhs.id;
};
std::cout << "\nSORTING ELEMENTS...\n\n";
std::sort(elements.begin(), elements.end(), cmp);
std::cout << "\nSORTED ELEMENTS:\n\n";
for (const auto& elem : elements)
std::cout << std::setw(16) << elem.id << "\n";
std::cout << "\nLEAVING MAIN...\n\n";
}