Могу ли я использовать '==' для сравнения двух векторов. Я попробовал и, кажется, отлично работает. Но я не знаю, будет ли он работать в более сложных ситуациях

Question

Первый пример:

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 

Второй пример:

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

overload of operator == that works on two std::vectors сравнивает размеры векторного изображения и возвращает false, если они отличаются; если нет, то он будет сравнивать содержимое векторного элемента за элементом.

Если для типа элемента вектора определено operator ==, то сравнение векторов через operator == является действительным и значимым.

Формально, стандарт C++ 11 указывает операционной семантики a == b для контейнеров последовательности, как (табл 96, § 23.2.1):

== эквивалентность отношение.

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

Как можно видеть, равенство между контейнерами последовательности определяется в терминах std::equal алгоритма между диапазонами, определенных парами итераторов, которые, в свою очередь, используют operator == для сравнения отдельных элементов.

Answer 2

Да, вы можете использовать operator== для сравнения двух std::vector с. Он вернет true только в том случае, если векторы имеют одинаковый размер, а все элементы сравниваются одинаково.

Answer 3

Вы можете проверить документацию operator== для вектора: operator==,!=,<,<=,>,>=(std::vector)

Цитируя ссылка:

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

Сравнивает содержимое двух контейнеров.

Проверяет, соответствуют ли значения lhs и rhs, то есть lhs.size() == rhs.size(), и каждый элемент в lhs имеет эквивалентный элемент в rhs в том же положении.

параметры:

л.ш., RHS контейнеры, содержимое для сравнения

T должны соответствовать требованиям EqualityComparable для того, чтобы использовать версии

Возвращаемое значение

правда если содержаниями контейнеры эквивалентны, ложно в противном случае

Answer 4

Да.Хорошая ссылка cppreference.com, где вы можете посмотреть operator== для vector<T>, например, на этой странице: non-member operators, и вы найдете:

Проверяет содержимое левой и правой частях равны, то есть ли lhs.size() == rhs.size(), и каждый элемент в lhs имеет эквивалентный элемент в rhs в том же положении.

Answer 5

Пока ваш вектор содержит элементы, которые сами по себе можно сравнить (есть operator==), это работает, да. Обратите внимание, что если у вас есть вектор, который содержит, например, указатели на идентичные объекты, но не тот же самый объект объекта, то вектор не считается идентичным, потому что элемент в векторе является тем, что сравнивается, а не с содержимым как таковой, если это имеет смысл.

Answer 6

Следует иметь в виду, что векторы не упорядочены, поэтому использование std :: equal или оператора «==» обычно не может использоваться для обеспечения правильного сравнения того, если два вектора содержат одни и те же элементы, но в другом порядке. Они сравнивают, что векторы имеют одинаковое содержимое в том же порядке (но не в разном порядке).

Для многих случаев использования этого может быть достаточно. Но могут быть случаи, когда вы хотите знать, имеют ли два вектора одинаковое содержимое, но не обязательно в том же порядке. Для этого вам нужна другая функция.

Одна красивая и краткая реализация - это следующая. Было предложено здесь: https://stackoverflow.com/questions/17394149/how-to-efficiently-compare-vectors-with-c/17394298#17394298 Там вы также найдете обсуждение о том, почему вы не можете использовать его ...

Поместите это в заголовочном файле по вашему выбору:

#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); 
} 

И здесь пример, иллюстрирующий описанную выше теорию:

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; 

выходной сигнал будет:

not same 
not same 
same