Можем ли мы вернуть объекты с удаленным/приватным конструктором копирования/перемещения по значению из функции?

Вот как это может работать

A f() {
  return { 10 };
}

Это работает даже несмотря на то, что у A нет рабочей копии или конструктора перемещения и нет другого конструктора, который мог бы копировать или перемещать A!

Чтобы использовать эту функцию C++11, конструктор (в данном случае берущий int) должен быть неявным.

Ограничение не снято. Что касается спецификатора доступа, в §12.8/32 есть примечание, в котором объясняется:

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

Что касается удаленных конструкторов копирования/перемещения, в §8.4.3/2 говорится, что

Программа, которая явно или неявно ссылается на удаленную функцию, кроме ее объявления, является некорректной. [Примечание: это включает неявный или явный вызов функции и формирование указателя или указателя на член функции. Это применимо даже для ссылок в выражениях, которые потенциально не оцениваются. Если функция перегружена, на нее ссылаются, только если функция выбрана разрешением перегрузки. — примечание в конце]

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

Приведенный выше код по-прежнему плохо сформирован в C++11. Но вы можете добавить в A конструктор общедоступного перемещения, и тогда это будет законно:

struct A
{
    A(int x) {}
    A(A&&);
private:
    A(A const&);
};

A f() {
  return A(10); // Ok!
}

Мне было интересно, снято ли это ограничение в С++ 11?

Как это могло произойти? Возвращая что-то по значению, вы по определению копируете (или перемещаете) это. И хотя C++ может позволить исключить это копирование/перемещение в определенных обстоятельствах, он по-прежнему копирует (или перемещает) в соответствии со спецификацией.

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

да. Вы избавляетесь от конструктора/назначения копирования, но разрешаете перемещать значение. std::unique_ptr делает это.

Вы можете вернуть unique_ptr по значению. Но при этом вы возвращаете «prvalue»: временное, которое уничтожается. Поэтому, если у вас есть функция g как таковая:

std::unique_ptr<SomeType> g() {...}

Ты можешь это сделать:

std::unique_ptr<SomeType> value = g();

Но не это:

std::unique_ptr<SomeType> value1 = g();
std::unique_ptr<SomeType> value2 = g();
value1 = value 2;

Но это возможно возможно:

std::unique_ptr<SomeType> value = g();
value = g();

Вторая строка вызывает оператор присваивания перемещения для value. Он удалит старый указатель и переместит в него новый указатель, оставив старое значение пустым.

Таким образом, вы можете быть уверены, что содержимое любого unique_ptr хранится только в одном месте. Вы не можете запретить им ссылаться на него в нескольких местах (через указатели на unique_ptr или что-то еще), но в памяти будет не более одного места, где хранится фактический указатель.

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

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

Что-то вроде:

template<typename T>
struct ReturnProxy {
    //This could be made private, provided appropriate frienship is granted
    ReturnProxy(T* p_) : p(p_) { }
    ReturnProxy(ReturnProxy&&) = default;

private:
    //don't want these Proxies sticking around...
    ReturnProxy(const ReturnProxy&) = delete;
    void operator =(const ReturnProxy&) = delete;
    void operator =(ReturnProxy&&) = delete;

    struct SUPER_FRIENDS { typedef T GO; };
    friend struct SUPER_FRIENDS::GO;
    unique_ptr<T> p;
};

struct Object {
    Object() : data(0) { }

    //Pseudo-copy constructor
    Object(ReturnProxy<Object>&& proxy)
      : data(proxy.p ? proxy.p->data : throw "Don't get sneaky with me \\glare") 
    {
      //steals `proxy.p` so that there isn't a second copy of this object floating around
      //shouldn't be necessary, but some men just want to watch the world burn.
      unique_ptr<Object> thief(std::move(proxy.p));
    }
private:
    int data;

    Object(const Object&) = delete;
    void operator =(const Object&) = delete;
};

ReturnProxy<Object> func() {
    return ReturnProxy(new Object);
}

int main() {
    Object o(func());
}

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