Como faço para encontrar o comprimento de uma matriz?

Existe uma maneira de descobrir quantos valores um array possui? Detectar se eu cheguei ao fim de um array também funcionaria.

Se você quer dizer uma matriz de estilo C, então você pode fazer algo como:

int a[7]; std::cout < < "Length of array = " << (sizeof(a)/sizeof(*a)) << std::endl; 

Isso não funciona em pointers, isto é , não funciona para nenhum dos seguintes itens:

 int *p = new int[7]; std::cout < < "Length of array = " << (sizeof(p)/sizeof(*p)) << std::endl; 

ou:

 void func(int *p) { std::cout < < "Length of array = " << (sizeof(p)/sizeof(*p)) << std::endl; } int a[7]; func(a); 

Em C ++, se você quiser esse tipo de comportamento, então você deve estar usando uma class de contêiner; provavelmente std::vector .

Como outro disse que você pode usar o sizeof(arr)/sizeof(*arr) mas isso vai lhe dar a resposta errada para os tipos de ponteiro que não são matrizes.

 template constexpr size_t size(T (&)[N]) { return N; } 

Isso tem a boa propriedade de não compilar para tipos não-array (visual studio tem _countof que faz isso). O constexpr faz com que esta seja uma expressão de tempo de compilation, de modo que não tenha nenhum inconveniente sobre a macro (pelo menos nenhuma que eu saiba).

Você também pode considerar o uso de std::array partir de C ++ 11, que expõe seu comprimento sem sobrecarga sobre um array C nativo.

C ++ 17 tem std::size() no header que faz o mesmo e funciona para contêineres STL também (graças a @Jon C ).

Fazendo sizeof( myArray ) você irá obter o número total de bytes alocados para essa matriz. Você pode então descobrir o número de elementos na matriz dividindo pelo tamanho de um elemento na matriz: sizeof( myArray[0] )

Existe uma maneira de descobrir quantos valores um array possui?

Sim!

Tente sizeof(array)/sizeof(array[0])

Detectar se eu cheguei ao fim de um array também funcionaria.

Eu não vejo nenhuma maneira para isso, a menos que sua matriz é uma matriz de caracteres (ou seja, string).

PS: Em C ++ sempre use std::vector . Existem várias funções embutidas e uma funcionalidade estendida.

Embora esta seja uma questão antiga, vale a pena atualizar a resposta para o C ++ 17. Na biblioteca padrão, existe agora a function template std::size() , que retorna o número de elementos em um contêiner std ou em um array no estilo C. Por exemplo:

 #include  uint32_t data[] = {10, 20, 30, 40}; auto dataSize = std::size(data); // dataSize == 4 

std::vector tem um size() método size() que retorna o número de elementos no vetor.

(Sim, esta é uma resposta irônica)

 #include  int main () { using namespace std; int arr[] = {2, 7, 1, 111}; auto array_length = end(arr) - begin(arr); cout < < "Length of array: " << array_length << endl; } 

Desde o C ++ 11, alguns novos modelos são introduzidos para ajudar a reduzir a dor ao lidar com o tamanho do array. Todos eles são definidos no header .

  • std::rank::value

    Se T for um tipo de matriz, fornece o valor da constante de membro igual ao número de dimensões da matriz. Para qualquer outro tipo, o valor é 0.

  • std::extent::value

    Se T é um tipo de matriz, fornece o valor da constante de membro igual ao número de elementos ao longo da N ésima dimensão da matriz, se N estiver em [0, std::rank::value ). Para qualquer outro tipo, ou se T é uma matriz de limite desconhecido ao longo de sua primeira dimensão e N é 0, o valor é 0.

  • std::remove_extent::type

    Se T é uma matriz de algum tipo X , fornece o tipo de typedef de membro igual a X , caso contrário, o tipo é T Observe que, se T for um array multidimensional, somente a primeira dimensão será removida.

  • std::remove_all_extents::type

    Se T é uma multidimensional array de algum tipo X , fornece o tipo typedef de membro igual a X , caso contrário, o tipo é T

Para obter o comprimento em qualquer dimensão de um array multidimensional, decltype poderia ser usado para combinar com std::extent . Por exemplo:

 #include  #include  // std::remove_extent std::remove_all_extents std::rank std::extent template constexpr size_t length(T(&)[N]) { return N; } template constexpr size_t length2(T(&arr)[N]) { return sizeof(arr) / sizeof(*arr); } int main() { int a[5][4][3]{{{1,2,3}, {4,5,6}}, { }, {{7,8,9}}}; // New way constexpr auto l1 = std::extent::value; // 5 constexpr auto l2 = std::extent::value; // 4 constexpr auto l3 = std::extent::value; // 3 constexpr auto l4 = std::extent::value; // 0 // Mixed way constexpr auto la = length(a); //constexpr auto lpa = length(*a); // compile error //auto lpa = length(*a); // get at runtime std::remove_extent::type pa; // get at compile time //std::remove_reference::type pa; // same as above constexpr auto lpa = length(pa); std::cout < < la << ' ' << lpa << '\n'; // Old way constexpr auto la2 = sizeof(a) / sizeof(*a); constexpr auto lpa2 = sizeof(*a) / sizeof(**a); std::cout << la2 << ' ' << lpa2 << '\n'; return 0; } 

BTY, para obter o número total de elementos em um array multidimensional:

 constexpr auto l = sizeof(a) / sizeof(std::remove_all_extents::type); 

Ou coloque-o em um modelo de function:

 #include  #include  template constexpr size_t len(T &a) { return sizeof(a) / sizeof(typename std::remove_all_extents::type); } int main() { int a[5][4][3]{{{1,2,3}, {4,5,6}}, { }, {{7,8,9}}}; constexpr auto ttt = len(a); int i; std::cout < < ttt << ' ' << len(i) << '\n'; return 0; } 

Mais exemplos de como usá-los podem ser encontrados seguindo os links.

Há também o caminho TR1 / C ++ 11 / C ++ 17 (veja Live on Coliru ):

 const std::string s[3] = { "1"s, "2"s, "3"s }; constexpr auto n = std::extent< decltype(s) >::value; // From  constexpr auto n2 = std::extent_v< decltype(s) >; // C++17 shorthand const auto a = std::array{ "1"s, "2"s, "3"s }; // C++17 class template arg deduction -- http://en.cppreference.com/w/cpp/language/class_template_argument_deduction constexpr auto size = std::tuple_size_v< decltype(a) >; std::cout < < n << " " << n2 << " " << size << "\n"; // Prints 3 3 3 

Em vez de usar a function built-in array aka:

  int x[2] = {0,1,2}; 

você deve usar a class de matriz e o modelo de matriz. Experimentar:

 #include  array Name_of_Array = {}; 

Então, agora, se você quiser encontrar o comprimento da matriz, tudo o que você precisa fazer é usar a function de tamanho na class da matriz.

 Name_of_Array.size(); 

e isso deve retornar o comprimento dos elementos na matriz.

Em C ++, usando a class std :: array para declarar uma matriz, pode-se facilmente encontrar o tamanho de uma matriz e também o último elemento.

 #include #include int main() { std::array arr; //To find the size of the array std::cout<  

Na verdade, a class array tem muitas outras funções que nos permitem usar um container padrão.
Referência 1 para C ++ std :: array class
Referência 2 para a class std :: array
Os exemplos nas referências são úteis.

Aqui está uma implementação do ArraySize do Google Protobuf .

 #define GOOGLE_ARRAYSIZE(a) \ ((sizeof(a) / sizeof(*(a))) / static_cast(!(sizeof(a) % sizeof(*(a))))) // test codes... char* ptr[] = { "you", "are", "here" }; int testarr[] = {1, 2, 3, 4}; cout < < GOOGLE_ARRAYSIZE(testarr) << endl; cout << GOOGLE_ARRAYSIZE(ptr) << endl; 

ARRAYSIZE (arr) funciona inspecionando sizeof (arr) (o número de bytes na matriz) e sizeof (* (arr)) (o número de bytes em um elemento da matriz). Se o primeiro é divisível pelo último, talvez arr seja de fato um array, caso em que o resultado da divisão é o número de elementos no array. Caso contrário, arr possivelmente não pode ser uma matriz e geramos um erro do compilador para evitar que o código seja compilado.

Como o tamanho do bool é definido pela implementação, precisamos converter! (Sizeof (a) & sizeof (* (a))) para size_t para garantir que o resultado final tenha o tamanho size_t.

Essa macro não é perfeita, pois aceita erroneamente certos pointers, ou seja, onde o tamanho do ponteiro é divisível pelo tamanho da ponta. Como todo o nosso código tem que passar por um compilador de 32 bits, em que um ponteiro é de 4 bytes, isso significa que todos os pointers para um tipo cujo tamanho seja 3 ou maior que 4 serão rejeitados (em retidão).

Para C ++ / CX (ao escrever, por exemplo, aplicativos UWP usando C ++ no Visual Studio), podemos encontrar o número de valores em uma matriz simplesmente usando a function size() .

Código fonte:

 string myArray[] = { "Example1", "Example2", "Example3", "Example4" }; int size_of_array=size(myArray); 

Se você cout o size_of_array a saída será:

 >>> 4 

Uma boa solução que usa genéricos:

 template  inline unsigned arraysize(const T (&v)[S]) { return S; } 

Então simplesmente chame arraysize(_Array); para obter o comprimento da matriz.

Fonte

  length = sizeof(array_name)/sizeof(int); 

Apenas um pensamento, mas apenas decidiu criar uma variável de contador e armazenar o tamanho da matriz na posição [0]. Eu apaguei a maior parte do código que eu tinha na function, mas você verá depois de sair do loop, prime [0] é atribuído o valor final de ‘a’. Eu tentei usar vetores, mas o VS Express 2013 não gostou muito disso. Anote também que ‘a’ começa em um para evitar sobrescrever [0] e é inicializado no começo para evitar erros. Eu não sou especialista, apenas pensei em compartilhar.

 int prime[] = {0}; int primes(int x, int y){ using namespace std; int a = 1; for (int i = x; i < = y; i++){prime[a] = i; a++; } prime[0] = a; return 0; } 

Uma das razões mais comuns que você acabaria procurando por isso é porque você quer passar um array para uma function, e não ter que passar outro argumento para seu tamanho. Você também geralmente gostaria que o tamanho da matriz fosse dynamic. Esse array pode conter objects, não primitivos, e os objects talvez complexos, de tal forma que size_of () é uma opção não segura para calcular a contagem.

Como outros sugeriram, considere o uso de um std :: vector ou list, etc em vez de um array primitivo. Em compiladores antigos, no entanto, você ainda não teria a solução final que você provavelmente deseja, simplesmente porque, ao preencher o contêiner, é necessário um monte de linhas push_back () feias. Se você é como eu, queira uma solução de linha única com objects anônimos envolvidos.

Se você optar pela alternativa do contêiner STL a uma matriz primitiva, essa postagem SO poderá ser útil para você iniciar: Qual é a maneira mais fácil de inicializar um std :: vector com elementos codificados?

Aqui está um método que estou usando para isso, que funcionará universalmente em compiladores e plataformas:

Crie uma estrutura ou class como contêiner para sua coleção de objects. Defina uma function de sobrecarga do operador para < <.

 class MyObject; struct MyObjectList { std::list objects; MyObjectList& operator< <( const MyObject o ) { objects.push_back( o ); return *this; } }; 

Você pode criar funções que tomam seu struct como um parâmetro, por exemplo:

 someFunc( MyObjectList &objects ); 

Então, você pode chamar essa function, assim:

 someFunc( MyObjectList() < < MyObject(1) << MyObject(2) << MyObject(3) ); 

Dessa forma, você pode construir e passar uma coleção de objects dinamicamente dimensionada para uma function em uma única linha limpa!

Evite usar o tipo junto com sizeof, pois sizeof(array)/sizeof(char) , de repente fica corrompido se você alterar o tipo da matriz.

No visual studio, você tem o equivivalente se sizeof(array)/sizeof(*array) . Você pode simplesmente digitar _countof(array)

Para o antigo compilador g ++, você pode fazer isso

 template  char (&helper(T (&)[N]))[N]; #define arraysize(array) (sizeof(helper(array))) int main() { int a[10]; std::cout < < arraysize(a) << std::endl; return 0; } 

Pessoalmente, eu sugeriria (se você é incapaz de trabalhar com funções especializadas por qualquer motivo) para primeiro expandir as matrizes de compatibilidade com o tipo que você normalmente usaria como (se você estivesse armazenando valores ≥ 0:

 unsigned int x[] -> int x[] 

do que você faria a matriz 1 elemento maior do que você precisa para fazer isso. Para o último elemento você colocaria algum tipo que é incluído no especificador de tipo expandido, mas que você normalmente não usaria, por exemplo, usando o exemplo anterior, o último elemento seria -1. Isso permite que você (usando um loop for) encontre o último elemento de uma matriz.

Eu forneço uma solução complicada aqui:

Você sempre pode armazenar o length no primeiro elemento:

 // malloc/new arr[0] = length; arr++; // do anything. int len = *(arr-1); free(--arr); 

O custo é que você deve --arr quando invocar free

Vamos dizer que você tem uma matriz global declarada no topo da página

 int global[] = { 1, 2, 3, 4 }; 

Para descobrir quantos elementos existem (em c ++) na matriz, digite o seguinte código:

 sizeof(global) / 4; 

O tamanho de (NAME_OF_ARRAY) / 4 retornará o número de elementos para o nome da matriz.