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

Первой версии функции push_back() можно передать любой объект, который может быть приведен к типу X. Эта версия копирует данные своего параметра. Второй версии можно передать только r-значение, которое не является константой. Эта версия точнее и лучшее соответствует неконстантным r-значениям и будет выполнена при передаче поддающегося изменению r-значения (см. раздел 13.6.2). Эта версия способна захватить ресурсы своего параметра.

Обычно нет никакой необходимости определять версии функций получающих const X&& или просто X&. Обычно ссылку на r-значение передают при необходимости "захватить" аргумент. Для этого аргумент не должен быть константой. Точно так же копирование объекта не должно изменять скопированный объект. В результате обычно нет никакой необходимости определять версию, получающую простой параметр X&.

У перегруженных функций, различающих перемещение и копирование параметра, обычно есть одна версия, получающая параметр типа 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<int> 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,

                   // вызов Foo::sorted() const &

При определении константных функций-членов можно определить две версии, отличающиеся только тем, что одна имеет квалификатор const, а другая нет. Для ссылочной квалификации функций ничего подобного по умолчанию нет. При определении двух или более функций-членов с тем же именем и тем же списком параметров следует предоставить квалификатор ссылки для всех или ни для одной из этих функций: