Kennt jemand den Weg, um Vektor konstanter Größe zu definieren?Vektor mit konstanter Größe
Zum Beispiel statt
std::vector<int>
definieren, wird es
std::vector<10, int>
sein Es sollte vollständig Quer platformed sein. Vielleicht eine Open-Source-Klasse?
Die std :: vector kann immer dynamisch wachsen, aber es gibt zwei Möglichkeiten, wie Sie eine Anfangsgröße zuordnen kann
std::vector<int> v(10);
v.size(); //returns 10
Diese zuordnet eine anfängliche Größe, aber nicht bevölkert nicht das Array mit Nullen:
std::vector<int> v;
v.reserve(10);
v.size(); //returns 0
Verwenden std::arrayc++11
Zur besseren Lesbarkeit können Sie machen typedef:
typedef std::array<int, 10> MyIntArray;
Natürlich, da wir Um C++ 11 zu schreiben, würden wir 'using MyIntArray = std :: array
Es gibt keine Möglichkeit, eine konstante Größe Vektor zu definieren. Wenn Sie die Größe zum Zeitpunkt der Kompilierung kennen, können Sie C++ 11s std::array Aggregat verwenden.
#include <array>
std::array<int, 10> a;
Wenn Sie nicht über die entsprechende C++ 11-Unterstützung haben, könnten Sie die TR1-Version verwenden:
#include <tr1/array>
std::tr1::array<int, 10> a;
oder boost::array, wie in anderen Antworten vorgeschlagen.
Beachten Sie, dass "Array" sich von "Vektor" unterscheidet, da die Daten im Objekt enthalten sind. Für 10 Ints mag man den Unterschied vielleicht nie bemerken, aber für große Arrays kann man (zum Beispiel) bemerken, dass sie nicht "O (1)' swap "haben, während große Vektoren dies tun. –
Beachten Sie auch, dass ein Array kein Konzept von "Größe" vs. "Kapazität" hat, wie Vektor. In einem Array 'size' ==' max_size'. Das heißt, Sie können kein Array der Größe 10 erstellen (dh Platz für 10 mögliche Elemente), sondern nur 5 auffüllen und erwarten, dass 'size' 5 zurückgibt. –
Ein std::vector ist ein dynamischer Container, es gibt keinen Mechanismus, um das Wachstum zu beschränken. So weist eine Anfangsgröße:
std::vector<int> v(10);
C++ 11 ein std::array hat, die besser geeignet wäre:
std::array<int, 10> my_array;
Wenn Ihr Compiler nicht C 11 ++ unterstützt prüfen, mit boost::array:
boost::array<int, 10> my_array;
Diese ---->std::vector<10, int> ist ungültig und verursacht einen Fehler. Aber der neue C++ - Standard hat eine neue Klasse eingeführt; das std :: -Array. Sie können ein Array wie folgt erklären:
std::array<int, 5> arr; // declares a new array that holds 5 ints
std::array<int, 5> arr2(arr); // arr2 is equal to arr
std::array<int, 5> arr3 = {1, 2, 3, 4, 5}; // arr3 holds 1, 2, 3, 4, 5
Die std::array konstante Größe hat und unterstützt iterator/const_iterator/reverse_iterator/const_reverse_iterator. Sie können mehr über diese Klasse bei http://cplusplus.com/reference/stl/array/ finden. Diese ordnet anfängliche Größe und füllt die Elemente mit Nullen
:
Wenn Sie eine feste Übersetzungszeit festgelegte Größe (ala std::array<T, N>) mögen, aber Sie möchten in der Lage sein, den Vektor mit einer unterschiedlichen Anzahl von Elementen zwischen 0 und N zu füllen, dann ist eine gute Option eastl::fixed_vector.
std :: vector:
Die Größe eines std::vector ist dynamisch - es wird dynamisch erforderliche Speicher zuweisen, und Sie können nicht die Größe begrenzen und einen Fehler erzwingen.
Sie können jedoch reserve eine bestimmte Größe, und fügen Sie Elemente dann auf diese Größe, bevor es neuen Speicher zuweisen muss.
vector.size() ist zunächst 0 und erhöht sich, wenn Sie elementss
std :: Array hinzufügen:
Die Größe eines std::array ist eine Kompilierung-Konstante - es wird erforderlich Lagerung statisch zuweisen, und Sie können die Größe nicht ändern.
array.size() ist immer der Größe des Arrays, und ist gleich array.max_size()
eastl :: fixed_vector:
Die Größe eines eastl::fixed_vector kann entweder statisch oder dynamisch sein.
Es wird zunächst eine bestimmte Anzahl von Elementen zugewiesen, und wenn Sie dynamisches Wachstum zulassen, wird es bei Bedarf dynamisch zugewiesen.
Für die Zwecke ursprünglich gefragt, können Sie das Wachstum (über bEnableOverflow in der Vorlage Instanziierung unten) deaktivieren
fixed_vector.size() anfänglich 0 ist, und erhöht sich, wenn Sie Elemente hinzufügen.
template<typename T,
size_t nodeCount,
bool bEnableOverflow = true,
typename OverflowAllocator =
typename eastl::type_select<bEnableOverflow,
EASTLAllocatorType,
EASTLDummyAllocatorType>::type>
class fixed_vector;
Einfaches Beispiel:
#include <iostream>
#include <vector>
#include <array>
#include "EASTL/fixed_vector.h"
int main()
{
std::vector<int> v;
v.reserve(10);
std::cout << "size=" << v.size() << " capacity=" << v.capacity() << '\n';
std::array<int, 10> a;
std::cout << "size=" << a.size() << " capacity=" << a.max_size() << '\n';
eastl::fixed_vector<int, 10, false> fv;
std::cout << "size=" << fv.size() << " capacity=" << fv.capacity() << '\n';
return 0;
}
Ausgang:
size=0 capacity=10
size=10 capacity=10
size=0 capacity=10
Beachten Sie, dass die Größe der array 10 ist, während vector und fixed_vector sind 0
wenn es ein Vektor eines benutzerdefinierten Typs ist, der angegeben wurde eine anfängliche Größe, womit würde es initialisiert werden? – simplename