Pourquoi les compilateurs C et C ++ autorisent-ils des longueurs de tableau dans les signatures de fonction quand elles ne sont jamais appliquées?

Voici ce que j'ai trouvé pendant ma période d'apprentissage:

#include<iostream>
using namespace std;
int dis(char a[1])
{
    int length = strlen(a);
    char c = a[2];
    return length;
}
int main()
{
    char b[4] = "abc";
    int c = dis(b);
    cout << c;
    return 0;
}  

Donc, dans la variable int dis(char a[1]), le [1]semble ne rien faire et ne fonctionne pas du
tout, car je peux utiliser a[2]. Tout comme int a[]ou char *a. Je sais que le nom du tableau est un pointeur et comment transmettre un tableau, donc mon puzzle ne concerne pas cette partie.

Ce que je veux savoir, c'est pourquoi les compilateurs autorisent ce comportement ( int a[1]). Ou a-t-il d'autres significations que je ne connais pas?

C'est une bizarrerie de la syntaxe pour passer des tableaux aux fonctions.

En fait, il n'est pas possible de passer un tableau en C. Si vous écrivez une syntaxe qui semble devoir passer le tableau, ce qui se passe réellement est qu'un pointeur vers le premier élément du tableau est passé à la place.

Étant donné que le pointeur n'inclut aucune information de longueur, le contenu de votre []dans la liste de paramètres formels de la fonction est en fait ignoré.

La décision d'autoriser cette syntaxe a été prise dans les années 1970 et a causé beaucoup de confusion depuis ...

La longueur de la première dimension est ignorée, mais la longueur des dimensions supplémentaires est nécessaire pour permettre au compilateur de calculer correctement les décalages. Dans l'exemple suivant, la foofonction reçoit un pointeur vers un tableau à deux dimensions.

#include <stdio.h>

void foo(int args[10][20])
{
    printf("%zd\n", sizeof(args[0]));
}

int main(int argc, char **argv)
{
    int a[2][20];
    foo(a);
    return 0;
}

La taille de la première dimension [10]est ignorée; le compilateur ne vous empêchera pas d'indexer la fin (notez que le formel veut 10 éléments, mais le réel n'en fournit que 2). Cependant, la taille de la deuxième dimension [20]est utilisée pour déterminer la foulée de chaque ligne, et ici, le formel doit correspondre au réel. Là encore, le compilateur ne vous empêchera pas non plus d'indexer la fin de la deuxième dimension.

Le décalage d'octet entre la base du tableau et un élément args[row][col]est déterminé par:

sizeof(int)*(col + 20*row)

Notez que si col >= 20, alors vous indexerez réellement dans une ligne suivante (ou à la fin du tableau entier).

sizeof(args[0]), revient 80sur ma machine où sizeof(int) == 4. Cependant, si j'essaye de prendre sizeof(args), j'obtiens l'avertissement suivant du compilateur:

foo.c:5:27: warning: sizeof on array function parameter will return size of 'int (*)[20]' instead of 'int [10][20]' [-Wsizeof-array-argument]
    printf("%zd\n", sizeof(args));
                          ^
foo.c:3:14: note: declared here
void foo(int args[10][20])
             ^
1 warning generated.

Ici, le compilateur avertit qu'il ne donnera que la taille du pointeur dans lequel le tableau s'est désintégré au lieu de la taille du tableau lui-même.

Le problème et comment le surmonter en C ++

Le problème a été largement expliqué par pat et Matt . Le compilateur ignore fondamentalement la première dimension de la taille du tableau en ignorant effectivement la taille de l'argument passé.

En C ++, en revanche, vous pouvez facilement surmonter cette limitation de deux manières:

• en utilisant des références
• using std::array(depuis C ++ 11)

Références

Si votre fonction essaie uniquement de lire ou de modifier un tableau existant (sans le copier), vous pouvez facilement utiliser des références.

Par exemple, supposons que vous souhaitiez avoir une fonction qui réinitialise un tableau de dix ints en définissant chaque élément sur 0. Vous pouvez facilement le faire en utilisant la signature de fonction suivante:

void reset(int (&array)[10]) { ... }

Non seulement cela fonctionnera très bien , mais cela imposera également la dimension du tableau .

Vous pouvez également utiliser des modèles pour rendre le code ci-dessus générique :

template<class Type, std::size_t N>
void reset(Type (&array)[N]) { ... }

Et enfin, vous pouvez profiter de l' constexactitude. Considérons une fonction qui imprime un tableau de 10 éléments:

void show(const int (&array)[10]) { ... }

En appliquant le constqualificatif, nous évitons d'éventuelles modifications .

La classe de bibliothèque standard pour les tableaux

Si vous considérez la syntaxe ci-dessus à la fois laide et inutile, comme je le fais, nous pouvons la jeter dans la boîte et l'utiliser à la std::arrayplace (depuis C ++ 11).

Voici le code refactoré:

void reset(std::array<int, 10>& array) { ... }
void show(std::array<int, 10> const& array) { ... }

N'est-ce pas merveilleux? Sans oublier que l' astuce de code générique que je vous ai enseignée plus tôt fonctionne toujours:

template<class Type, std::size_t N>
void reset(std::array<Type, N>& array) { ... }

template<class Type, std::size_t N>
void show(const std::array<Type, N>& array) { ... }

Non seulement cela, mais vous obtenez une copie et un déplacement sémantique gratuitement. :)

void copy(std::array<Type, N> array) {
    // a copy of the original passed array 
    // is made and can be dealt with indipendently
    // from the original
}

Alors qu'est-ce que tu attends? Allez utiliser std::array.

C'est une fonctionnalité amusante de C qui vous permet de vous tirer efficacement dans le pied si vous êtes si incliné.

Je pense que la raison en est que C est juste un pas au-dessus du langage d'assemblage. La vérification de la taille et les fonctions de sécurité similaires ont été supprimées pour permettre des performances optimales, ce qui n'est pas une mauvaise chose si le programmeur est très diligent.

En outre, attribuer une taille à l'argument de fonction a l'avantage que lorsque la fonction est utilisée par un autre programmeur, il y a une chance qu'il remarque une restriction de taille. Le simple fait d'utiliser un pointeur ne transmet pas cette information au prochain programmeur.

Premièrement, C ne vérifie jamais les limites du tableau. Peu importe qu'ils soient des paramètres locaux, globaux, statiques, peu importe. Vérifier les limites du tableau signifie plus de traitement, et C est censé être très efficace, donc la vérification des limites du tableau est effectuée par le programmeur en cas de besoin.

Deuxièmement, il existe une astuce qui permet de passer par valeur un tableau à une fonction. Il est également possible de renvoyer par valeur un tableau à partir d'une fonction. Il vous suffit de créer un nouveau type de données à l'aide de struct. Par exemple:

typedef struct {
  int a[10];
} myarray_t;

myarray_t my_function(myarray_t foo) {

  myarray_t bar;

  ...

  return bar;

}

Vous devez accéder aux éléments comme ceci: foo.a [1]. Le ".a" supplémentaire peut sembler étrange, mais cette astuce ajoute de grandes fonctionnalités au langage C.

Pour indiquer au compilateur que myArray pointe vers un tableau d'au moins 10 pouces:

void bar(int myArray[static 10])

Un bon compilateur devrait vous donner un avertissement si vous accédez à myArray [10]. Sans le mot-clé "statique", le 10 ne signifierait rien du tout.

Il s'agit d'une "fonctionnalité" bien connue de C, passée au C ++ car C ++ est censé compiler correctement le code C.

Le problème découle de plusieurs aspects:

1. Un nom de tableau est censé être complètement équivalent à un pointeur.
2. C est censé être rapide, à l'origine developerd être une sorte d '"assembleur de haut niveau" (spécialement conçu pour écrire le premier "système d'exploitation portable": Unix), donc il n'est pas censé insérer du code "caché"; la vérification de la plage d'exécution est donc "interdite".
3. Le code machine généré pour accéder à un tableau statique ou dynamique (dans la pile ou alloué) est en fait différent.
4. Puisque la fonction appelée ne peut pas connaître le "genre" de tableau passé en argument, tout est supposé être un pointeur et traité comme tel.

On pourrait dire que les tableaux ne sont pas vraiment supportés en C (ce n'est pas vraiment vrai, comme je le disais auparavant, mais c'est une bonne approximation); un tableau est en fait traité comme un pointeur vers un bloc de données et accessible à l'aide de l'arithmétique du pointeur. Puisque C n'a AUCUNE forme de RTTI, vous devez déclarer la taille de l'élément du tableau dans le prototype de fonction (pour prendre en charge l'arithmétique du pointeur). Ceci est encore «plus vrai» pour les tableaux multidimensionnels.

Quoi qu'il en soit, tout ce qui précède n'est plus vraiment vrai: p

La plupart des compilateurs C / C ++ modernes prennent en charge la vérification des limites, mais les normes exigent qu'elle soit désactivée par défaut (pour la compatibilité descendante). Les versions raisonnablement récentes de gcc, par exemple, font une vérification de la plage au moment de la compilation avec "-O3 -Wall -Wextra" et une vérification des limites à l'exécution complète avec "-fbounds-checking".

C ne transformera pas seulement un paramètre de type int[5]en *int; compte tenu de la déclaration typedef int intArray5[5];, il transformera un paramètre de type intArray5à *intaussi bien. Il y a des situations où ce comportement, bien qu'étrange, est utile (en particulier avec des éléments comme le va_listdefined in stdargs.h, que certaines implémentations définissent comme un tableau). Il serait illogique d'autoriser comme paramètre un type défini comme int[5](ignorant la dimension) mais ne pas permettre int[5]d'être spécifié directement.

Je trouve que la gestion par C des paramètres de type tableau est absurde, mais c'est une conséquence des efforts pour prendre un langage ad-hoc, dont de grandes parties n'étaient pas particulièrement bien définies ou réfléchies, et essayer de trouver des des spécifications cohérentes avec ce que les implémentations existantes ont fait pour les programmes existants. Beaucoup des bizarreries de C ont un sens vu sous cet angle, en particulier si l'on considère que lorsque beaucoup d'entre elles ont été inventées, de grandes parties du langage que nous connaissons aujourd'hui n'existaient pas encore. D'après ce que j'ai compris, dans le prédécesseur de C, appelé BCPL, les compilateurs ne suivaient pas vraiment très bien les types de variables. Une déclaration int arr[5];équivaut à int anonymousAllocation[5],*arr = anonymousAllocation;; une fois l'allocation mise de côté. le compilateur ne savait ni ne se souciait de savoir siarrétait un pointeur ou un tableau. Lorsqu'il est accédé comme étant l'un arr[x]ou l' autre *arr, il serait considéré comme un pointeur quelle que soit la façon dont il a été déclaré.

Une chose qui n'a pas encore été répondue est la question réelle.

Les réponses déjà données expliquent que les tableaux ne peuvent pas être passés par valeur à une fonction en C ou C ++. Ils expliquent également qu'un paramètre déclaré comme int[]est traité comme s'il avait un type int *, et qu'une variable de type int[]peut être passée à une telle fonction.

Mais ils n'expliquent pas pourquoi il n'a jamais été commis d'erreur de fournir explicitement une longueur de tableau.

void f(int *); // makes perfect sense
void f(int []); // sort of makes sense
void f(int [10]); // makes no sense

Pourquoi le dernier de ces derniers n'est-il pas une erreur?

Une raison à cela est que cela pose des problèmes avec les typedefs.

typedef int myarray[10];
void f(myarray array);

S'il s'agissait d'une erreur de spécifier la longueur du tableau dans les paramètres de fonction, vous ne pourrez pas utiliser le myarraynom dans le paramètre de fonction. Et comme certaines implémentations utilisent des types de tableaux pour des types de bibliothèques standard tels que va_list, et que toutes les implémentations sont nécessaires pour créer jmp_bufun type de tableau, il serait très problématique s'il n'y avait pas de moyen standard de déclarer les paramètres de fonction en utilisant ces noms: sans cette capacité, il pourrait ne pas être une implémentation portable de fonctions telles que vprintf.

Il est permis aux compilateurs de pouvoir vérifier si la taille du tableau passé est la même que celle attendue. Les compilateurs peuvent signaler un problème si ce n'est pas le cas.