Как правильно пересылать unique_ptr?

Поскольку вам действительно не нужно обращаться к p после его перемещения, один из способов — получить p->x перед перемещением, а затем использовать его.

Пример:

unique_ptr<C> transform1(unique_ptr<C> p) {
    int x = p->x;
    return transform2(move(p), x);
}

Код не подходит.

• std::move — не что иное, как приведение (g++: что-то вроде static_cast<typename std::remove_reference<T>::type&&>(value))
• Вычисление значения и побочные эффекты каждого выражения аргумента упорядочены до выполнения вызываемой функции.
• Однако инициализация параметров функции происходит в контексте вызывающей функции. (Спасибо TC)

Цитаты из черновика N4296:

1.9/15 Выполнение программы

[...] При вызове функции (независимо от того, является ли функция встроенной) каждое вычисление значения и побочный эффект, связанные с любым выражением аргумента или с постфиксным выражением, обозначающим вызываемую функцию, упорядочены перед выполнением каждого выражения или оператора в теле вызываемой функции. [...]

5.2.2/4 Вызов функции

При вызове функции каждый параметр (8.3.5) должен быть инициализирован (8.5, 12.8, 12.1) соответствующим аргументом. [Примечание: такие инициализации неопределенно упорядочены по отношению друг к другу (1.9) примечание] [...] Инициализация и уничтожение каждого параметра происходит в контексте вызывающей функции. [...]

Образец (г++ 4.8.4):

#include <iostream>
#include <memory>
struct X
{
    int x = 1;
    X() {}
    X(const X&) = delete;
    X(X&&) {}
    X& operator = (const X&) = delete;
    X& operator = (X&&) = delete;
};


void f(std::shared_ptr<X> a, X* ap, X* bp, std::shared_ptr<X> b){
    std::cout << a->x << ", " << ap << ", " << bp << ", " << b->x << '\n';
}

int main()
{
    auto a = std::make_unique<X>();
    auto b = std::make_unique<X>();
    f(std::move(a), a.get(), b.get(), std::move(b));
}

Вывод может быть 1, 0xb0f010, 0, 2, показывающим, что (нулевой) указатель сдвинут.

Прекратите выполнять более одной операции в одной строке, если только операции не мутируют.

Код не быстрее, если он весь в одной строке, и зачастую он менее корректен.

std::move — это изменяющая операция (или, точнее, она помечает операцию, которой следует следовать, как «мутировать нормально»). Он должен быть на отдельной строке или, по крайней мере, на строке без какого-либо другого взаимодействия с его параметром.

Это как foo( i++, i ). Вы что-то модифицировали и тоже использовали.

Если вам нужна универсальная безмозглая привычка, просто свяжите все аргументы в std::forward_as_tuple и вызовите std::apply для вызова функции.

unique_ptr<C> transform1(unique_ptr<C> p) {
  return std::experimental::apply( transform2, std::forward_as_tuple( std::move(p), p->x ) );
}

что позволяет избежать проблемы, потому что мутация p выполняется в строке, отличной от чтения адреса p.get() в p->x.

Или сверните свой собственный:

template<class F, class...Args>
auto call( F&& f, Args&&...args )
->std::result_of_t<F(Args...)>
{
  return std::forward<F>(f)(std::forward_as_tuple(std::forward<Args>)...);
}
unique_ptr<C> transform1(unique_ptr<C> p) {
  return call( transform2, std::move(p), p->x );
}

Цель здесь состоит в том, чтобы упорядочить выражения оценки параметра отдельно от инициализации оценки параметра. Он по-прежнему не устраняет некоторые проблемы, связанные с перемещением (например, SSO std::basic_string move-guts и проблемы со ссылкой на символ).

Кроме того, надеюсь, что компилятор добавит предупреждения для неупорядоченного mutate-and-read в общем случае.

Как отмечено в ответе Дитера Люкинга, вычисления значений выполняются до тела функции, поэтому std::move и operator -> располагаются перед телом функции --- 1,9/15.

Однако это не указывает, что инициализация параметра выполняется после всех этих вычислений, они могут появляться где угодно по отношению друг к другу и к независимым вычислениям значений, если они выполняются до тело функции --- 5.2.2/4.

Это означает, что поведение здесь не определено, поскольку одно выражение изменяет p (переходя во временный аргумент), а другое использует значение p, см. https://stackoverflow.com/a/26911480/166389. Хотя, как упоминалось там, P0145 предлагает исправить порядок оценки слева направо (в данном случае). Это означало бы, что ваш код неисправен, но transform2(p->x, move(p)) будет делать то, что вы хотите. (Исправлено благодаря TC)

Что касается идиом, чтобы избежать этого, рассмотрите подход Дэвида Хейма с использованием unique_ptr<C> по ссылке, хотя это довольно непрозрачно для вызывающего абонента . Вы сигнализируете что-то вроде «Может изменить этот указатель». Состояние перемещения unique_ptr достаточно ясно, так что это вряд ли укусит вас так сильно, как если бы вы перешли от переданной ссылки на объект или что-то в этом роде.

В конце концов, вам нужна точка последовательности между использованием p и изменением p.

аммм ... не то чтобы ответ, а предложение - зачем вообще передавать право собственности на unique_ptr? кажется, что transformXXX играет с целочисленным значением, почему здесь должно играть роль управление памятью?

передать unique_ptr по ссылке:

unique_ptr<C>& transform1(unique_ptr<C>& p) {
    return transform2(p, p->x); // 
}

unique_ptr<C>& transform2(unique_ptr<C> p&, int val) {
    p->x *= val;
    return p;
}

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

Вообще говоря, нет надежного способа сделать это, не заботясь о мелких деталях. Где это становится действительно подлым, так это в списках-инициализации-членов.

Просто в качестве примера, который идет на один шаг дальше вашего, что произойдет, если p->x сам является объектом, время жизни которого зависит от *p, а затем transform2(), который фактически не знает о временной связи между своими аргументами, передает val вперед к какой-либо функции приемника, не заботясь о том, чтобы сохранить *p в живых. И, учитывая его собственный масштаб, как он узнает, что должен?

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