Dlaczego zwracanie wektora przez wartość typu jawnie niemobilnego i niejawnie nie generuje błędu kompilacji?

Question

Mam ten prosty przykład klasy uchwyt, który jest wyraźnie non-ruchoma:

template <typename T> 
struct holder 
{ 
    holder() = default; 

    holder(const holder& b) 
     : t(b.t) 
    { 
    } 

    holder(holder&& b) = delete; 

    holder& operator=(const holder& b) 
    { 
     t = b.t; 
     return *this; 
    } 

    holder& operator=(holder&& b) = delete; 

    T t; 
}; 

Poniższy typ jest więc także w sposób dorozumiany zakaz copyable (ze względu std::unique_ptr jest taki):

typedef holder<std::unique_ptr<int>> ptr; 

Więc, Tak jak przypuszczam, jeśli mam funkcję podobną do ptr foo();, wywołanie jej przez auto x = foo; lub ptr x; x = foo(); powoduje błąd kompilacji, przez który wywoływana jest funkcja usunięta.

Jednak jeśli mogę przedstawić inny typ wektora ptr tak:

typedef std::vector<ptr> vec; 

vec foo(); 

int main() 
{ 
    vec x = foo(); 
    x = foo(); 
    return 0; 
} 

... to kompiluje grzywny.

Jak to możliwe? Jak to działa?

(przykład pomyślnego zestawienia można znaleźć here)

Answer 1

nie mówiąc już Rvo, wektor jest ruchoma niezależnie od charakterystyki TYP elementu.