Qualcuno conosce il modo di definire un vettore di dimensioni costanti?Vettore a dimensione costante
Ad esempio, invece di definire
std::vector<int>
sarà
std::vector<10, int>
Dovrebbe essere completamente cross-platformed. Forse una classe open source?
La std :: vector può sempre crescere dinamicamente, ma ci sono due modi per allocare una dimensione iniziale:
Questo alloca dimensioni iniziali e riempie gli elementi con zeri:
std::vector<int> v(10);
v.size(); //returns 10
This alloca una dimensione iniziale, ma non compilare la matrice con zeri:
std::vector<int> v;
v.reserve(10);
v.size(); //returns 0
Usa std::arrayc++11
Per una migliore leggibilità è possibile effettuare typedef:
typedef std::array<int, 10> MyIntArray;
Naturalmente, dal momento che' scrivendo C++ 11, scriveremmo 'usando MyIntArray = std :: array
Non v'è alcun modo per definire un formato di vettore costante. Se si conosce la dimensione in fase di compilazione, è possibile utilizzare l'aggregato std::array di C++ 11.
#include <array>
std::array<int, 10> a;
Se non si dispone del relativo supporto C++ 11, è possibile utilizzare la versione TR1:
#include <tr1/array>
std::tr1::array<int, 10> a;
o boost::array, come è stato suggerito in altre risposte.
Anche se si ricorda che 'array' è diverso da' vector' in quanto i dati sono contenuti all'interno dell'oggetto. Per 10 pollici potresti non notare mai la differenza, ma per i grandi array potresti (ad esempio) notare che non hanno 'O (1)' 'swap', mentre i vettori di grandi dimensioni lo fanno. –
Sappi anche che un array non ha un concetto di 'size' vs' capacity' come fa il vettore. In un array 'size' ==' max_size'. Cioè, non puoi creare una matrice di dimensione 10 (es .: spazio per 10 possibili elementi), ma popola solo 5 e aspettati 'size' per restituire 5. –
A std::vector è un contenitore dinamico, non esiste alcun meccanismo per limitare la sua crescita. Per assegnare una dimensione iniziale:
std::vector<int> v(10);
C++ 11 ha una std::array che sarebbe più appropriato:
std::array<int, 10> my_array;
Se il compilatore non supporta C++ 11 considerare l'utilizzo di boost::array:
boost::array<int, 10> my_array;
Questo ---->std::vector<10, int> non è valido e causa un errore. Ma il nuovo standard C++ ha introdotto una nuova classe; lo std :: array. È possibile dichiarare un array come questo:
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
Il std::array ha parità di perimetro e supporta iterator/const_iterator/reverse_iterator/const_reverse_iterator. Puoi trovare ulteriori informazioni su questo corso allo http://cplusplus.com/reference/stl/array/.
Se si desidera un tempo di compilazione fisso dimensione specificata (ala std::array<T, N>), ma si desidera essere in grado di popolare il vettore con un numero variabile di elementi tra 0 e N, quindi una buona opzione è eastl::fixed_vector.
std :: vector:
La dimensione di un std::vector è dinamico - che assegnerà memoria richiesto in modo dinamico, e non è possibile limitare la dimensione e far rispettare un errore.
È tuttavia possibile reserve una certa dimensione e quindi aggiungere elementi di dimensioni tali prima che sia necessario allocare nuovo spazio di archiviazione.
vector.size() è inizialmente 0, e aumenta quando si aggiungono elementss
std :: array:
La dimensione di un std::array è una costante della fase di compilazione - allocherà memoria necessario staticamente, e non puoi cambiare la taglia.
array.size() è sempre la dimensione della matrice, ed è pari a array.max_size()
eastl :: f ixed_vector:
Le dimensioni di un eastl::fixed_vector possono essere statici o dinamici.
Assegnerà inizialmente un certo numero di elementi e, se si consente la crescita dinamica, verrà allocata dinamicamente se necessario.
Ai fini originariamente chiesto, è possibile disabilitare la crescita (tramite bEnableOverflow nel modello di istanza di seguito)
fixed_vector.size() è inizialmente 0, e aumenta quando si aggiungono elementi.
template<typename T,
size_t nodeCount,
bool bEnableOverflow = true,
typename OverflowAllocator =
typename eastl::type_select<bEnableOverflow,
EASTLAllocatorType,
EASTLDummyAllocatorType>::type>
class fixed_vector;
semplice esempio:
#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;
}
uscita:
size=0 capacity=10
size=10 capacity=10
size=0 capacity=10
Si noti che la dimensione del array è 10, mentre vector e fixed_vector sono 0
se fosse un vettore di un tipo definito dall'utente che è stato dato una dimensione iniziale, a cosa sarebbe inizializzato? – simplename