Je passe 3 pointeurs (key, K1Ptr, K2Ptr) comme arguments à une fonction (keyGenerator) mais lorsque l'appel de fonction se termine, seul le pointeur de touche conserve la valeur de l'appel de fonction et les 2 autres pointeurs ne le font pas.
J'ai essayé beaucoup de choses différentes, comme renvoyer un tableau avec les 2 pointeurs, ou j'ai essayé de ne pas utiliser de pointeurs et de passer 2 tableaux à la place. Les deux essais ont eu le même résultat, aucun n'a conservé la valeur après l'appel de la fonction.
char* P8_swap(char *left_key, char *right_key) {
int P8[8] = {6, 3, 7, 4, 8, 5, 10, 9}; //key possitions after P8 operation
char P8_Output[9];
char *K1; //They key after the P8 swap
char keyLR[11]; //The left and right halves will be stored together here
int i;
//The two halves become one so that we can do the P8 swap
for(i=0;i<5;i++) {
keyLR[i] = left_key[i];
keyLR[i+5] = right_key[i];
}
//P8 swap
for(i=0; i<8; i++) {
P8_Output[i] = keyLR[P8[i]-1]; //P10[i] - 1 because the possitiongs in P10 are from 1-10 and not 0-9
}
P8_Output[8] = '\0';
K1 = P8_Output;
return K1;
\
void keyGenerator(char *key, char *K1, char *K2) {
char P10_Left[6];
char P10_Right[6];
char *P10leftPtr, *P10rightPtr;
printf("Starting key: %s\n", key);
//P10 Operation first step
P10_swap(key);
printf("P10swap key: %s\n", key);
//Initializing the left and right arrays
int i;
for(i=0;i<5;i++) {
P10_Left[i] = key[i];
P10_Right[i] = key[i+5];
}
P10_Left[5] = '\0';
P10_Right[5] = '\0';
P10leftPtr = P10_Left;
P10rightPtr = P10_Right;
//The left half shift
LS(P10leftPtr, 1);
//The right half shift
LS(P10rightPtr, 1);
//P8 swap starts here
K1 = P8_swap(P10leftPtr, P10rightPtr);
printf("K1 key: %s\n", K1);
//P8 swap ends here
//After we find K1 we need to shift the 2 halves again, 2 times to the left this time
//The left half shift
LS(P10leftPtr, 2);
//The right half shift
LS(P10rightPtr, 2);
//After the 2 shifts we use P8 operation again on the new halves
//P8 swap starts here
K2 = P8_swap(P10leftPtr, P10rightPtr);
printf("K2 key: %s\n", K2);
//P8 swap ends here
} //
char K1[9], K2[9];
char *K1ptr, *K2ptr;
K1ptr = K1;
K2ptr = K2;
keyGenerator(key, K1ptr, K2ptr);
printf("Key. %s\n", key);
printf("K1. %s\n", K1Ptr);
printf("K2. %s\n", K2Ptr);
}
Après la fonction keyGenerator lorsque j'imprime le K1Ptr et K2Ptr je n'obtiens rien mais je m'attendais à obtenir les valeurs qui sont stockées à l'intérieur de la fonction.
3 Réponses :
Dans cette ligne:
K1 = P8_swap(P10leftPtr, P10rightPtr);
vous modifiez la valeur de K1 mais ce changement est local pour la fonction et ne changera pas la valeur de K1ptr dans main.
Si vous voulez changer la valeur de K1ptr dans main vous devez passer un pointeur vers K1ptr à la fonction. Cependant, cela semble un peu étrange lorsque vous initialisez K1ptr pour pointer vers le char-array K1 [9] . Je suppose que vous ne voulez pas changer la valeur du pointeur dans la fonction, mais simplement copier quelques données dans le tableau "pointé vers".
BTW:
Votre P8_swap est faux. Vous renvoyez un pointeur vers P8_Output qui est une variable locale. Ne fais jamais cela! Lorsque la fonction retourne, la variable locale sort de la portée (c'est-à-dire n'existe plus), de sorte que le pointeur renvoyé pointe vers une mémoire illégale. Si vous voulez vraiment quelque chose comme ça, vous devez utiliser l'allocation de mémoire dynamique.
Définition des paramètres de fonction K1 et K2 :
void keyGenerator (char * key, char * K1, char * K2)
ombres les variables globales:
car K1 [9], K2 [9];
Et comme les paramètres de fonction sont locaux à la portée de la fonction, ils sont en fait assignés, mais la valeur n'est pas propagée aux variables définies ailleurs.
Essayez d'utiliser:
void keyGenerator (char * key, char ** K1, char ** K2)
et appelez-le:
keyGenerator (clé, & K1ptr, & K2ptr);
Il est également nécessaire de changer assignmend en K1 dans la fonction en fonction de la fonction P8_swap.
Le problème est ici
char* tmp = P8_swap(P10leftPtr, P10rightPtr);
for(int i = 0; i < strlen(tmp); i++) {
K1[i] = tmp[i];
}
et ici
char* tmp = P8_swap(P10leftPtr, P10rightPtr); memcpy(K1, tmp, strlen(tmp)+1); ... tmp = P8_swap(P10leftPtr, P10rightPtr); memcpy(K2, tmp, strlen(tmp)+1);
Vous écrasez fondamentalement la valeur des pointeurs, de sorte qu'ils pointent vers quelque chose d'autre qui est finalement détruit à la fin de l'appel de fonction.
Donc, à la place, vous devez copier la valeur de retour de l'appel P8_swap () dans le contenu des pointeurs, comme ceci:
K2 = P8_swap(P10leftPtr, P10rightPtr);
Vous pouvez en savoir plus sur memcpy ici .
ou une boucle for basique le ferait également
K1 = P8_swap(P10leftPtr, P10rightPtr);
Modifier :
Comme @ 4386427 vient de le souligner, le tmp serait dans ce cas un pointeur dangereux à utiliser, car la valeur de retour P8_swap () pourrait être détruit entre-temps - car il est défini localement dans la fonction.
Cependant, si la mémoire était allouée dynamiquement pour la valeur (dans la fonction) - comme je l'ai d'abord supposé, alors le pointeur serait en sécurité utilisation. Voir la démo .
L'utilisation d'un pointeur invalide ( tmp ) n'est pas un bon conseil
La fonction P8_swap renvoie un pointeur vers la variable locale P8_Output , c'est-à-dire que tmp "pointe vers" P8_Output mais P8_Output est hors de portée.
Pouvez-vous ajouter
P8_swap ()à votre code?J'ai ajouté le code P8_swap si cela aide plus. J'ai essayé de changer les arguments de keyGenerator et de mettre des pointeurs doubles mais j'ai des erreurs dans P8_swap.
Votre
P8_swapest incorrect. Vous renvoyez un pointeur versP8_Outputqui est une variable locale . Ne fais jamais cela! Lorsque la fonction retourne, la variable locale n'est plus présente et le pointeur pointe vers une mémoire illégale. Si vous voulez vraiment quelque chose comme ça, vous devez utiliser l'allocation de mémoire dynamique.