Что такое «ссылки rvalue для этого»?

Question

Каковы наиболее типичные случаи использования «ссылок rvalue для * this», которые стандарт также называет ссылочными квалификаторами для функций-членов?

Кстати, есть действительно хорошее объяснение об этой функции языка here.

Answer 1

При вызове каждая функция-член имеет параметр неявного объекта, который ссылается на *this.

So (а) эти нормальные функции Перегрузки:

void f(const T&); 
void f(T&&); 

при вызове как f(x); и (б) эти функции члена перегружает:

struct C 
{ 
    void f() const &; 
    void f() &&; 
}; 

когда называют как x.f() - как (а) и (б) отправку с подобной жизнеспособностью и ранжированием.

Таким образом, варианты использования практически одинаковы. Они должны поддерживать перемещение семантической оптимизации. В функции RValue члена вы можете существенно грабить объекты ресурсов, потому что вы знаете, что это истекающий объект (собирается быть удалена):

int main() 
{ 
    C c; 
    c.f(); // lvalue, so calls lvalue-reference member f 
    C().f(); // temporary is prvalue, so called rvalue-reference member f 
    move(c).f(); // move changes c to xvalue, so again calls rvalue-reference member f 
} 

Так, например:

struct C 
{ 
    C operator+(const C& that) const & 
    { 
     C c(*this); // take a copy of this 
     c += that; 
     return c; 
    } 

    C operator+(const C& that) && 
    { 
     (*this) += that; 
     return move(*this); // moving this is ok here 
    } 
} 

Answer 2

Некоторые операции могут быть более эффективным при вызове rvalues, поэтому перегрузка по категории значений *this позволяет автоматически использовать наиболее эффективную реализацию, например

struct Buffer 
{ 
    std::string m_data; 
public: 
    std::string str() const& { return m_data; }  // copies data 
    std::string str()&& { return std::move(m_data); } // moves data 
}; 

(Эта оптимизация может быть сделано для std::ostringstream, но не был официально предложен AFAIK.)

Некоторые операции не имеют смысла вызывать на rvalues, поэтому перегрузка на *this позволяет форму RValue будет удалено:

struct Foo 
{ 
    void mutate()&; 
    void mutate()&& = delete; 
}; 

Я на самом деле не нужно использовать эту функцию еще, но, возможно, я найду больше пользы для него теперь, когда два компиляторов я забочусь о поддержке его.

Answer 3

В моей структуре компилятора (который будет выпущен Sometime Soon ™) вы передаете элементы информации, такие как токены, в объект компилятора, а затем вызовите finalize, чтобы указать конец потока.

Было бы плохо уничтожить объект, не вызвав finalize, потому что он не вытолкнул бы весь его выход. Тем не менее finalize не может быть выполнен деструктором, поскольку он может генерировать исключение, а также неправильно спрашивать finalize для получения большего объема вывода, если парсер уже прерывается.

В случае, когда весь вход уже инкапсулирован другим объектом, приятно передать вход в объект компилятора rvalue.

pile< lexer, parser >(output_handler).pass(open_file("source.q")); 

Без специальной поддержки, то это должно быть неправильным, потому что finalize не вызывался. Интерфейс не должен позволять пользователю делать такую ​​вещь вообще.

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

void pass(input_file f) & { 
    process_the_file(); 
} 

Это делает комнату, чтобы добавить еще одну перегрузки, которая должным образом объект обеспечивающих окончательную. Это rvalue ref-qual, поэтому он выбирается, только если вызывается на объект, который истекает.

void pass(input_file f) && { 
    pass(std::move(f)); // dispatch to lvalue case 
    finalize(); 
} 

Теперь пользователю практически никогда не нужно беспокоиться о запоминании называть finalize, так как большинство объектов компилятора, в конечном счете экземпляра в качестве временных.

---

Обратите внимание, что это не относится к квалифицированным членам. Любая функция может иметь отдельные перегрузки для t & и t &&. Путь pass фактически в настоящее время реализуются использует совершенную переадресацию, а затем откатывается, чтобы определить правильную семантику:

template< typename compiler, typename arg > 
void pass(compiler && c, arg a) { 
    c.take_input(a); 

    if (! std::is_reference<compiler>::value) { 
     c.finalize(); 
    } 
} 

Есть много способов приблизиться к перегрузке. На самом деле, неквалифицированные функции-члены необычны в , но не заботятся о категории (lvalue или rvalue) объекта, на который они вызваны, и не передают эту информацию в функцию. Любой параметр функции, кроме неявного this, должен сказать что-то о категории его аргумента.