std :: vector :: äquivalent für QVector zuweisen

Question

Ich habe ein Array im C-Stil, und ich möchte es einem QVector zuweisen. Wenn ich std :: vector verwendet haben, würde ich assign() verwendet haben:

int arr[] = { 1, 2, 3, 4, 5 }; 
std::vector<int> v; 
v.assign(arr, arr + sizeof(arr)/sizeof(int)); 

Aber für QVector konnte ich nicht ein ähnliches assign() Verfahren oder über Bereich annehme Konstruktor finden.

Ich habe bereits eine for-Schleife dafür programmiert, aber ich war überrascht, dass es keine so grundlegende Funktion gab, ist das wirklich so, oder gibt es eine Entsprechung?

Answer 1

können Sie Qt verwenden qCopy():

int arr[] = { 1, 2, 3, 4, 5 }; 
QVector<int> v(5); 
qCopy(arr, arr+5, v.begin()); 

Oder Sie können std::copy() natürlich nutzen.

int arr[] = { 1, 2, 3, 4, 5 }; 
QVector<int> v(5); 
std::copy_n(&arr, 5, v.begin()); 
// or more general: 
QVector<int> v2; 
std::copy(std::begin(arr), std::end(arr), std::back_inserter(v2)); 
// without begin/end 
std::copy(arr, arr + 5, std::back_inserter(v2)); 

Answer 2

Es gibt fromStdVector(), die Ihnen eine QVector von einem std::vector erstellen können:

int arr[] = { 1, 2, 3, 4, 5 }; 
std::vector<int> v; 
v.assign(arr, arr + sizeof(arr)/sizeof(arr[0])); 
QVector<int> qvec = QVector<int>::fromStdVector(v); 

Answer 3

für einfache Typen (zB int, char, void * ... usw.), können Sie die Vorteile :: memcpy

int arr[] = { 1, 2, 3, 4, 5 }; 

const int CNT = sizeof(arr)/sizeof(int); 
QVector<int> v(CNT); 

// memcpy may be faster than std::copy_n in some compiler 
::memcpy(v.data(), arr, CNT * sizeof(int)); 

für Objekte (zB std :: string) erfolgen kann, eine Schleife schreiben, um die Objekte von Ank bis V

dann rufen nur die Kopie-Konstruktoren one-by-one

zB kopieren

std::string arr[] = { std::string("a"), std::string("b"), std::string("c") }; 
const int CNT = sizeof(arr)/sizeof(std::string); 
QVector<std::string> v(CNT); 
for(size_t i = 0; i < CNT ; ++i) 
    v[i] = arr[i]; 

Als Copykonstruktor für jedes Objekt in arr one-by-one aufgerufen werden muss, ich bin sicher, dass es nicht eine schnellere Lösung sein wird (auch verwenden Sie die std :: copy()).

Und der obige Code kann kleinere Code-Größe im Vergleich zu std :: copy in einigen Compilern ergeben.