Стенли Липпман - Язык программирования C++. Пятое издание

У перегруженных функций, различающих перемещение и копирование параметра, обычно есть одна версия, получающая параметр типа const Т&, и вторая, получающая параметр типа T&&.

В качестве более конкретного примера придадим классу StrVecвторую версию функции push_back():

class StrVec {

public:

void push_back(const std::string&); // копирует элемент

void push_back(std::string&&); // перемещает элемент

// другие члены как прежде

};

// неизменно с оригинальной версии в разделе 13.5

void StrVec::push_back(const string& s) {

chk_n_alloc(); // удостовериться в наличии места для другого элемента

// создать копию s в элементе, на который указывает first_free

alloc.construct(first_free++, s);

}

void StrVec::push_back(string &&s) {

chk_n_alloc(); // пересоздает StrVec при необходимости

alloc.construct(first_free++, std::move(s));

}

Эти функции-члены почти идентичны. Различие в том, что версия ссылки на r-значение функции push_back()вызывает функцию move(), чтобы передать этот параметр функции construct(). Как уже упоминалось, функция construct()использует тип своего второго и последующих аргументов для определения используемого конструктора. Поскольку функция move()возвращает ссылку на r-значение, аргумент функции construct()будет иметь тип string&&. Поэтому для создания нового последнего элемента будет использован конструктор перемещения класса string.

Когда вызывается функция push_back(), тип аргумента определяет, копируется ли новый элемент в контейнер или перемещается:

StrVec vec; // пустой StrVec

string s = "some string or another";

vec.push_back(s); // вызов push_back(const string&)

vec.push_back("done"); // вызов push_back(string&&)

Эти вызовы различаются тем, является ли аргумент l-значением ( s) или r-значением (временная строка, созданная из слова "done"). Вызовы распознаются соответственно.

Обычно функцию-член объекта можно вызвать независимо от того, является ли этот объект l- или r-значением. Например:

string s1 = "a value", s2 = "another";

auto n = (s1 + s2).find('a');

Здесь происходит вызов функции-члена find()(см. раздел 9.5.3) для r-значения класса string, полученного при конкатенации двух строк. Иногда такой способ применения может удивить:

s1 + s2 = "wow!";

Здесь r-значению присваивается результат конкатенации двух строк.

До нового стандарта не было никакого способа предотвратить подобное применение. Для обеспечения совместимости с прежней версией библиотечные классы продолжают поддерживать присвоение r-значению; в собственных классах такое может понадобиться предотвратить. В таком случае левый операнд (т.е. объект, на который указывает указатель this) обязан быть l-значением.

Свойство l- или r-значения указателя thisзадают таким же образом, как и константность функции-члена (см. раздел 7.1.2): помещая квалификатор ссылки (reference qualifier) после списка параметров:

class Foo {

public:

Foo &operator=(const Foo&) & // возможно присвоение только

// изменяемым l-значениям

// другие члены класса Foo

};

Foo &Foo::operator=(const Foo &rhs) & {

// сделать все необходимое для присвоения rhs этому объекту

return *this;

}

Квалификаторы ссылки &или &&означают, что указатель thisможет указывать на r- или l-значение соответственно. Подобно спецификатору const, квалификатор ссылки может быть применен только к (нестатической) функции-члену и должен присутствовать как в объявлении, так и в определении функции.

Функцию, квалифицированную символом &,можно применить только к l-значению, а функцию, квалифицированную символом &&,—только к r-значению:

Foo &retFoo(); // возвращает ссылку;

// вызов retFoo() является l-значением

Foo retVal(); // возвращает значение; вызов retVal() - r-значение

Foo i, j; // i и j - это l-значения

i = j; // ok: i - это l-значение

retFoo() = j; // ok: retFoo() возвращает l-значение

retVal() = j; // ошибка: retVal() возвращает r-значение

i = retVal(); // ok: вполне можно передать r-значение как правый

// операнд присвоения

Функция может быть квалифицирована и ссылкой, и константой. В таких случаях квалификатор ссылки должен следовать за спецификатором const:

class Foo {

public:

Foo someMem() & const; // ошибка: первым должен быть

// спецификатор const

Foo anotherMem() const & // ok: спецификатор const расположен первым

};

Подобно тому, как можно перегрузить функцию-член на основании константности параметра (см. раздел 7.3.2), ее можно перегрузить на основании квалификатора ссылки. Кроме того, функцию можно перегрузить на основании квалификатора ссылки и константности. В качестве примера придадим классу Fooчлен типа vectorи функцию sorted(), возвращающую копию объекта класса Foo, в котором сортируется вектор:

class Foo {

public:

Foo sorted() && // применимо к изменяемым r-значениям

Foo sorted() const & // применимо к любому объекту класса Foo

// другие члены класса Foo

private:

vector data;

};

// этот объект - r-значение, поэтому его можно сортировать на месте

Foo Foo::sorted() && {

sort(data.begin(), data.end());

return *this;

}

// этот объект либо константа, либо l-значение;

// так или иначе, его нельзя сортировать на месте

Foo Foo::sorted() const & {

Foo ret(*this); // создает копию

sort(ret.data.begin(), ret.data.end()); // сортирует копию

return ret; // возвращает копию

}

При выполнении функции sorted()для r-значения вполне безопасно сортировать вектор-член dataнепосредственно. Объект является r-значением, а это означает, что у него нет никаких других пользователей, поэтому данный объект можно изменить непосредственно. При выполнении функции sorted()для константного r- или l-значения изменить этот объект нельзя, поэтому перед сортировкой вектор-член dataнеобходимо скопировать.

Поиск перегруженной функции использует свойство l-значение/r-значение объекта, вызвавшего функцию sorted()для определения используемой версии:

retVal().sorted(); // retVal() - это r-value, вызов Foo::sorted() &&

retFoo().sorted(); // retFoo() - это l-value,