Move constructors

Da cppreference.com.

Questa pagina è stata tradotta in modo automatico dalla versione in ineglese della wiki usando Google Translate.

La traduzione potrebbe contenere errori e termini strani. Muovi il puntatore sopra al testo per vedere la versione originale. Puoi aiutarci a correggere gli gli errori. Per ulteriori istruzioni clicca qui.

Click here for the English version of this page

Linguaggio C + +

Temi generali

Preprocessore
Commenti
Parole chiave

Tabella ASCII
Sequenze di escape
La storia del C + +

Controllo del flusso

Dichiarazioni esecuzione condizionale

if statement

switch statement

Iterazione dichiarazioni

`for` loop
range-`for` loop (C++11)

`while` loop
`do-while` loop

Vai dichiarazioni

`continue` statement
`break` statement

`goto` statement
`return` statement

Funzioni

dichiarazione di funzione

lambda funzione dichiarazione

funzione di modello

specificatore inline

eccezioni specifiche (deprecato)

noexcept specificatore (C++11)

Eccezioni

tiro espressione

blocco try-catch

Spazi dei nomi

namespace dichiarazione

alias dello spazio dei nomi

Tipi

tipi fondamentali
composti tipi
enumerazione tipi

sindacali tipi
tipi di funzione

decltype specifier (C++11)

Specifiers

cv specificatori

Durata di stoccaggio specificatori

constexpr specificatore (C++11)

specificatore auto (C++11)

alignas specificatore (C++11)

Inizializzazione

predefinito di inizializzazione
valore di inizializzazione
inizializzazione a zero
copiare inizializzazione
inizializzazione diretta

inizializzazioni di aggregazione
elenco di inizializzazione (C++11)
inizializzazione delle costanti
riferimento inizializzazione

Letterali

letterali interi
caratteri letterali
virgola mobile letterali
stringhe letterali

letterali booleani
nullptr (C++11)
definito dall'utente (C++11)

Espressioni

valore categorie
ordine di valutazione

operatori
precedenza degli operatori

rappresentazioni alternative

Utilities

Tipi

typedef declaration

Tipo alias dichiarazione (C++11)

attributi (C++11)

Lancia

conversioni implicite

const_cast conversion

static_cast conversion

dynamic_cast conversion

reinterpret_cast conversion

Fusione C-stile e funzionale

Occupazione della memoria

new expression

delete expression

Classi

classe di dichiarazione
`this` pointer
specificatori di accesso

amico specificatore
liste di inizializzazione

Specifiche per una classe di funzioni proprietà

funzione virtuale
ignorare specificatore (C++11)
identificatore finale (C++11)

esplicito (C++11)
statico

Funzioni membro speciali

costruttore di default
costruttore di copia
spostare costruttore (C++11)

copiare assegnazione
spostare l'assegnazione (C++11)
distruttore

Modelli

classe template

funzione di modello

modello di specializzazione

parametri confezioni (C++11)

Varie

Montaggio in linea

[edit]

Un costruttore mossa di T classe non è un modello di costruzione il cui primo parametro è T&&, const T&&, volatile T&& o const volatile T&&, e sia non ci sono altri parametri, o il resto dei parametri di tutti hanno valori di default. Un tipo con un costruttore mossa pubblico MoveConstructible.

Indice

[modifica] Sintassi


class_name ( class_name `&&` )	(1)	(dal C++11)

class_name ( class_name `&&` ) = default;	(2)	(dal C++11)

class_name ( class_name `&&` ) = delete;	(3)	(dal C++11)

[modifica] Spiegazione

# Dichiarazione tipica di un costruttore mossa

# Forzare un costruttore mossa per essere generato dal compilatore

# Evitare costruttore implicito mossa

Il costruttore mossa è chiamata quando un oggetto è inizializzato da xValue dello stesso tipo, che comprende

inizializzazione, T a = std::move(b); o T a(std::move(b));, dove b è di tipo T
Original:
initialization, T a = std::move(b); or T a(std::move(b));, where b is of type T
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Passaggio di argomenti funzione: f(std::move(a));, dove a è di tipo T e f è void f(T t)
Original:
function argument passing: f(std::move(a));, where a is of type T and f is void f(T t)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
di ritorno della funzione: return a; all'interno di una funzione, ad esempio T f(), dove a è di T tipo che ha un costruttore mossa.
Original:
function return: return a; inside a function such as T f(), where a is of type T which has a move constructor.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Spostare costruttori tipicamente "rubare" le risorse contenute l'argomento (ad esempio i puntatori a oggetti allocati dinamicamente, descrittori di file, socket TCP, I / O ruscelli, thread in esecuzione, ecc), piuttosto che farne delle copie, e lasciare l'argomento in uno stato valido ma per il resto indeterminato. Ad esempio, passando da un std::string o da un std::vector trasforma l'argomento vuoto.

[modifica] Implicitamente-ha dichiarato costruttore mossa

Se non definite dall'utente costruttori di movimento vengono forniti per un tipo di classe (struct, class o union), e tutte le seguenti condizioni:

non ci sono dichiarate dall'utente costruttori di copia
Original:
there are no user-declared copy constructors
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
non ci sono utenti-operatori di assegnamento copia dichiarata
Original:
there are no user-declared copy assignment operators
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
non ci sono dall'utente dichiarato operatori di assegnazione di spostamento
Original:
there are no user-declared move assignment operators
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
non ci sono dichiarate dall'utente destructurs
Original:
there are no user-declared destructurs
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
il costruttore mossa implicitamente dichiarato-non potrebbe essere definita come cancellati
Original:
the implicitly-declared move constructor would not be defined as deleted
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

allora il compilatore dichiarare un costruttore mossa come membro inline public della sua classe con la T::T(T&&) firma

Una classe può avere costruttori si muovono di più, ad es sia T::T(const T&&) e T::T(T&&). Se alcuni definiti dall'utente costruttori movimento sono presenti, l'utente può comunque forzare la generazione del costruttore mossa implicitamente dichiarata con la parola chiave default.

[modifica] Soppresso implicitamente dichiarato costruttore mossa

Il costruttore mossa implicitamente dichiarate o inadempiente per T classe è definita come cancellati in una qualsiasi delle seguenti condizioni:

T ha membri non statici di dati che non possono essere spostati (sono state eliminate, inaccessibili, o costruttori spostare ambigue)
Original:
T has non-static data members that cannot be moved (have deleted, inaccessible, or ambiguous move constructors)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
T ha classe base diretta o virtuale che non possono essere spostati (ha eliminato, inaccessibile, o costruttori spostare ambigue)
Original:
T has direct or virtual base class that cannot be moved (has deleted, inaccessible, or ambiguous move constructors)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
T ha classe base diretta o virtuale con un distruttore cancellati o inaccessibili
Original:
T has direct or virtual base class with a deleted or inaccessible destructor
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
T ha definito dall'utente costruttore movimento o operatore di assegnazione di spostamento
Original:
T has a user-defined move constructor or move assignment operator
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
T è un sindacato e ha un membro variante con non banale costruttore di copia
Original:
T is a union and has a variant member with non-trivial copy constructor
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
T ha un membro non statico di dati o di una base diretta o virtuale senza un costruttore mossa che non è banalmente copiabili.
Original:
T has a non-static data member or a direct or virtual base without a move constructor that is not trivially copyable.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifica] Mossa costruttore Trivial

Il costruttore mossa implicitamente dichiarato per-T classe è banale se tutte le seguenti condizioni:

T non ha funzioni membro virtuali
Original:
T has no virtual member functions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
T non ha classi base virtuali
Original:
T has no virtual base classes
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Il costruttore mossa selezionata per ogni base diretta di T è banale
Original:
The move constructor selected for every direct base of T is trivial
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Il costruttore mossa selezionati per ogni non-static tipo di classe (o una matrice di tipo di classe) memeber di T è banale
Original:
The move constructor selected for every non-static class type (or array of class type) memeber of T is trivial
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Un costruttore mossa banale è un costruttore che esegue la stessa azione, come il costruttore di copia banale, che è, fa una copia della rappresentazione dell'oggetto come per std::memmove. Tutti i tipi di dati compatibili con il linguaggio C (tipo POD) sono banalmente mobili.

[modifica] Implicitamente definito costruttore mossa

Se il costruttore mossa implicitamente dichiarato-non viene eliminato o banale, è definito (cioè corpo di una funzione viene generato e compilato) da parte del compilatore. Per i tipi union, il costruttore mossa implicitamente definito copia la rappresentazione dell'oggetto (come da std::memmove). Per i non-sindacali tipi di classe (class e struct), il costruttore mossa esegue membro a pieno titolo-mossa saggia di basi dell'oggetto e membri non statici, nel loro ordine di inizializzazione, utilizzando l'inizializzazione diretta con un argomento xValue.

[modifica] Note

Per rendere garanzia eccezione forte possibile, definite dall'utente costruttori movimento non deve generare eccezioni. In realtà, contenitori standard tipicamente si basano su std::move_if_noexcept di scegliere tra movimento e copia quando elementi contenitori devono essere trasferiti.

Se entrambi i costruttori di copia e spostamento sono previsti, risoluzione dell'overload seleziona il costruttore mossa se l'argomento è un rvalue (o prvalue come una temporanea senza nome o xValue, come il risultato di std::move) , e seleziona il costruttore di copia se l'argomento è lvalue' (oggetto con nome o di una funzione / operatore di ritorno valore assegnabile di riferimento). Se solo il costruttore di copia è previsto, tutte le categorie di argomenti selezionarlo (come tempo necessario riferimento a const, in quanto rvalues può legarsi a riferimenti const), il che rende la copia del fallback per lo spostamento, quando si muove non è più disponibile.
Original:
If both copy and move constructors are provided, overload resolution selects the move constructor if the argument is an rvalue (either prvalue such as a nameless temporary or xvalue such as the result of std::move), and selects the copy constructor if the argument is lvalue (named object or a function/operator returning lvalue reference). If only the copy constructor is provided, all argument categories select it (as long as it takes reference to const, since rvalues can bind to const references), which makes copying the fallback for moving, when moving is unavailable.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

In molte situazioni, i costruttori movimento sono ottimizzati fuori anche se produrrebbero osservabili effetti collaterali, copia elisione vedere

[modifica] Esempio

#include <string>
#include <iostream>
 
struct A {
    std::string s;
    A() : s("test") {}
    A(const A& o) : s(o.s) { std::cout << "move failed!\n";}
    A(A&& o) : s(std::move(o.s)) {}
};
 
A f(A a) {
    return a;
}
 
struct B : A {
     std::string s2; 
     int n;
     // implicit move-contructor B::(B&&)
     // calls A's move constructor
     // calls s2's move constructor
     // and makes a bitwise copy of n
};
 
struct C : B {
    ~C() {}; // destructor prevents implicit move
};
 
struct D : B {
    D() {}
    ~D() {}; // destructor would prevent implicit move
    D(D&&) = default; // force a move ctor anyway
};
 
int main()
{
    std::cout << "Trying to move A\n";
    A a1 = f(A()); // move-construct from rvalue temporary
    A a2 = std::move(a1); // move-construct from xvalue
 
    std::cout << "Trying to move B\n";
    B b1;
    std::cout << "Before move, b1.s = \"" << b1.s << "\"\n";
    B b2 = std::move(b1); // calls implicit move ctor
    std::cout << "After move, b1.s = \"" << b1.s << "\"\n";
 
    std::cout << "Trying to move C\n";
    C c1;
    C c2 = std::move(c1); // calls the copy constructor
 
    std::cout << "Trying to move D\n";
    D d1;
    D d2 = std::move(d1);
}

Output:

Trying to move A
Trying to move B
Before move, b1.s = "test"
After move, b1.s = ""
Trying to move C
move failed!
Trying to move D

Estratto da "https://it.cppreference.com/mwiki/index.php?title=cpp/language/move_constructor&oldid=25960"

Linguaggio
Concetti
Libreria di Utilità
Stringhe
Contenitori
Algoritmi
Iteratori
Libreria matematca
Input/output
Localizzazione
Espressioni regolari (C++11)
Operazioni atomicche (C++11)
Multithreading (C++11)

cppreference.com

Namespace

Varianti

Visite

Azioni