Discussion :

[Luc Hermitte]

C'est assez moyen tous ces trucs. Je pensais que la signature template prenant un tableau (référence sur tableau ?) serait prioritaire, sur celle prenant un pointeur, mais même pas.
Pire, avec une signature prenant un tableau et celle prenant un pointeur, il y a ambiguité.

Code :

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

1
2
3
4
5
6
void f(int * p) { cout << "pointeur\n"; }
// template <int N> void f(int (&p)[N]) {cout << "tableau[N]\n";}
void f(int (&p)[42]) {cout << "tableau[42]\n";}
...
    int T[42];
    f(T);

[Jean-Marc.Bourguet]

C'est assez moyen tous ces trucs.

N'est-ce pas? J'ai à moitié en projet de faire un article récapitulant toutes les subtilités des tableaux, et ça m'arrive encore d'en apprendre comme hier.

[koala01]

Salut,

+1 pour loufoque.

De plus, pour l'histoire des "hors limites", tu peux facilement comprendre que dans une boucle ou une demande d'accès au n-ième élément d'un tableau mais d'une manière non déterminée à la compilation, le compilateur ne pourra jamais savoir si c'est bien dans les limites du tableau ou non.
Alors lui imposer cette vérification qui ne sera pas toujours utile, voir rarement, rajoutant un temps de compilation non négligeable et tout, ce serait bof.
Autant user de la rigueur à outrance à la place.

Sauf que cela implique bel et bien que tu n'as PAS de controle de taille sur un tableau...

Quand tu utilises n'importe quel conteneur de la STL, tu disposes d'un controle de taille, meme s'il est indirect, grâce à la méthode size(), ou à la methode end() qui renvoie un iterateur, mais tu n'as aucune possiblité similaire avec les tableaux.

Quand tu utilises un tableau, c'est à toi à indiquer, d'une manière ou d'une autre, la taille du tabeau, de manière à ce que ta fonction puisse calculer le moment où elle doit sortir de sa boucle (et éviter d'accéder à des éléments hors limites, voire, qu'il boucle sur le Giga de mémoire dont tu disposes)

Il est bien évident que la meme rigueur doit etre utilisée que tu utilises un conteneur STL ou un tableau...

Mais tu ne peux obtenir cette rigueur sur un tableau qu'à partir du moment... ou tu fournis explicitement une valeur supplémentaire à la fonction qui l'emploi (à savoir la taille du tableau), que ce soit une taille fixe, pour un tableau de taille précise, ou un parametre de fonction supplémentaire pour permettre d'adapter la fonction au plus grand nombre de cas, n'est en définitive qu'un détail d'implémentation

[Luc Hermitte]

Quand tu utilises n'importe quel conteneur de la STL, tu disposes d'un controle de taille, meme s'il est indirect, grâce à la méthode size(), ou à la methode end() qui renvoie un iterateur, mais tu n'as aucune possiblité similaire avec les tableaux.

Que nenni. Dans le cas des tableaux (statiques) (et non des buffers alloués dynamiquement), avec la fonction template que je donne plus haut tu disposes de l'indication de taille. NB: la surcharge pointeur est malheureusement, et étrangement, prioritaire -- sauf en full-template.

Code :

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

1
2
3
4
5
6
7
8
9
template <typename T, int N> void g(T (&t)[N])
{cout << "tableau["<<N<<"]\n";}
template <typename T>        void g(T * p)
{cout << "pointeur\n";}
...
    int t[42];
    int * p = t;
    g(t);
    g(p);