Como encontrar o tamanho da array em C++

Para encontrar o comprimento de um array em C++, conte seus elementos. A técnica adequada depende do tipo: use sizeof para um array nativo no escopo em que ele foi declarado, size() para std::array ou std::vector, ou std::size para uma chamada genérica da biblioteca padrão. Um loop for baseado em intervalo também pode contar os elementos de um intervalo que já pode ser percorrido.

Conte os elementos de um array com um loop for baseado em intervalo em C++

Um loop for baseado em intervalo percorre cada elemento de um array ou de outro intervalo iterável. Incremente um contador a cada passagem para contar os elementos:

#include <iostream>

int main() {
    int values[] = {10, 20, 30, 40, 50};
    int count = 0;

    for (int value : values) {
        (void)value;
        ++count;
    }

    std::cout << "Element count: " << count << '\n';
}

Esse método conta os elementos do intervalo fornecido por values. Ele não descobre o tamanho da alocação de um ponteiro bruto nem de uma área de armazenamento alocada dinamicamente. Nesses casos, mantenha a contagem de elementos separadamente ou use um contêiner que informe seu tamanho.

Use sizeof para encontrar o comprimento de um array nativo

Quando um array nativo ainda é um array no escopo atual, divida o tamanho total em bytes pelo tamanho, em bytes, de um elemento:

#include <iostream>
#include <cstddef>

int main() {
    int values[] = {1, 2, 3, 4, 5};
    const std::size_t count = sizeof(values) / sizeof(values[0]);

    std::cout << "Element count: " << count << '\n';
}

sizeof(values) fornece o número de bytes ocupados pelo array inteiro, enquanto sizeof(values[0]) fornece os bytes ocupados por um elemento. O quociente é a quantidade de elementos. O exemplo inclui <cstddef> para usar std::size_t.

Esse cálculo deixa de fornecer a quantidade de elementos quando um array é passado para uma função. Um parâmetro declarado como int values[] é ajustado para int* values; dentro da função, sizeof(values) mede o ponteiro, não o array original. O quociente resultante depende dos tamanhos do ponteiro e do elemento naquela implementação, portanto não é uma contagem portável. Passe a quantidade separadamente ou aceite um contêiner.

Use size() com std::array e std::vector

Tanto std::array quanto std::vector oferecem uma função membro size() que retorna a quantidade de elementos. std::array representa um array de tamanho fixo, enquanto um vetor pode mudar de tamanho quando elementos são adicionados ou removidos.

#include <array>
#include <iostream>
#include <vector>

int main() {
    std::array<int, 3> fixed{4, 8, 12};
    std::vector<int> resizable{5, 10, 15, 20};

    std::cout << "std::array: " << fixed.size() << '\n';
    std::cout << "std::vector: " << resizable.size() << '\n';
}

Use a função membro do contêiner que você tem. std::array::size() informa sua quantidade fixa de elementos; std::vector::size() informa a quantidade atual de elementos no vetor.

Use std::end() e std::begin() para encontrar o comprimento de um array

Para um array nativo, std::begin aponta para o primeiro elemento e std::end aponta para a posição logo após o último. Subtrair os dois ponteiros fornece a quantidade de elementos entre eles. Inclua <iterator> para usar essas funções.

#include <iostream>
#include <iterator>

int main() {
    int values[] = {2, 4, 6, 8};
    const auto count = std::end(values) - std::begin(values);

    std::cout << "Element count: " << count << '\n';
}

A subtração é válida porque os dois ponteiros se referem ao mesmo array, ou à posição logo após seu último elemento. Essa abordagem é útil para arrays nativos; para std::array ou std::vector, geralmente é mais claro usar a função membro size().

Use std::size() para obter a quantidade de elementos

std::size é uma função da biblioteca padrão que retorna a quantidade de elementos. Ela funciona com arrays nativos e contêineres padrão, como std::array e std::vector. Inclua <iterator> para usá-la.

#include <array>
#include <iostream>
#include <iterator>
#include <vector>

int main() {
    int built_in[] = {3, 6, 9};
    std::array<int, 2> fixed{7, 14};
    std::vector<int> resizable{11, 22, 33, 44};

    std::cout << "Built-in array: " << std::size(built_in) << '\n';
    std::cout << "std::array: " << std::size(fixed) << '\n';
    std::cout << "std::vector: " << std::size(resizable) << '\n';
}

Diferentemente da função membro size(), std::size(container) é uma chamada de função livre. Ela oferece uma forma única de escrever a chamada para os tipos de arrays e contêineres compatíveis, enquanto a função membro size() de cada contêiner continua disponível.

Escolha o método adequado ao tipo do seu array

• Para um array nativo no mesmo escopo em que foi declarado, use sizeof(array) / sizeof(array[0]) ou std::size(array).
• Para std::array e std::vector, prefira a função membro size(). Use std::size(container) se for útil ter uma chamada de função comum.
• Use std::end(array) - std::begin(array) quando a subtração de iteradores combinar com o restante do código.
• Use um loop for baseado em intervalo quando quiser contar os elementos percorrendo um intervalo iterável.
• Para um ponteiro ou array alocado dinamicamente, mantenha a quantidade de elementos separadamente ou use um contêiner. O ponteiro, por si só, não informa quantos elementos foram alocados.

A distinção principal é entre o tamanho do armazenamento em bytes e a quantidade de elementos. sizeof mede bytes; divida pelo tamanho em bytes de um elemento somente enquanto a expressão ainda se referir ao array nativo completo. As funções de tamanho dos contêineres e a subtração de iteradores fornecem diretamente a quantidade de elementos.