Следует ли использовать тип только для перемещения только потому, что копирование может быть дорогостоящим?

Следует ли использовать тип только для перемещения только потому, что копирование может быть дорогостоящим?

Нет. Если семантика вашего типа такова, что копирование имеет концептуальный смысл, то правильный способ сделать копирование доступным - реализовать конструктор копирования и дать пользователю возможность принять стандартный синтаксис для его вызова. :

T a;
T a = b;

Если люди забудут отойти от предметов, которыми больше не хотят пользоваться ... Что ж, в этом их беда:

T c = std::move(a); // I'm doing it right (if I no longer need object a);
T d = b; // If I don't need b anymore, I'm doing it wrong.

И если (по какой-либо причине) для некоторых ваших функций всегда желательно, чтобы вызывающий объект предоставлял объект, из которого можно перемещаться, тогда пусть функция принимает ссылку rvalue:

void foo(my_class&& obj);

my_class a;
foo(a); // ERROR!
foo(std::move(a)); // OK

Я бы рассматривал класс как не копируемый в подписи, если копирование достаточно дорогое. Семантически вещи можно копировать только в том случае, если вы хотите, чтобы они были копируемыми, а дорогая копия - достойный повод принять решение «нет, копировать нельзя».

Возможность чего-либо копировать не означает, что это нужно реализовать в копируемом типе. Разработчик этого типа должен решить, следует ли его семантически копировать.

Я бы не назвал операцию, которая произвела дорогостоящую копию, «копией», а скорее «клонированием» или «дубликатом».

Например, вы могли бы сделать это:

#include <utility>

template<typename T>
struct DoCopy {
  T const& t;
  DoCopy( T const& t_ ):t(t_) {}
};
template<typename T>
DoCopy<T> do_copy( T const& t ) {
  return t;
}
struct Foo {
  struct ExpensiveToCopy {
    int _[100000000];
  };
  ExpensiveToCopy* data;
  Foo():data(new ExpensiveToCopy()) {}
  ~Foo(){ delete data; }
  Foo(Foo&& o):data(o.data) { o.data = nullptr; }
  Foo& operator=(Foo&& o) { data=o.data; o.data=nullptr; return *this; }
  Foo& operator=(DoCopy<Foo> o) {
    delete data;
    if (o.t.data) {
      data=new ExpensiveToCopy(*o.t.data);
    } else {
      data=new ExpensiveToCopy();
    }
    return *this;
  }
  Foo( DoCopy<Foo> cp ):data(cp.t.data?new ExpensiveToCopy( *cp.t.data ):new ExpensiveToCopy() ) {};
};
int main() {
  Foo one;
  // Foo two = one; // illegal
  Foo three = std::move(one); // legal
  Foo four;
  Foo five = do_copy(three);
  four = std::move(three);
  five = do_copy(four);
}

Это в некоторой степени похоже на то, как вы могли написать std::move подобную семантику до существования ссылок на rvalue, с теми же недостатками, что и у таких методов, а именно: сам язык не знает, какие махинации вы затеваете.

Его преимущество состоит в том, что синтаксис приведенного выше do_copy аналогичен синтаксису std::move и позволяет использовать традиционные выражения без необходимости создавать тривиальные экземпляры Foo, а затем создавать копию другой переменной и т. Д.

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

Нет. Если тип копируемый, значит тип копируемый. Это означает, что его конструктор копирования доступен и работает. Это не означает, что существует некоторая функция-член, имя которой выглядит как символы c, o, p и y, которая делает «что-то вроде почти аналогичного».