Posso usare '==' per confrontare due vettori. L'ho provato e sembra funzionare bene. Ma io non so se funzionerà in situazioni più complesse

Question

Primo esempio:

int main(){ 
    using namespace std; 
    vector<int> v1{10, 20, 30, 40, 50}; 
    vector<int> v2{10, 20, 30, 40, 50}; 

    if(v1==v2) 
     cout<<"equal"; 
    else 
     cout<<"unequal"; 
} // it returns equal 

Secondo esempio:

int main(){ 
    using namespace std; 
    vector<int> v1{10, 20, 30, 40, 50}; 
    vector<int> v2{10, 20, 100000, 40, 50}; 

    if(v1==v2) 
     cout<<"equal"; 
    else 
     cout<<"unequal"; 
} // it returns notequal 

Answer 1

Il overload of operator == that works on two std::vectors confronta le dimensioni del vettore e restituisce false se queste sono diverse; in caso contrario, confronterà il contenuto del vettore elemento per elemento.

Se operator == è definito per il tipo di elemento del vettore, il confronto dei vettori tramite operator == è valido e significativo.

Formalmente, lo standard C++ 11 specifica la semantica operazionale di a == b per contenitori di sequenza come (Tabella 96, § 23.2.1):

== un'equivalenza relazione.

distance(a.begin(), a.end()) == distance(b.begin(), b.end()) && equal(a.begin(), a.end(), b.begin())

Come si può vedere, l'uguaglianza tra i contenitori di sequenza è definita in termini di std::equal algoritmo tra intervalli definiti da coppie di iteratori, che a sua volta utilizza operator == per il confronto dei singoli elementi.

Answer 2

Sì, è possibile utilizzare operator== per confrontare due std::vector s. Restituirà true solo se i vettori hanno la stessa dimensione e tutti gli elementi sono uguali.

Answer 3

È possibile controllare la documentazione di operator== per il vettore: operator==,!=,<,<=,>,>=(std::vector)

Citando dal link:

template< class T, class Alloc > 
bool operator==(vector<T,Alloc>& lhs, 
      vector<T,Alloc>& rhs); 

Confronta il contenuto di due contenitori.

Verifica se il contenuto di lhs e rhs sono uguali, vale a dire lhs.size() == rhs.size() e ogni elemento in lhs ha un elemento equivalente in rhs nella stessa posizione.

parametri:

sx, contenitori sd cui contenuto per confrontare

T deve soddisfare i requisiti di EqualityComparable al fine di utilizzare le versioni

valore di ritorno

vero se il contenuto della i contenitori sono equivalenti, false altrimenti

Answer 4

Sì.Un buon riferimento è cppreference.com, dove è possibile cercare operator== per vector<T>, per esempio in questa pagina: non-member operators, e troverete:

Controlla se il contenuto di sx e dx sono uguali, cioè se lhs.size() == rhs.size() e ogni elemento in lhs ha l'equivalente elemento in rhs nella stessa posizione.

Answer 5

Fintanto che il vettore contiene elementi che possono essere confrontati da soli (avere operator==), questo funziona, sì. Si noti tuttavia che se si ha un vettore che contiene per esempio puntatori a oggetti identici, ma non l'istanza SAME di un oggetto, allora il vettore non è considerato identico, poiché l'elemento nel vettore è ciò che viene confrontato, non il contenuto del elemento in quanto tale, se ciò ha senso.

Answer 6

Si noti che i vettori non sono ordinati, quindi l'uso di std :: equal o l'operatore "==" non può essere utilizzato normalmente per assicurare un confronto corretto di se due vettori contengono gli stessi elementi ma in ordine diverso. Confronta che i vettori hanno gli stessi contenuti nello stesso ordine (ma non in ordine diverso).

Per molti casi d'uso questo potrebbe essere sufficiente. Ma potrebbero esserci occasioni in cui vuoi sapere se due vettori hanno gli stessi contenuti ma non necessariamente nello stesso ordine. In questo caso è necessaria un'altra funzione.

Una bella e breve implementazione è quella sotto. E 'stato suggerito qui: https://stackoverflow.com/questions/17394149/how-to-efficiently-compare-vectors-with-c/17394298#17394298 Vi si possono trovare anche una discussione sul perché non si potrebbe desiderare di usarlo ...

mettere questo in un file di intestazione della vostra scelta:

#include <algorithm> 

template <class T> 
static bool compareVectors(std::vector<T> a, std::vector<T> b) 
{ 
    if (a.size() != b.size()) 
    { 
     return false; 
    } 
    ::std::sort(a.begin(), a.end()); 
    ::std::sort(b.begin(), b.end()); 
    return (a == b); 
} 

E qui un esempio che illustra la teoria di cui sopra:

std::vector<int> vector1; 
std::vector<int> vector2; 

vector1.push_back(100); 
vector1.push_back(101); 
vector1.push_back(102); 

vector2.push_back(102); 
vector2.push_back(101); 
vector2.push_back(100); 

if (vector1 == vector2) 
    std::cout << "same" << std::endl; 
else 
    std::cout << "not same" << std::endl; 

if (std::equal(vector1.begin(), vector1.end(), vector2.begin())) 
    std::cout << "same" << std::endl; 
else 
    std::cout << "not same" << std::endl; 

if (compareVectors(vector1, vector2)) 
    std::cout << "same" << std::endl; 
else 
    std::cout << "not same" << std::endl; 

l'output sarà:

not same 
not same 
same