Calculer la longueur du tableau en C en utilisant la fonction

Vous ne pouvez pas calculer la taille d'un tableau lorsque tout ce que vous avez est un pointeur.

Le seul moyen de faire cette "fonction de type" "est de définir une macro: p> xxx

Ceci est livré avec toutes les réserves habituelles des macros, bien sûr. p>

EDIT: strong> (Les commentaires ci-dessous appartiennent vraiment à la réponse ...) p>

1. vous ne peut pas strud> déterminer le nombre d'éléments initialisés em> dans un tableau, sauf si vous initialisez tous les éléments à une valeur "invalide" en premier et à compter les valeurs "valides" manuellement. Si votre matrice a été définie comme ayant 8 éléments, pour le compilateur, il dispose de 8 éléments, que vous soyez initialisé seulement 5 d'entre eux. LI>
2. vous ne peut pas strud> déterminer la taille d'un tableau dans une fonction à laquelle ce tableau a été transmis en tant que paramètre. Pas directement, pas à travers une macro, pas de quelque manière que ce soit. Vous pouvez SEULEMENT STRUT> déterminer la taille d'un tableau dans la portée, il a été déclaré dans em>. Li> ol>

   L'impossibilité de déterminer la taille de la matrice dans une fonction appelée peut être comprise une fois que vous réalisez que Tailleof () CODE> est un Compile-Time em> opérateur fort>. Il pourrait regarder em> comme un appel de fonction d'exécution, mais ce n'est pas le cas: le compilateur em> détermine la taille des opérandes et les insère sous forme de constantes. P>

   Dans la portée, le tableau est déclaré, le compilateur a les informations qu'il s'agit en réalité d'une matrice et combien d'éléments il a. p>

   dans une fonction à laquelle le tableau est passé, tout le compilateur voit est un pointeur. (Considérez que la fonction pourrait être appelée avec de nombreux différents tableaux em> et rappelez-vous que Tailleof () code> est un opérateur de compilation em>. P >

   Vous pouvez passer à C ++ et utiliser code>. Vous pouvez définir un vecteur structurer code> plus des fonctions qui manipulent cela, mais ce n'est pas vraiment confortable: p>

   #include <stdlib.h>
   
   typedef struct
   {
       int *  _data;
       size_t _size;
   } int_vector;
   
   int_vector * create_int_vector( size_t size )
   {
       int_vector * _vec = malloc( sizeof( int_vector ) );
       if ( _vec != NULL )
       {
           _vec._size = size;
           _vec._data = (int *)malloc( size * sizeof( int ) );
       }
       return _vec;
   }
   
   void destroy_int_vector( int_vector * _vec )
   {
       free( _vec->_data );
       free( _vec );
   }
   
   int main()
   {
       int_vector * myVector = create_int_vector( 8 );
       if ( myVector != NULL && myVector->_data != NULL )
       {
           myVector->_data[0] = ...;
           destroy_int_vector( myVector );
       }
       else if ( myVector != NULL )
       {
           free( myVector );
       }
       return 0;
   }