Comment faire en sorte que le compilateur vérifie une longueur de tableau?

Bien sûr, st doit être de taille 20 (ou plus).

Vous pouvez utiliser la fonction d'index de tableau statique de C99, disponible pour une utilisation dans déclarateurs de fonction .

Si le mot-clé static apparaît également dans les [et] de la dérivation de type tableau, alors pour chaque appel à la fonction, la valeur de l'argument réel correspondant doit donner accès au premier élément d'un tableau avec au moins autant de éléments tels que spécifiés par l'expression de taille.

Vous pouvez donc déclarer la fonction comme

void myFunction(char string[static 20])
{
    /* ... */
}

à la place. Cela déclenchera un avertissement du compilateur si l'argument de tableau passé contient moins de 20 éléments.

Par exemple, lorsque vous appelez maFonction avec st de type char [5] , clang 10 me donne avertissement: l'argument du tableau est trop petit; contient 5 éléments, l'appelé nécessite au moins 20 [-Warray-bounds]

Cependant, pour l'instant, seul clang semble avoir le support avec -Warray-bounds , et GCC prévoit d'ajouter le support dans le futur . p >

Notez que cela ne fonctionne qu'au moment de la compilation pour les tableaux, mais cela en avertit également un lors du passage de pointeurs NULL (si cela peut être déterminé au moment de la compilation). Cependant, quelqu'un peut passer un pointeur vers un tableau d'éléments alloué dynamiquement inférieur à 20, et le compilateur ne peut pas le vérifier statiquement au moment de la compilation.

Donc, dans ce cas, cela ne fonctionne bien que lorsque le type déclaré de l'argument est char [N] où N est sa taille, et N est au moins 20. Si vous souhaitez gérer les deux cas, un paramètre de taille explicite sera nécessaire, et une vérification à l'intérieur de la fonction pour retourner une erreur dans le cas où la taille passée est inférieure à 20.

Vous pouvez encapsuler le tableau:

void myFunction( char (*string)[20] )
{
}
//....
char st[5];
char st20[20];
myFunction(&st); //WRONG; diagnosed error
myFunction(&st20); //OK

ou passer des pointeurs vers le tableau (! = pointeurs vers le premier élément):

struct string20 { char string[20]; };
void myFunction(struct string20 *string)
{
}

En utilisant l'une de ces approches, vous obtiendrez des diagnostics du compilateur quelle que soit votre plate-forme (tant qu'il s'agit d'une plate-forme conforme à la norme).

Votre fonction ressemble à ceci:

char st[5];
myFunction(st);

Mais, le compilateur la voit comme ceci:

void myFunction(char *string)
{
    // update my string here, maximal size is 20.
}

La taille "20" signifie littéralement rien au compilateur. Vous pouvez appeler la fonction avec un tableau de n'importe quelle longueur.

Concernant l'appel avec:

void myFunction(char string[20])
{
    // update my string here, maximal size is 20.
}

C'est tout à fait correct.

Si vous voulez appliquer une taille de tableau spécifique, vous pouvez envelopper le tableau dans une structure.