I vettori sono più rigorosi nel controllo dei limiti rispetto agli array di heap?

Question

Quanto è rigoroso il controllo dei limiti sui vettori rispetto agli array di heap? Quanto esattamente sta controllando i limiti e come si confronta con il modo in cui viene verificato un array di heap?

Answer 1

Un vector farà il controllo dei limiti, se si utilizza la funzione at(), ad esempio:

std::vector<int> v(5); 
v.at(3) = 10; 
v.at(5) = 20; // throws an exception, std::out_of_range 

Tuttavia, se si utilizza operator[], non ci sono limiti di controllo. (E l'accesso a elementi inesistenti porta ad un comportamento indefinito.)

_{Va notato, però, che la maggior parte delle implementazioni avranno la possibilità di includere limiti controllo su tutti gli iteratori, di cui si parla nelle risposte here. Per impostazione predefinita, VS2008 e versioni successive sono attivate in Debug e Release, VS2010 solo in Debug. gcc richiede di definire _GLIBCXX_DEBUG per ottenere gli iteratori verificati.}

Answer 2

Definita in fase di implementazione, vector contract non fornisce garanzie di verifica dei vincoli. Ma, una cosa è certa, sarà non peggiore di un array di heap.

Nella mia implementazione SGI:

• vector::operator[] non sia selezionata
• vector::at() è legato controllato

Dalla definizione file di intestazione di operator[]:

/** 
    * @brief Subscript access to the data contained in the %vector. 
    * @param n The index of the element for which data should be 
    * accessed. 
    * @return Read-only (constant) reference to data. 
    * 
    * This operator allows for easy, array-style, data access. 
    * Note that data access with this operator is unchecked and 
    * out_of_range lookups are not defined. (For checked lookups 
    * see at().) 
    */ 

E per vector::at():

Answer 3

In un'implementazione tipica, gli array non vengono controllati affatto, indipendentemente dall'assegnazione. std::vector richiede il controllo dei limiti su at(). L'accesso fuori limite con operator[] fornisce un comportamento indefinito, quindi è possibile eseguire anche il controllo dei limiti, ma è piuttosto insolito.

Ancora più importante, tuttavia, consiglierei in genere l'utilizzo di algoritmi che eliminano principalmente la preoccupazione in primo luogo. Quando fai qualcosa come: for (i=0; i<N; i++), è abbastanza facile per N essere la cosa sbagliata. Quando usi algorithm(x.begin(), x.end(), ...); è molto più facile ottenere un ragionevole grado di certezza che la tua logica sia corretta.