Pourquoi ne pouvons-nous pas passer des tableaux à la fonction par valeur ?

Question

Apparemment, nous pouvons passer des instances de classes complexes aux fonctions, mais pourquoi ne pouvons-nous pas passer des tableaux aux fonctions ?

Answer 1

L'origine est historique. Le problème est que la règle "les tableaux se décomposent en pointeurs, lorsqu'ils sont passés à une fonction" est simple.

Copier des tableaux serait un peu compliqué et pas très clair, puisque le comportement changerait pour différents paramètres et différentes déclarations de fonctions.

Notez que vous pouvez toujours faire une passe indirecte par valeur :

struct A { int arr[2]; };
void func(struct A);

Answer 2

Voici une autre perspective : Il n'y a pas un seul type "tableau" en C. Au contraire, T[N] est un a a différents pour chaque N . Donc T[1] , T[2] etc., sont tous différents types .

En C, il n'y a pas de surcharge de fonctions, et donc la seule chose sensée que vous auriez pu autoriser serait une fonction qui prend (ou renvoie) une fonction un seul type de tableau :

void foo(int a[3]);  // hypothetical

Vraisemblablement, cela a été considéré comme beaucoup moins utile que la décision actuelle de faire en sorte que tous les tableaux se décomposent en un pointeur sur le premier élément et que l'utilisateur doive communiquer la taille par d'autres moyens. Après tout, ce qui précède pourrait être réécrit comme suit :

void foo(int * a)
{
  static const unsigned int N = 3;
  /* ... */
}

Il n'y a donc pas de perte de puissance expressive, mais un gain énorme en généralité.

Notez que cela n'est pas différent en C++, mais la génération de code basée sur des modèles vous permet d'écrire une fonction modélisée foo(T (&a)[N]) , donde N est déduit pour vous - mais cela signifie simplement que vous pouvez créer une famille entière de distinct, différent fonctions, une pour chaque valeur de N .

_{Dans un cas extrême, imaginez que vous ayez besoin de deux fonctions <code>print6(const char[6])</code> y <code>print12(const char[12])</code> pour dire <code>print6("Hello")</code> y <code>print12("Hello World")</code> si vous ne voulez pas décomposer les tableaux en pointeurs, sinon vous devrez ajouter une conversion explicite, <code>print_p((const char*)"Hello World")</code> .}

Answer 3

La raison pour laquelle vous ne pouvez pas passer un tableau par valeur est qu'il n'existe pas de moyen spécifique de suivre la taille d'un tableau de telle sorte que la logique d'invocation de la fonction sache combien de mémoire allouer et ce qu'il faut copier. Vous pouvez passer une instance de classe parce que les classes ont des constructeurs. Les tableaux n'en ont pas.

Answer 4

Vous son passer par valeur : la valeur du pointeur vers le tableau. Rappelez-vous que l'utilisation de la notation entre crochets en C est simplement un raccourci pour déréférencer un pointeur. ptr[2] signifie *(ptr+2).

En supprimant les parenthèses, vous obtenez un pointeur sur le tableau, qui peut être transmis par valeur à une fonction :

int x[2] = {1, 2};
int result;
result = DoSomething(x);

Voir le liste des types dans la spécification C de l'ANSI. Les tableaux ne sont pas des types primitifs, mais construits à partir d'une combinaison de pointeurs et d'opérateurs. (Je ne peux pas mettre un autre lien, mais la construction est décrite sous "Array type derivation").

Answer 5

L'équivalent de cela serait de faire d'abord une copie du tableau et de le passer ensuite à la fonction (ce qui peut être très inefficace pour les grands tableaux).

Sinon, je dirais que c'est pour des raisons historiques, c'est-à-dire qu'on ne pouvait pas passer des tableaux par valeur en C.

Je pense que la raison pour laquelle on n'a PAS introduit le passage des tableaux par valeur en C++ était que l'on pensait que les objets avaient une taille modérée par rapport aux tableaux.

Comme l'a souligné delnan, lorsque l'on utilise std::vector vous pouvez en fait passer des objets de type tableau aux fonctions par valeur.