'pouvez répéter la questioooon ?

donner le mauvais accès à la mémoire réservée par ce pointeur

un pointeur en soi ne réserve pas de mémoire :

int main()
{
 int * input = NULL, 
 int *output = NULL;
 mafonction(output, input, 42);
}

Ici aucune mémoire n'a été allouée aux pointeurs input et output donc l'appel à mafonction va déréférencer un pointeur NULL ce qui va engendrer un comportement non-défini, ce qui est à-peu-près passible de la peine capitale pour un programmeur C.

(Là je suis sympa, il me semble que Linux est pas trop méchant et plante le programme direct quand le pointeur est NULL, par contre si le pointeur n'avait pas été initialisé du tout, c'était des feux d'artifice)
Tu peux décider d'utiliser de la mémoire sur la pile pour appeler ta fonction:

int main()
{
 int input[42]; 
 int output[42];
 mafonction(output, input, 42);
}

Ici, on a bien de la mémoire pour l'input et l'output (mémoire de la pile), mais l'appel à mafonction va engendrer la lecture du tableau input qui n'a pas été initialisé, ce qui va provoquer un comportement non-défini, ce qui est à-peu-près passible de la peine capitale pour un programmeur C.

Tu peux corriger en initialisant les données lues :

int main()
{
 int input[] = {0, 1 , 42}; 
 int output[42];
 mafonction(output, input, 42);
}

Là, c'est bien on a initialisé les données, mais on a dépassé la taille du tableau input, et on commence à lire et à écrire des données en débordant du tableau , ce qui va provoquer un comportement non-défini, ce qui est à-peu-près passible de la peine capitale pour un programmeur C.

On peut s'en sortir en contraignant la taille de ton tableau de sortie.

int main()
{
 int input[] = {0, 1 , 42}; 
 int output[sizeof(input) / sizeof(int)];//does C11+ have constexpr?
 mafonction(output, input, sizeof(input) / sizeof(int);
}

Tu peux aussi décider d'allouer un tableau sur le tas et bien penser à initialiser les données et tout et tout.

int main()
{
 cont size_t length = 42;
 int *input = malloc(length * sizeof(int)}; 
 for (size_t i = 0; i!= length;++i){input[i] = length - i;} 
 int output = malloc(length * sizeof(int)}; 
 mafonction(output, input, length);
}

Mais on aura oublié d'invoquer free afin de libérer la mémoire allouée pour input et output, créant une fuite de mémoire qui est à-peu-près passible de la peine capitale pour un programmeur C.

C'est le côté fun du C, on donne au programmeur une infinité d'opportunités de se prendre les pieds dans le tapis.

Bon 'dredi !