Créer une taille fixe std::vector et d'écrire sur les éléments

Ce n'est pas possible sans l'écriture de votre propre classe wrapper. Si vous souhaitez utiliser une plaine std::vector, vous devez compter sur l'auto-discipline, en n'utilisant pas les fonctions de membre insert(), push_back() ou emplace_back(), que ce soit directement ou indirectement (par exemple par l'intermédiaire d'un back_inserter).

Remarque qu'il y a une proposition pour les tableaux dynamiques pour le nouveau C++14 Standard:

[...] nous proposons de définir une nouvelle installation pour tableaux où le nombre de
éléments est lié à la construction. Nous appelons ces tableaux dynamiques,
dynarray.

La proposition vient avec une implémentation de référence que vous pouvez utiliser dans votre propre code (assurez-vous de changer namespace std en quelque chose d'autre pour le moment).

namespace std {
template< class T >
struct dynarray
{
//types:
typedef       T                               value_type;
typedef       T&                              reference;
typedef const T&                              const_reference;
typedef       T*                              iterator;
typedef const T*                              const_iterator;
typedef std::reverse_iterator<iterator>       reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef size_t                                size_type;
typedef ptrdiff_t                             difference_type;
//fields:
private:
T*        store;
size_type count;
//helper functions:
void check(size_type n)
{ if ( n >= count ) throw out_of_range("dynarray"); }
T* alloc(size_type n)
{ if ( n > std::numeric_limits<size_type>::max()/sizeof(T) )
throw std::bad_array_length();
return reinterpret_cast<T*>( new char[ n*sizeof(T) ] ); }
public:
//construct and destruct:
dynarray() = delete;
const dynarray operator=(const dynarray&) = delete;
explicit dynarray(size_type c)
: store( alloc( c ) ), count( c )
{ size_type i;
try {
for ( size_type i = 0; i < count; ++i )
new (store+i) T;
} catch ( ... ) {
for ( ; i > 0; --i )
(store+(i-1))->~T();
throw;
} }
dynarray(const dynarray& d)
: store( alloc( d.count ) ), count( d.count )
{ try { uninitialized_copy( d.begin(), d.end(), begin() ); }
catch ( ... ) { delete store; throw; } }
~dynarray()
{ for ( size_type i = 0; i < count; ++i )
(store+i)->~T();
delete[] store; }
//iterators:
iterator       begin()        { return store; }
const_iterator begin()  const { return store; }
const_iterator cbegin() const { return store; }
iterator       end()          { return store + count; }
const_iterator end()    const { return store + count; }
const_iterator cend()   const { return store + count; }
reverse_iterator       rbegin()       
{ return reverse_iterator(end()); }
const_reverse_iterator rbegin()  const
{ return reverse_iterator(end()); }
reverse_iterator       rend()         
{ return reverse_iterator(begin()); }
const_reverse_iterator rend()    const
{ return reverse_iterator(begin()); }
//capacity:
size_type size()     const { return count; }
size_type max_size() const { return count; }
bool      empty()    const { return count == 0; }
//element access:
reference       operator[](size_type n)       { return store[n]; }
const_reference operator[](size_type n) const { return store[n]; }
reference       front()       { return store[0]; }
const_reference front() const { return store[0]; }
reference       back()        { return store[count-1]; }
const_reference back()  const { return store[count-1]; }
const_reference at(size_type n) const { check(n); return store[n]; }
reference       at(size_type n)       { check(n); return store[n]; }
//data access:
T*       data()       { return store; }
const T* data() const { return store; }
};
} //namespace std

OriginalL'auteur TemplateRex

La réponse directe est que vous ne pouvez pas le faire: vous ne pouvez pas définir le vecteur const puis d'ajouter des membres.

Comme d'autres l'ont souligné, la nouvelle norme offre le tableau de la classe, qui est probablement plus adapté pour ce que vous faites.

Si vous êtes intéressé par une longueur fixe, les plus méthode associée au vecteur vous pouvez être intéressé par est reserve(), sur lequel sera fixé le vector<> à la taille du paramètre donné, la prise de vecteur expansions inutiles.

Si vous ne pouvez pas utiliser Std C++11, alors vous avez besoin de créer une classe wrapper qui ne vous permet pas de modifier le vecteur. Par exemple:

#include <vector>
#include <iostream>
#include <exception>
#include <stdexcept>
using namespace std;
template <typename T>
class FinalVector {
public:
FinalVector(unsigned int size)
{ v.reserve( size ); }
const T &at(unsigned int i) const
{ return v.at( i ); }
T &at(unsigned int i)
{ return v.at( i ); }
T &operator[](unsigned int i)
{ return at( i ); }
const T &operator[](unsigned int i) const
{ return at( i ); }
void push_back(const T &x);
size_t size() const
{ return v.size(); }
size_t capacity() const
{ return v.size(); }
private:
std::vector<T> v;
};
template<typename T>
void FinalVector<T>::push_back(const T &x)
{
if ( v.size() < v.capacity() ) {
v.push_back( x );
} else {
throw runtime_error( "vector size exceeded" );
}
}
int main()
{
FinalVector<int> v( 3 );
v.push_back( 1 );
v.push_back( 2 );
v.push_back( 3 );
for(size_t i = 0; i < v.size(); ++i) {
cout << v[ i ] << endl;
}
}

Espère que cette aide.

OriginalL'auteur Baltasarq