plus - matrix size c++




Como faço para encontrar o comprimento de uma matriz? (16)

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.

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


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 função, 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. 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;
}

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

template<class T, size_t N>
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 compilação, de modo que não tenha nenhuma desvantagem sobre a macro (pelo menos nenhuma que eu saiba).

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

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


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 cabeçalho <type_traits> .

  • std::rank<T>::value

    Se T é 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<T, N>::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<T>::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<T>::type

    Se T é uma matriz de algum tipo X , fornece o tipo 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<T>::type

    Se T é uma matriz multidimensional 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, o decltype poderia ser usado para combinar com o std::extent . Por exemplo:

#include <iostream>
#include <type_traits> // std::remove_extent std::remove_all_extents std::rank std::extent

template<class T, size_t N>
constexpr size_t length(T(&)[N]) { return N; }

template<class T, size_t N>
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<decltype(a)>::value;     // 5
    constexpr auto l2 = std::extent<decltype(a), 1>::value;  // 4
    constexpr auto l3 = std::extent<decltype(a), 2>::value;  // 3
    constexpr auto l4 = std::extent<decltype(a), 3>::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<decltype(a)>::type pa;  // get at compile time
    //std::remove_reference<decltype(*a)>::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<decltype(a)>::type);

Ou coloque-o em um modelo de função:

#include <iostream>
#include <type_traits>template<class T>
constexpr size_t len(T &a)
{
    return sizeof(a) / sizeof(typename std::remove_all_extents<T>::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.


Em vez de usar a função de matriz incorporada aka:

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

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

#include <array>
array<type_of_the_array, number_of_elements_in_the_array> Name_of_Array = {};

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

Name_of_Array.size();

e isso deve retornar o comprimento dos elementos na matriz.


Embora esta seja uma questão antiga, vale a pena atualizar a resposta para o C ++ 17. Na biblioteca padrão, existe agora a função 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 <iterator>

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

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 equivalente se sizeof(array)/sizeof(*array) . Você pode simplesmente digitar _countof(array)


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


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 função 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

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

template <class T, size_t N>
char (&helper(T (&)[N]))[N];

#define arraysize(array) (sizeof(helper(array)))

int main() {
    int a[10];
    std::cout << arraysize(a) << std::endl;
    return 0;
}

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;

Isto não funciona em ponteiros, isto é , não funciona para nenhum dos seguintes:

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, você deve estar usando uma classe de contêiner; provavelmente std::vector .


Simplesmente você pode usar este trecho:

#include <iostream>
#include <string>
#include <array>

using namespace std;

int main()
{

  array<int,3> values;
  cout << "No. elements in valuea array: " << values.size() << " elements." << endl;
  cout << "sizeof(myints): " << sizeof(values) << endl;

}

e aqui está a referência: http://www.cplusplus.com/reference/array/array/size/


Uma das razões mais comuns que você acabaria procurando por isso é porque você quer passar um array para uma função, e não ter que passar outro argumento para seu tamanho. Você também geralmente gostaria que o tamanho da matriz fosse dinâmico. Esse array pode conter objetos, não primitivos, e os objetos 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, quer uma solução de linha única com objetos anônimos envolvidos.

Se você optar pela alternativa de contêiner STL a uma matriz primitiva, essa postagem SO poderá ser útil para você aprender como inicializá-la: 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 classe como contêiner para sua coleção de objetos. Defina uma função de sobrecarga do operador para <<.

class MyObject;

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

Você pode criar funções que levam sua estrutura como um parâmetro, por exemplo:

someFunc( MyObjectList &objects );

Então, você pode chamar essa função, assim:

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

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


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.


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

(Sim, esta é uma resposta irônica)


#include <iostream>

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






arrays