toujours initialiser un pointeur ?

Bonjour,
j'aimerais savoir si on doit initialiser un pointeur lors de sa déclaration. En effet, quand je compile, j'ai un message de warning tel que :

Code:

---

1 2	warning: ‘pub_key_buf’ may be used uninitialized in this function

---

Et le code ressemble a ceci :

Code:

---

1 2	unsigned char *pub_key_buf ; length = BN_bn2bin(const_pub_key, pub_key_buf);

---

Est ce que je devrais faire un:

Code:

---

unsigned char *pub_key_buf = NULL;

---

Quel est l'inconvénient ? est ce une bonne manière ?
merci d'avance.

Je ne connais pas la fonction BN_bn2bin, mais en général quand une fonction prend un pointeur en paramètre, il faut que celui-ci pointe vers une zone mémoire accessible, ce qui n'est pas le cas dans les deux exemples que tu proposes.

Après une recherche google, je suis tombé sur ça (click) :

Citation:

---

BN_bn2bin() converts the absolute value of a into big-endian form and stores it at to. to must point to BN_num_bytes(a) bytes of memory.

---

... ce qui, traduit en bon français, t'indique que la fonction sert à convertir un grand nombre (const_pub_key) en une chaine de caractères. Il est également écrit que cette chaine de caractère doit être pré-allouée et doit contenir au moins BN_num_bytes(a) bytes (1 byte = 1 octet = sizeof(char), dont autant de caractères si je ne m'abuse).

Du coup le code qui fonctionne serait plutôt :

Code:

---

1 2 3 4 5

int size = BN_num_bytes(const_pub_key); unsigned char* pub_key_buff = new unsigned char[size]; length = BN_bn2bin(const_pub_key, pub_key_buf); // ... delete[] pub_key_buff;

---

Mais j'ai bien peur que tout ça n'ait rien à voir avec le C++.
Si tu ne veux pas avoir à te casser la tête avec le chaines de caractère à la C, tu peux chercher une bibliothèque équivalente écrite en C++, par exemple celle ci : SSL++ (je ne la connais pas du tout, mais c'est le premier résultat sur google).

Pour répondre à ta question, tu n'es pas obligé de toujours initialiser tes pointeurs, mais c'est une bonne pratique, qui ne coute pas grand chose et peut t'épargner de longues heures de debug.

Merci :), ca marche nikel

Salut,

De manière générale, il est préférable de toujours initialiser les différentes variables que l'on crée, autant que faire se peut avec une valeur qui soit directement correcte.

C'est, entre autres, la raison pour laquelle on n'insistera jamais assez sur l'utilisation des constructeurs, dont le but est de fournir des objets "directement utilisables" (comprend: dont on est sur qu'il créent directement des objets cohérents, dont les différents membres sont initialisés de manière à permettre à l'objet de fournir les services que l'on attend de lui pour une /des valeur(s) donnée(s) ).

A défaut de pouvoir fournir une valeur correcte au moment de la déclaration, il est "de bon ton" de fournir une valeur qui pourra être testée et reconnue comme représentant une valeur "invalide" et nécessitant donc d'être redéfinie de manière utile.

C'est d'autant plus vrai pour les pointeurs qui ne sont, en définitive, que des variable particulières car représentant... l'adresse mémoire à laquelle se trouve une information donnée.

Si tu n'initialise pas correctement ton pointeur, il n'est pas exclu que la valeur qu'il contient (et qui est sensé représenter une adresse mémoire valide et accessible) soit en fait le "résidu" d'une utilisation antérieure de la mémoire, peut etre due à une application fermée depuis longtemps (autrement dit: des crasses !!!) :P

Je te laisse imaginer les problèmes qui pourraient se poser si tu venais à essayer de lire, ou pire, de modifier ce qui se trouve à cette adresse prédendument valide: une lecture aura de fortes chances de te donner un résultat tout à fait aberrant, alors qu'une tentative d'écriture risqe, purement et simplement, de modifier des données qui n'auraient jamais du l'être, le "moindre mal" étant que l'application lance un signal d'erreur de segmentation :P

L'idéal est donc, pour autant que faire se peut, de "reporter" la déclaration de ton pointeur jusqu'au moment où tu sera, effectivement, en mesure de le faire pointer vers une adresse valide (par exemple, en l'initialisant avec le résultat de new ou de new[]).

Mais il arrive régulièrement (entre autre lorsque l'on doit avoir recours au polymorphisme et que le type réel de l'objet doit être déterminé de manière dynamique) que l'on ne soit en mesure d'initialiser de manière utile le pointeur que bien après sa déclaration.

Dans ce cas, il est primordial de veiller à l'initialiser à NULL lors de la déclaration.

C'est, en effet, la valeur d'une adresse connue et testable comme étant invalide.

Il te sera donc facile (et largement conseillé) de t'assurer de la validité de ton pointeur, pour autant que tu "prenne le pli" de systématiquement "ré initialiser" ton pointeur à NULL chaque fois que tu effectue une action tendant à invalider l'adresse mémoire qu'il contient.

L'avantage supplémentaire étant que toute tentative d'invocation de delete (ou delete[]) sur cette adresse est garantie sans effet, alors qu'une tentative d'invocation de delete (ou delete[]) sur une adresse pointant sur "n'importe quoi" (comprend: sur une adresse semblant valide mais pointant vers quelque chose n'ayant rien à voir) aura des conséquences désastreuses.