Non in grado di sovraccaricare le funzioni std :: vector esistenti

Question

Sto facendo un'implementazione POC e come requisito ho bisogno di estendere std :: vector insert API che prenderebbe solo un singolo parametro (valore da inserire) e internamente il codice sarebbe aggiungere questo alla fine del contenitore.

Ho creato una classe personalizzata (ValVector) derivata da std :: vector e definita un'API di inserimento personalizzata che accetta un singolo parametro ma durante la sua compilazione l'errore genera.

Apprezzo per la risposta rapida.

Di seguito si riporta il frammento di codice con il messaggio di errore: Messaggio

#include <iostream> 
#include <vector> 

using namespace std; 

typedef bool BOOL; 

template<class T, class Allocator = allocator<T>> 

class ValVector : public std::vector<T, Allocator> { 

    public: 
    BOOL insert(const T& elem) { return (this->insert(this->end(),elem)!=this->end()); } 
}; 

int main() 
{ 
    std::vector<int> myvector (3,100); 
    std::vector<int>::iterator it; 

    myvector.push_back (200); 

    ValVector<int> mKeyAr; 

    mKeyAr.insert(10); // 

std::cout << "myvector contains:"; 
    for (auto it=mKeyAr.begin(); it<mKeyAr.end(); it++) 
    std::cout << ' ' << *it; 
    std::cout << '\n'; 

    return 0; 
} 

Errore:

In instantiation of 'BOOL ValVector<T, Allocator>::insert(const T&) [with T = int; Allocator = std::allocator<int>; BOOL = bool]': 
23:19: required from here 
11:72: error: no matching function for call to 'ValVector<int>::insert(std::vector<int>::iterator, const int&)' 
11:72: note: candidate is: 
11:10: note: BOOL ValVector<T, Allocator>::insert(const T&) [with T = int; Allocator = std::allocator<int>; BOOL = bool] 
11:10: note: candidate expects 1 argument, 2 provided In member function 'BOOL ValVector<T, Allocator>::insert(const T&) [with T = int; Allocator = std::allocator<int>; BOOL = bool]': 
11:88: warning: control reaches end of non-void function [-Wreturn-type] 

Answer 1

Quando si effettua la propria funzione di elemento di inserto per qualcosa che non è virtuale si nasconde lo stesso nome funzioni da più in alto (penso che si chiami shadowing). Stai ora cercando di chiamare una funzione che non è più visibile.

C'è una buona ragione per non fare semplicemente una funzione separata che fa quello che ti serve, o devi ricavarlo dal vettore? Nulla si sta facendo richiede l'accesso ai dati o funzioni protette ...

// from 
vector.insert(data); 
// to 
insert_poc(vector, data); 

Answer 2

Per rispondere alla sua domanda attuale: dichiarare una funzione in una classe nasconde tutte le funzioni ereditate con lo stesso nome in quella classe. In altre parole, poiché ValVector ha una funzione denominata insert, l'ereditato std::vector::insert non è più visibile in esso. Probabilmente il modo migliore per risolvere questo è quello di portare il ereditato insert di nuovo a portata di una dichiarazione using:

template<class T, class Allocator = allocator<T>> 
class ValVector : public std::vector<T, Allocator> { 

    public: 
    using std::vector<T, Allocator>::insert; 

    BOOL insert(const T& elem) { return (this->insert(this->end(),elem)!=this->end()); } 
}; 

---

Tuttavia, ho un commento da fare. Penso che il tuo approccio sia sbagliato. I contenitori std non sono destinati all'eredità pubblica; se non altro, non hanno un distruttore virtuale e nessun membro protetto. Si sarebbe meglio fornire una funzione libera, che potrebbe poi essere utilizzato con qualsiasi std::vector, non solo il tipo:

template <class T, class A> 
BOOL insert(std::vector<T, A> &vec, const T &val) 
{ 
    return vec.insert(vec.end(), val) != vec.end(); 
} 

o renderlo un po 'più generico per lavorare con qualsiasi contenitore:

temlate <class C, class E> 
BOOL insert(C &cont, const E &val) 
{ 
    return cont.insert(cont.end(), val) != cont.end(); 
} 

Answer 3

Basta cambiare l'implementazione inserto come segue per farlo funzionare

BOOL insert(const T& elem) { return (std::vector<T>::insert(this->end(),elem)!=this->end()); } 

Acclamazioni