[C++] Comment trouver la taille d'un int []?



Answers

La manière "standard" C de le faire est

sizeof(list) / sizeof(list[0])
Question

j'ai

int list[] = {1, 2, 3};

Comment puis-je obtenir la taille de la list ?

Je sais que pour un tableau char, nous pouvons utiliser strlen(array) pour trouver la taille, ou vérifier avec '\0' à la fin du tableau.

J'ai essayé sizeof(array) / sizeof(array[0]) comme certaines réponses l'ont dit, mais cela ne fonctionne que dans main? Par exemple:

int size(int arr1[]){
    return sizeof(arr1) / sizeof(arr1[0]);
}

int main() {
    int list[] = {1, 2, 3};

    int size1 = sizeof(list) / sizeof(list[0]); // ok
    int size2 = size(list_1); // no
    // size1 and size2 are not the same
}

Pourquoi?




Cette méthode fonctionne lorsque vous utilisez une classe: Dans cet exemple, vous recevrez un tableau, donc la seule méthode qui a fonctionné pour moi était celle-ci:

template <typename T, size_t n, size_t m>   
Matrix& operator= (T (&a)[n][m])
{   

    int arows = n;
    int acols = m;

    p = new double*[arows];

    for (register int r = 0; r < arows; r++)
    {
        p[r] = new double[acols];


        for (register int c = 0; c < acols; c++)
        {
            p[r][c] = a[r][c]; //A[rows][columns]
        }

}

https://www.geeksforgeeks.org/how-to-print-size-of-an-array-in-a-function-in-c/




Vous ne pouvez pas faire cela pour un tableau alloué dynamiquement (ou un pointeur). Pour les tableaux statiques, vous pouvez utiliser sizeof(array) pour obtenir la taille totale du tableau en octets et la diviser par la taille de chaque élément:

#define COUNTOF(x) (sizeof(x)/sizeof(*x))

Pour obtenir la taille d'un tableau dynamique, vous devez le garder manuellement et le passer avec lui, ou le terminer avec une valeur sentinelle (comme '\ 0' dans les chaînes terminées nulles).

Mise à jour: je me suis rendu compte que votre question est étiquetée C ++ et non C. Vous devriez certainement envisager d'utiliser std::vector au lieu de tableaux en C ++ si vous voulez passer des choses:

std::vector<int> v;
v.push_back(1);
v.push_back(2);
std::cout << v.size() << std::endl; // prints 2



Vous devez utiliser la fonction sizeof ().

Extrait de code:

#include<bits/stdc++.h>
using namespace std;

int main()
{
      ios::sync_with_stdio(false);

      int arr[] ={5, 3, 6, 7};

      int size = sizeof(arr) / sizeof(arr[0]);
      cout<<size<<endl;

      return 0;
}



Puisque vous avez marqué ceci comme C ++, il vaut la peine de mentionner qu'il y a un peu mieux que la macro de style C:

template <class T, size_t N>
size_t countof(const T &array[N]) { return N; }

Cela a l'avantage que si vous essayez accidentellement de lui passer autre chose qu'un tableau, le code ne compilera tout simplement pas (alors que passer un pointeur vers la macro C compilera mais produira un mauvais résultat. t vous donner une constante de compilation, donc vous ne pouvez pas faire quelque chose comme ça:

int a[20];

char x[countof(a)];

En C ++ 11 ou plus récent, vous pouvez ajouter constexpr pour obtenir une constante de compilation:

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

Si vous voulez vraiment soutenir la même chose sur les compilateurs plus anciens, il y a un moyen, inventé à l'origine par Ivan Johnson, AFAIK:

#define COUNTOF(x)  (                                           \
  0 * sizeof( reinterpret_cast<const ::Bad_arg_to_COUNTOF*>(x) ) +  \
  0 * sizeof( ::Bad_arg_to_COUNTOF::check_type((x), &(x))      ) +  \
  sizeof(x) / sizeof((x)[0])  )                                  


class Bad_arg_to_COUNTOF
{
public:
   class Is_pointer;
   class Is_array {};  
   template<typename T>
   static Is_pointer check_type(const T*, const T* const*);
   static Is_array check_type(const void*, const void*);
};

Cela utilise sizeof (x) / sizeof (x [0]) pour calculer la taille, tout comme la macro C, donc il donne une constante à la compilation. La différence est qu'il utilise d'abord une magie de template pour provoquer une erreur de compilation si ce que vous avez passé n'est pas le nom d'un tableau. Il le fait en surchargeant check_type pour retourner un type incomplet pour un pointeur, mais un type complet pour un tableau. Alors (la partie vraiment délicate) il n'appelle pas du tout cette fonction - il prend juste la taille du type que la fonction retournerait, qui est zéro pour la surcharge qui retourne le type complet, mais pas autorisé (forçant un erreur de compilation) pour le type incomplet.

OMI, c'est un exemple assez sympa de programmation de méta de modèle - bien qu'en toute honnêteté, le résultat soit inutile. Vous n'avez vraiment besoin de cette taille que comme constante de temps de compilation si vous utilisez des tableaux, ce que vous devriez normalement éviter dans tous les cas. En utilisant std::vector , il est bon de fournir la taille à l'exécution (et de redimensionner le vecteur quand / si nécessaire).




Links