web-dev-qa-db-fra.com

Comment trouver la taille d'un int []?

J'ai

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

Comment obtenir la taille de list?

Je sais que pour un tableau de caractères, 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?

c++arrays
38
adam

Essaye ça:

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

Étant donné que cette question est balisée C++, il est toujours recommandé d'utiliser std::vector en C++ plutôt que d'utiliser des tableaux classiques de style C.

Un array-type est implicitement converti en un pointer-type lorsque vous le transmettez à une fonction . Regardez this.

Afin d'imprimer correctement la taille d'un tableau dans une fonction, transmettez le tableau en le référant à cette fonction (mais vous devez connaître la taille de ce tableau à l'avance).

Vous le feriez comme ça pour le cas général

template<typename T,int N> 
//template argument deduction
int size(T (&arr1)[N]) //Passing the array by reference 
{
   return sizeof(arr1)/sizeof(arr1[0]); //Correctly returns the size of 'list'
   // or
   return N; //Correctly returns the size too [cool trick ;-)]
}
49
Prasoon Saurav

La manière "standard" de faire ceci est

sizeof(list) / sizeof(list[0])
12
Carl Smotricz

Vous pouvez utiliser boost::size , qui est défini comme suit:

template <typename T, std::size_t N>
std::size_t size(T const (&)[N])
{
    return N;
}

Notez que si vous souhaitez utiliser la taille en tant qu'expression constante, vous devez utiliser l'idiome sizeof a / sizeof a[0] ou attendre la prochaine version de la norme C++.

9
avakar

Vous ne pouvez pas le faire 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 le 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 en assurer le suivi manuellement et le transmettre ou le terminer par une valeur sentinelle (comme '\ 0' dans les chaînes terminées par un caractère nul).

Mise à jour: Je me suis rendu compte que votre question portait les balises C++ et non C. Vous devez absolument envisager d'utiliser std::vector au lieu de tableaux en C++ si vous souhaitez transmettre des éléments:

std::vector<int> v;
v.Push_back(1);
v.Push_back(2);
std::cout << v.size() << std::endl; // prints 2
8
Mehrdad Afshari

Puisque vous avez marqué cela en C++, il est intéressant de noter qu'il existe un meilleur moyen 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 sera tout simplement pas compilé (alors que passer un pointeur sur la macro C compilera mais produira un mauvais résultat. ne vous donne pas une constante de compilation, vous ne pouvez donc pas faire quelque chose comme ceci:

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 supporter la même chose sur les anciens compilateurs, 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*);
};

Ceci utilise sizeof (x)/sizeof (x [0]) pour calculer la taille, comme le fait la macro C, ce qui donne une constante au moment de la compilation. La différence est qu’il utilise d’abord un modèle magique pour provoquer une erreur de compilation si ce que vous avez transmis n’est pas le nom d’un tableau. Cela se fait en surchargeant check_type pour renvoyer un type incomplet pour un pointeur, mais un type complet pour un tableau. Ensuite (la partie la plus délicate), la fonction n’appelle pas du tout. Elle prend simplement la taille du type que la fonction renverrait, ce qui correspond à zéro pour la surcharge renvoyant le type complet, mais elle n’est pas autorisée (forcer erreur de compilation) pour le type incomplet.

IMO, c’est un bon exemple de méta-programmation de modèles - même si, honnêtement, le résultat est un peu inutile. Si vous utilisez des tableaux, vous n’avez réellement besoin que de cette taille en tant que constante de temps de compilation, ce que vous devriez normalement éviter dans tous les cas. Avec std::vector, il est bon de fournir la taille au moment de l'exécution (et de redimensionner le vecteur si/si nécessaire).

4
Jerry Coffin

Outre la réponse de Carl, la méthode C++ "standard" ne consiste pas à utiliser un tableau C int, mais quelque chose comme un C++ STL std::vector<int> list que vous pouvez interroger pour list.size().

4
Dirk Eddelbuettel

quand vous passez un tableau à une fonction. vous ne faites que passer son adresse de départ, donc pour que cela fonctionne, vous devez lui transmettre la taille aussi pour que cela fonctionne correctement c'est la même raison pour laquelle nous passons argc avec argv [] dans les arguments en ligne de commande.

1
coming out of void

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

Cette méthode fonctionne lorsque vous utilisez une classe: Dans cet exemple, vous recevrez un tableau. 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/

0
Horacimar Pinheiro Cotrim
int arr1[] = {8, 15, 3, 7};
int n = sizeof(arr1)/sizeof(arr1[0]);

Donc, fondamentalement, sizeof (arr1) donne la taille de l’objet pointé, chaque élément occupant plusieurs bits, la division par le nombre de bits par élément (sizeof (arr1 [0]) vous donne le nombre réel d’éléments que vous à la recherche de 4 dans mon exemple.

0
Aditya Mittal

Vous pouvez créer une fonction de modèle et transmettre le tableau par référence pour y parvenir.

Voici mon extrait de code

template <typename TypeOfData>


void PrintArray(TypeOfData &arrayOfType);

int main()

{

    char charArray[] = "my name is";

    int intArray[] = { 1,2,3,4,5,6 };

    double doubleArray[] = { 1.1,2.2,3.3 };


    PrintArray(charArray);

    PrintArray(intArray);

    PrintArray(doubleArray);

}


template <typename TypeOfData>

void PrintArray(TypeOfData &arrayOfType)

{

    int elementsCount = sizeof(arrayOfType) / sizeof(arrayOfType[0]);


    for (int i = 0; i < elementsCount; i++)

    {

        cout << "Value in elements at position " << i + 1 << " is " << arrayOfType[i] << endl;

    }

}
0
Nooruddin Dar