HOWTO · C++

Comparar Arrays em C++

Este artigo introduz a forma de comparar arrays em C++

Nesta página

Escolha o método de comparação conforme as entradas e o resultado de que precisa. Para arrays de tamanho fixo e igual, um loop ou std::equal pode retornar um valor booleano. Para sequências de bytes, std::memcmp compara as representações dos objetos. Para vetores, o operator== de std::vector compara os tamanhos e os valores. Se precisar da primeira posição em que há diferença, use std::mismatch depois de verificar os comprimentos dos intervalos.

Os exemplos a seguir são programas completos em C++, destinados a ser compilados individualmente. Os resultados de execução fornecidos indicam que os seis exemplos foram executados com sucesso. Parâmetros de array brutos decaem para ponteiros: uma função que os recebe não consegue determinar seus comprimentos. Passe os comprimentos explicitamente e garanta que cada ponteiro se refira a um intervalo com pelo menos esse tamanho.

Comparar arrays de tamanho fixo com um loop

Um loop torna explícita a regra de comparação: examina os elementos correspondentes e retorna false assim que um par for diferente. Se todos os pares forem iguais, retorna true. Como quem chama a função fornece os dois comprimentos, verifique-os antes de indexar os arrays; este exemplo trata comprimentos diferentes sem ler nenhum dos intervalos.

O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.

#include <cstddef>
#include <iostream>

bool equalArrays(const int* left, std::size_t leftSize,
                 const int* right, std::size_t rightSize) {
  if (leftSize != rightSize) return false;
  for (std::size_t i = 0; i < leftSize; ++i) {
    if (left[i] != right[i]) return false;
  }
  return true;
}

int main() {
  const int first[] = {2, 4, 6, 8};
  const int same[] = {2, 4, 6, 8};
  const int different[] = {2, 4, 6, 9};
  constexpr std::size_t count = sizeof(first) / sizeof(first[0]);

  std::cout << std::boolalpha
            << equalArrays(first, count, same, count) << '\n'
            << equalArrays(first, count, different, count) << '\n';
}
true
false

A primeira chamada compara todos os valores correspondentes e retorna true; a segunda para no último par e retorna false. Essa abordagem elemento a elemento funciona quando != tem o significado pretendido para o tipo dos elementos. Ela não compara automaticamente os tamanhos dos arrays, portanto passe os tamanhos reais em vez de presumir que dois ponteiros apontam para arrays de tamanhos iguais.

Escrever uma função de comparação reutilizável

Um template permite reutilizar o loop com tipos que aceitam a comparação de desigualdade. Assim como na versão para inteiros, a função recebe os comprimentos explicitamente e os verifica antes de ler os elementos. O exemplo é independente e pode ser compilado sozinho.

O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.

#include <cstddef>
#include <iostream>
#include <string>

template <typename T>
bool equalRanges(const T* left, std::size_t leftSize,
                 const T* right, std::size_t rightSize) {
  if (leftSize != rightSize) return false;
  for (std::size_t i = 0; i < leftSize; ++i) {
    if (left[i] != right[i]) return false;
  }
  return true;
}

int main() {
  const std::string namesA[] = {"Ada", "Lin"};
  const std::string namesB[] = {"Ada", "Lin"};
  std::cout << std::boolalpha
            << equalRanges(namesA, 2, namesB, 2) << '\n';
}
true

O parâmetro de template T é deduzido a partir dos elementos. A função exige que T aceite !=; ela não exige um contêiner específico. Mantenha cada ponteiro associado ao comprimento correspondente e garanta que o intervalo indicado continue válido e tenha tamanho suficiente para o comprimento fornecido. Para contêineres padrão, prefira os iteradores ou uma operação que conheça o contêiner quando isso tornar os limites mais claros.

Comparar intervalos com std::equal

std::equal, de <algorithm>, compara elementos correspondentes e retorna um valor booleano. A sobrecarga de três iteradores recebe o início e o fim do primeiro intervalo, além do início do segundo. Antes de chamá-la, compare os comprimentos: o segundo intervalo deve conter pelo menos tantos elementos quanto o primeiro. Verificar se os comprimentos são iguais permite comparar os intervalos completos e evita ler além do fim do segundo intervalo.

O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.

#include <algorithm>
#include <iostream>
#include <vector>

int main() {
  const std::vector<int> left{3, 1, 4};
  const std::vector<int> same{3, 1, 4};
  const std::vector<int> longer{3, 1, 4, 1};

  const bool firstEqual = left.size() == same.size() &&
      std::equal(left.begin(), left.end(), same.begin());
  const bool secondEqual = left.size() == longer.size() &&
      std::equal(left.begin(), left.end(), longer.begin());

  std::cout << std::boolalpha << firstEqual << '\n' << secondEqual << '\n';
}
true
false

As verificações de tamanho fazem parte da comparação; não são uma otimização opcional. std::equal compara os elementos na ordem: os elementos na mesma posição precisam ser iguais. Use esse algoritmo com intervalos de iteradores cujos tempos de vida e limites sejam válidos. A sobrecarga de quatro iteradores pode indicar diretamente os dois fins nas versões da linguagem que a oferecem, mas o padrão de verificação dos tamanhos acima dispensa essa sobrecarga.

Comparar bytes com std::memcmp

std::memcmp, de <cstring>, compara uma quantidade especificada de bytes. Retorna zero quando os bytes correspondem e um valor diferente de zero quando são diferentes; o sinal pode indicar a ordem byte a byte, mas não dependa de um valor diferente de zero específico. Forneça ponteiros válidos para pelo menos a quantidade de bytes solicitada e calcule essa quantidade em bytes, não em elementos.

O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.

#include <cstring>
#include <iostream>

int main() {
  const unsigned char left[] = {0x10, 0x20, 0x30};
  const unsigned char same[] = {0x10, 0x20, 0x30};
  const unsigned char different[] = {0x10, 0x20, 0x31};
  constexpr std::size_t byteCount = sizeof(left);

  std::cout << (std::memcmp(left, same, byteCount) == 0) << '\n'
            << (std::memcmp(left, different, byteCount) == 0) << '\n';
}
1
0

Este exemplo usa arrays de bytes, para os quais a comparação byte a byte responde diretamente se os bytes listados são iguais. Para objetos em geral, valores iguais não necessariamente têm representações idênticas: bytes de preenchimento ou várias representações para um mesmo valor podem tornar std::memcmp inadequado. Para valores comuns, prefira comparar os elementos; compare os bytes apenas quando a igualdade das representações for a regra pretendida pelo formato dos dados. Uma quantidade de bytes igual a zero não compara nenhum byte; ainda assim, quem chama a função precisa tratar os intervalos de forma válida para o programa.

Comparar vetores com std::vector::operator==

Para vetores, use == quando precisar verificar a igualdade dos valores do vetor inteiro. O operador verifica se os tamanhos coincidem e se os elementos correspondentes são iguais, dispensando uma verificação de tamanho separada. A ordem importa: vetores com os mesmos valores em ordens diferentes não são iguais.

O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.

#include <iostream>
#include <vector>

int main() {
  const std::vector<int> first{5, 8, 13};
  const std::vector<int> same{5, 8, 13};
  const std::vector<int> reordered{8, 5, 13};
  const std::vector<int> shorter{5, 8};

  std::cout << std::boolalpha
            << (first == same) << '\n'
            << (first == reordered) << '\n'
            << (first == shorter) << '\n';
}
true
false
false

Essa é a escolha mais direta quando as duas entradas são std::vector e basta obter uma resposta booleana. O tipo dos elementos contidos precisa aceitar comparação por igualdade. Se a ordem não importar para a sua tarefa, defina essa regra explicitamente e escolha uma abordagem adequada; a igualdade comum entre vetores compara deliberadamente as posições.

Encontrar a primeira diferença com std::mismatch

Use std::mismatch quando precisar encontrar o primeiro par diferente, em vez de obter apenas true ou false. Sua sobrecarga de três iteradores percorre o primeiro e o segundo intervalos; por isso, compare primeiro os comprimentos para garantir que ambos terminem juntos. O primeiro iterador retornado identifica o elemento diferente no primeiro intervalo; se for igual ao fim desse intervalo, todos os pares comparados eram iguais.

O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.

#include <algorithm>
#include <iostream>
#include <iterator>
#include <vector>

int main() {
  const std::vector<int> left{7, 8, 9, 10};
  const std::vector<int> right{7, 8, 0, 10};

  if (left.size() != right.size()) {
    std::cout << "Different lengths\n";
    return 0;
  }

  const auto result = std::mismatch(left.begin(), left.end(), right.begin());
  if (result.first == left.end()) {
    std::cout << "Equal\n";
  } else {
    const auto index = std::distance(left.begin(), result.first);
    std::cout << "First mismatch at zero-based index " << index << '\n';
  }
}
First mismatch at zero-based index 2

std::distance fornece aqui um deslocamento baseado em zero. Se apresentar uma posição para leitores baseada em um, indique isso e some um ao deslocamento. Comparar os comprimentos primeiro também torna significativa a condição de fim para verificar a igualdade dos intervalos completos e mantém o segundo iterador dentro dos limites do intervalo.

Escolher um método de comparação

Use um loop quando quiser controlar explicitamente a comparação elemento a elemento ou precisar de uma lógica personalizada. Use std::equal para comparar intervalos de iteradores e obter um valor booleano, depois de confirmar que os comprimentos são compatíveis com sua sobrecarga de três iteradores. Para std::vector, operator== oferece uma verificação concisa do contêiner inteiro. Escolha std::mismatch quando for importante localizar a primeira diferença.

Use std::memcmp apenas para sequências de bytes cuja representação é o dado que se pretende comparar; não é uma substituição geral para a igualdade de valores. Em toda abordagem baseada em ponteiros, associe os ponteiros aos comprimentos corretos. Quando possível, prefira os tamanhos dos contêineres e os intervalos de iteradores e, antes de usar um algoritmo que percorra o segundo intervalo, garanta que ele seja longo o suficiente.