Представьте, что ваш материал был классом с выделенной кучей памяти, как строка, и что он имел понятие емкости. Дайте ему оператор + =, который увеличит емкость геометрически. В C ++ 03 это может выглядеть так:
#include <iostream>
#include <algorithm>
struct stuff
{
int size;
int cap;
stuff(int size_):size(size_)
{
cap = size;
if (cap > 0)
std::cout <<"allocating " << cap <<std::endl;
}
stuff(const stuff & g):size(g.size), cap(g.cap)
{
if (cap > 0)
std::cout <<"allocating " << cap <<std::endl;
}
~stuff()
{
if (cap > 0)
std::cout << "deallocating " << cap << '\n';
}
stuff& operator+=(const stuff& y)
{
if (cap < size+y.size)
{
if (cap > 0)
std::cout << "deallocating " << cap << '\n';
cap = std::max(2*cap, size+y.size);
std::cout <<"allocating " << cap <<std::endl;
}
size += y.size;
return *this;
}
};
stuff operator+(const stuff& lhs,const stuff& rhs)
{
stuff g(lhs.size + rhs.size);
return g;
}
Также представьте, что вы хотите добавить больше, чем две вещи одновременно:
int main()
{
stuff a(11),b(9),c(7),d(5);
std::cout << "start addition\n\n";
stuff e = a+b+c+d;
std::cout << "\nend addition\n";
}
Для меня это печатает:
allocating 11
allocating 9
allocating 7
allocating 5
start addition
allocating 20
allocating 27
allocating 32
deallocating 27
deallocating 20
end addition
deallocating 32
deallocating 5
deallocating 7
deallocating 9
deallocating 11
Я считаю 3 распределения и 2 освобождения для вычисления:
stuff e = a+b+c+d;
Теперь добавьте семантику перемещения:
stuff(stuff&& g):size(g.size), cap(g.cap)
{
g.cap = 0;
g.size = 0;
}
...
stuff operator+(stuff&& lhs,const stuff& rhs)
{
return std::move(lhs += rhs);
}
Запустив снова, я получаю:
allocating 11
allocating 9
allocating 7
allocating 5
start addition
allocating 20
deallocating 20
allocating 40
end addition
deallocating 40
deallocating 5
deallocating 7
deallocating 9
deallocating 11
Теперь у меня 2 распределения и 1 освобождение. Это означает более быстрый код.