Come si cancella un elemento da std :: vector <> per indice?

Question

Ho uno std :: vector < int> e desidero eliminare l'elemento n'th. Come lo faccio?

std::vector<int> vec; 

vec.push_back(6); 
vec.push_back(-17); 
vec.push_back(12); 

vec.erase(???); 

Answer 1

Per cancellare un singolo elemento, si potrebbe fare:

std::vector<int> vec; 

vec.push_back(6); 
vec.push_back(-17); 
vec.push_back(12); 

// Deletes the second element (vec[1]) 
vec.erase(vec.begin() + 1); 

Oppure, per eliminare più di un elemento alla volta:

// Deletes the second through third elements (vec[1], vec[2]) 
vec.erase(vec.begin() + 1, vec.begin() + 3); 

Answer 2

Il metodo di cancellazione su std :: vector è sovraccarico, quindi è probabilmente più chiaro chiamare

vec.erase(vec.begin() + index); 

quando si desidera cancellare un singolo elemento.

Answer 3

template <typename T> 
void remove(std::vector<T>& vec, size_t pos) 
{ 
    std::vector<T>::iterator it = vec.begin(); 
    std::advance(it, pos); 
    vec.erase(it); 
} 

Answer 4

Procedimento erase verrà utilizzato in due modi:

1. Cancellazione singolo elemento:

   vector.erase(vector.begin() + 3); // Deleting the third element 
   

2. gamma Cancellazione di elementi:

   vector.erase(vector.begin() + 3, vector.begin() + 5); // Deleting from third element to fifth element 
   

Answer 5

Se si lavora con i grandi vettori (dimensioni> 100.000) e da eliminare un sacco di elementi, mi sento di raccomandare a fare qualcosa di simile:

int main(int argc, char** argv) { 

    vector <int> vec; 
    vector <int> vec2; 

    for (int i = 0; i < 20000000; i++){ 
     vec.push_back(i);} 

    for (int i = 0; i < vec.size(); i++) 
    { 
     if(vec.at(i) %3 != 0) 
      vec2.push_back(i); 
    } 

    vec = vec2; 
    cout << vec.size() << endl; 
} 

Il codice prende ogni numero in vec che non può essere diviso per 3 e lo copia in vec2. Successivamente copia vec2 in vec. È piuttosto veloce Per elaborare 20.000.000 di elementi questo algoritmo impiega solo 0,8 sec!

Ho fatto la stessa cosa con la cancellazione metodo, e ci vuole un sacco di tempo:

Erase-Version (10k elements) : 0.04 sec 
Erase-Version (100k elements) : 0.6 sec 
Erase-Version (1000k elements): 56 sec 
Erase-Version (10000k elements): ...still calculating (>30 min) 

Answer 6

In realtà, la funzione erase lavora per due profili:

• Rimozione di un elemento singolo

  iterator erase (iterator position); 
  

• Rimozione di un intervallo di elementi

  iterator erase (iterator first, iterator last); 
  

Dal std :: vec.begin() segna l'inizio di contenitore e, se vogliamo eliminare l'elemento i-esimo nel nostro vettore, possiamo usare:

vec.erase(vec.begin() + index); 

Se guarda da vicino, vec.begin() è solo un puntatore alla posizione di partenza del nostro vettore e aggiungendo il valore di i ad esso incrementa il puntatore I POSIZIONE, così invece si può accedere al puntatore all'elemento i-esimo da:

&vec[i] 

Così possiamo scrivere:

vec.erase(&vec[i]); // To delete the ith element 

Answer 7

per eliminare un elemento di utilizzare il seguente modo:

 1 // declaring and assigning array1 
    2 std:vector<int> array1 {0,2,3,4}; 
    3 
    4 // erasing the value in the array 
    5 array1.erase(array1.begin()+n); 

per più ampia panoramica si possono visitare: - http://www.cplusplus.com/reference/vector/vector/erase/

Answer 8

Le risposte precedenti presumono che tu sempre abbia un indice firmato. Purtroppo, std::vector utilizza size_type per l'indicizzazione e difference_type per l'aritmetica di iteratore, quindi non funzionano insieme se si dispone di "-Wversion" e di amici abilitati. Questo è un altro modo per rispondere alla domanda, pur essendo in grado di gestire entrambi firmati e non firmati:

Per rimuovere:

template<class T, class I, class = typename std::enable_if<std::is_integral<I>::value>::type> 
void remove(std::vector<T> &v, I index) 
{ 
    const auto &iter = v.cbegin() + gsl::narrow_cast<typename std::vector<T>::difference_type>(index); 
    v.erase(iter); 
} 

Per fare:

template<class T, class I, class = typename std::enable_if<std::is_integral<I>::value>::type> 
T take(std::vector<T> &v, I index) 
{ 
    const auto &iter = v.cbegin() + gsl::narrow_cast<typename std::vector<T>::difference_type>(index); 

    auto val = *iter; 
    v.erase(iter); 

    return val; 
} 

Answer 9

Se si dispone di un vettore non ordinata si può trarre vantaggio dal fatto che non è ordinato e utilizzare qualcosa che ho visto da Dan Higgins a CPPCON

template< typename TContainer > 
static bool EraseFromUnorderedByIndex(TContainer& inContainer, size_t inIndex) 
{ 
    if (inIndex < inContainer.size()) 
    { 
     if (inIndex != inContainer.size() - 1) 
      inContainer[inIndex] = inContainer.back(); 
     inContainer.pop_back(); 
     return true; 
    } 
    return false; 
} 

Poiché l'ordine dell'elenco non ha importanza, basta prendere l'ultimo elemento nell'elenco e copiarlo sopra l'elemento superiore che si desidera rimuovere, quindi compila ed elimina l'ultimo elemento.