Как скопировать (или поменять местами) объекты типа, который содержит элементы, являющиеся ссылками или константами?

Если вы реализуете это с помощью операторов перемещения, есть способ:

Bar & Bar :: operator = (Bar && source) {
    this -> ~ Bar ();
    new (this) Bar (std :: move (source));
    return *this;
}

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

std::vector и другие контейнеры теперь используют операции перемещения везде, где это возможно, поэтому изменение размера, сортировка и т. Д. Будет в порядке.

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

И, кстати, никогда не следует использовать memcpy таким образом для типов, не относящихся к POD.

Редактировать

Ответ на жалобу на неопределенное поведение.

Проблемный случай кажется

struct X {
    const int & member;
    X & operator = (X &&) { ... as above ... }
    ...
};

X x;
const int & foo = x.member;
X = std :: move (some_other_X);
// foo is no longer valid

Верно, это неопределенное поведение, если вы продолжите использовать foo. Для меня это то же самое, что

X * x = new X ();
const int & foo = x.member;
delete x;

в котором совершенно ясно, что использование foo недопустимо.

Возможно, наивное прочтение X::operator=(X&&) заставит вас подумать, что, возможно, foo все еще действует после хода, примерно так

const int & (X::*ptr) = &X::member;
X x;
// x.*ptr is x.member
X = std :: move (some_other_X);
// x.*ptr is STILL x.member

Указатель элемента ptr переживает перемещение x, но foo - нет.

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

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

class BarBase
{
    Foo* foo;
    int number;
protected:
    BarBase(Foo& f, int num): foo(&f), number(num) {}
    int get_number() const { return number; }
    Foo& get_foo() { return *foo; }
    const Foo& get_foo() const { return *foo; }
};

struct Bar : private BarBase {
  Bar (Foo & foo, int num) : BarBase(foo, num) {}

  // Mutable member data elided
};

(Кстати, это не обязательно должен быть базовый класс. Также может быть членом с общедоступными методами доступа.)

этот константный член действительно должен быть константным

Что ж, тогда нельзя переназначить объект, а? Потому что это изменило бы значение того, что вы только что сказали, действительно не должно меняться: до того, как присваивание foo.x равно 1, а bar.x равно 2, а вы делаете foo = bar, тогда если foo.x "действительно должно быть константой", то что должно произойти? Вы сказали ему изменить foo.x, который на самом деле не должен быть изменен.

Элемент вектора похож на foo, это объект, который иногда модифицирует контейнер.

Pimpl может быть подходящим вариантом. Динамически выделяйте объект ("impl"), содержащий все ваши данные-члены, включая константные и ссылки. Сохраните указатель на этот объект («p») в вашем объекте, который входит в вектор. Тогда swap является тривиальным (поменять местами указатели), как и присвоение перемещения, а присвоение копирования может быть реализовано путем создания нового impl и удаления старого.

Затем любые операции на Impl сохраняют постоянство и непереставляемость ваших элементов данных, но небольшое количество операций, связанных с жизненным циклом, может воздействовать непосредственно на P.

Однако при этом теряются преимущества ссылок перед указателями.

Нет никакого преимущества. Указатели и ссылки разные, но ни один из них не лучший. Вы используете ссылку, чтобы убедиться, что существует действительный экземпляр, и указатель, если передача nullptr действительна. В вашем примере вы можете передать ссылку и сохранить указатель

struct Bar {
   Bar (Foo & foo) : foo_reference(&foo) {}
private:
   Foo * foo_reference;
};

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

#include <functional>

template <class T>
class readonly_wrapper
{
    T value;
public:
    explicit readonly_wrapper(const T& t): value(t) {}
    const T& get() const { return value; }
    operator const T& () const { return value; }
};

struct Foo{};

struct Bar {
  Bar (Foo & foo, int num) : foo_reference(foo), number(num) {}
private:
  std::reference_wrapper<Foo> foo_reference;  //C++11, Boost has one too
  readonly_wrapper<int> number;
  // Mutable member data elided
};

#include <vector>
int main()
{
  std::vector<Bar> bar_vector;
  Foo foo;
  bar_vector.push_back(Bar(foo, 10));
};