Discussion :

[cijad]

Bonjour,

ma question est peut être plus une question de méthode. J'aimerais savoir si il y a un moyen de s'assurer de la taille d'un tableau passé en paramètre d'une fonction.

Il y a plusieurs raisons à cela :

• s'assurer de la bonne utilisation de la fonction par le code client. Je ne voudrais pas par exemple que le code client passe un tableau de 2 éléments quand il en faudrait 4.

• avoir une fonction qui a un comportement différent selon le nombre d'éléments dans le tableau

Je sais que lorsqu'un tableau est passé comme argument d'une fonction c'est en fait implicitement un pointeur qui est passé, et c'est ce qui pose problème justement. J'ai bien pensé à demander un second argument contenant le nombre de champs dans le tableau, mais cela ne résout que partiellement le problème car rien ne garanti que le tableau passé fasse effectivement la taille annoncée.

Pour illustrer ma question :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
#include <iostream>
#include <cstdlib>
 
void f( int entier[4], int n ){
  std::cout<<"il y a "<<n<<" entiers."<<std::endl;
  for( unsigned int i = 0; i<n ; ++i ){
    std::cout<<"  entier "<<i<<" : "<<entier[i]<<std::endl;
  }
}
 
int main( int argc, char* argv[]){
  int entier4[] = {0,1,2,3};
  int entier8[] = {0,1,2,3,4,5,6,7};
  f(entier8,8); // good behaviour
  f(entier4,8); // bad behaviour
  return EXIT_SUCCESS;
}

cela retourne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
il y a 8 entiers.
  entier 0 : 0
  entier 1 : 1
  entier 2 : 2
  entier 3 : 3
  entier 4 : 4
  entier 5 : 5
  entier 6 : 6
  entier 7 : 7
il y a 8 entiers.
  entier 0 : 0
  entier 1 : 1
  entier 2 : 2
  entier 3 : 3
  entier 4 : 0
  entier 5 : 0
  entier 6 : 852933709
  entier 7 : 32669

Merci d'avance pour votre aide

PS: je poste ici et non dans le forum C car je travaille effectivement en C++ et celui-ci apporte peut être des solutions différentes à ce problème.

[r0d]

Bonjour,

je poste ici et non dans le forum C car je travaille effectivement en C++ et celui-ci apporte peut être des solutions différentes à ce problème.

Effectivement: en c++, on utilisera plutôt une classe conteneur pour manipuler des tableaux. Par exemple un vecteur (voir std::vector), plutôt qu'un int[]. Et du coup, les conteneurs possèdent une fonction size() qui te donne la taille du tableau.

A noter que si tu choisis d'uitiliser un tableau, il sera certainement préférable de le passer par référence (éventuellement constante), plutôt que par valeur.

[koala01]

Salut, et bienvenue sur le forum.

De manière générale, il est très rare que l'on crée une fonction prenant en paramètre un tableau d'éléments de taille fixe.

En C, nous passerons généralement un pointeur sur le pemier élément du tableau (ce qui revient en réalité à passer le tableau lui-même ) et, pour s'assurer de la taille du tableau, nous demanderons à l'utilisateur de l'indiquer explicitement, sous une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
void foo(Type * ptr, int size)
{
    printf("we have (normally) %d elements in our vector",size);
}

En C++, nous préférerons utiliser une classe créée tout spécialement pour gérer des tableaux d'éléments contigus en mémoire: la classe vector, disponible dans l'espace de noms std par simple inclusion du fichier d'en-tête <vector>.

Cette classe apporte énormément de sécurité à l'utilisation, entre autre pour tout ce qui a trait à la gestion de la mémoire et à l'utilisation des pointeurs. Il est donc fortement recommandé d'en user et d'en abuser

De plus, elle a l'énorme avantage de connaitre sa taille, ce qui nous intéresse ici, car tu peux donc vérifier à n'importe quel moment que l'utilisateur a placé un nombre correct d'élément dans le tableau

La fonction qui permet de ce faire est la fonction membre size(). tu pourrais donc t'assurer de la présence d'un nombre correct d'éléments avec un code proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
void bar(std::vector<UnType> /* const */ & tab)
{
     if(tab.size()== 8
     {
        std::cout<<"le tableau continent bien 8 elements, c'est ce qui etait"
                 <<" attendu";
     }
     else
     {
         std:::cout<<"j'attendais un tableau de 8 elements, or il en contient "
                       <<tab.size();
     }
}

[cijad]

Merci pour vos réponses.

En effet std::vector se révèle être une bonne option. Je l'avais écartée dans un premier temps en réfléchissant à ce problème parce qu'elle m'avait paru beaucoup plus complexe qu'un tableau au premier abord et que le code client de mes objets manipule plutôt des tableaux.

Jusque là je voyais std::vector comme un conteneur qu'on initialise, rempli, puis sur lequel on itère pour manipuler son contenu ... Suite à vos réponses j'y ai regardé de plus près et c'est vrai que std::vector peut se manipuler vraiment comme un tableau, notamment à sa construction.

merci encore et bonne journée

[Joel F]

Pour des tableaux C :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
template<int N>   void
f( const int (& entier)[N] )
{
  std::cout<<"il y a "<<n<<" entiers."<<std::endl;
  for( unsigned int i = 0; i<n ; ++i ){
    std::cout<<"  entier "<<i<<" : "<<entier[i]<<std::endl;
  }
}

devrait suffire :

http://codepad.org/JfIYfpS1

[Flob90]

Pour le code de Joel (qu'on trouve aussi dans la FaQ comeau), il ne faut pas oublier que le tableau ne doit pas être alloué dynamiquement. (A cause du template qui sera évalué à la compilation).

[cijad]

Merci pour l'astuce avec les templates

Je n'avais jamais réalisé que l'on pouvait faire ce genre de chose.
Ils sont décidément vraiment très fort ces templates.