[Résolu] Toujours les pointeurs

Bonsoir,
Voila, je m’intéresse toujours aux pointeurs. Je souhaite faire une fonction qui utilise en argument un pointeur de char local et qui copie son contenue dans un tableau de pointeurS de char déclaré en global. Je ne parviens pas à copier le contenu et l'écrire à l'adresse par mon tableau. Quand je sort de ma fonction local, le contenu pointé par mon tableau global disparait.
Je pointe donc sur l'adresse local.

J'arrive à faire la manipulation avec 2 pointeur de char.

char PointeurVersTabChar(char* Entree, char Sortie[])           //
{
  int q = 0;
  while (Entree[q] != '\0')                                     // Boucle tant qu'on à pas atteins le char nul
  {
    Sortie[q] = Entree[q];                                      // Copie les char pointé
    q++;
  }
  Sortie[q + 1] = '\0';                                         // Ajoute le nul
  return;
}

Je ne souhaite pas utiliser un tableau de taille défini, mais plutôt dynamique.

On ne voit pas tout!
Comment est déclaré Sortie?

Et ça devrait être Sortie[q] = '\0';pas de +1 puisque quand vous en arrivez là de votre fonction c’est que [nobbc]Entree[q] == '\0'[/nobbc]

Je souhaite faire une fonction qui utilise en argument un pointeur de char local et qui copie son contenue dans un tableau de pointeurS de char déclaré en global

strcpy ?

hbachetti:
strcpy ?

Oui c’est ce que je me suis dit aussi mais je me suis ravisé en me disant que l’OP voulait apprendre

Le prototype est plutôt mal choisi :

char PointeurVersTabChar(char* Entree, char Sortie[])           //
{
  int q = 0;
  while (Entree[q] != '\0')                                     // Boucle tant qu'on à pas atteins le char nul
  {
    Sortie[q] = Entree[q];                                      // Copie les char pointé
    q++;
  }
  Sortie[q] = '\0';                                         // Ajoute le nul
  return;
}

Pourquoi pas char *Sortie au lieu de char Sortie ?
Pourquoi la valeur retournée est-elle un char, alors qu’elle ne retourne rien ?
Elle pourrait retourner la chaîne destination ou le nombre de caractères copiés.
Le paramètre Entree pourrait être de préférence const.

@+

hbachetti:
Le prototype est plutôt mal choisi :
Pourquoi pas char *Sortie au lieu de char Sortie ?
Pourquoi la valeur retournée est-elle un char, alors qu'elle ne retourne rien ?
Elle pourrait retourner la chaîne destination ou le nombre de caractères copiés.
Le paramètre Entree pourrait être de préférence const.

genre char * [url=http://www.cplusplus.com/reference/cstring/strcpy/]copieChaine[/url] ( char * destination, const char * source );

:slight_smile:

Voilà. :wink:

et tant qu’on y est, pourquoi pas

char * copieChaine ( char * destination, const char * source ) {
  char * debut = destination;
  while(*destination++ = *source++);
  return debut;
}

;D

bricoleau:
et tant qu'on y est, pourquoi pas

char * copieChaine ( char * destination, const char * source ) {

char * debut = destination;
  while(*destination++ = *source++);
  return debut;
}




;D

oui ou alors

char * copieChaine ( char * destination, const char * source ) {
  return strcpy(destination, source);
}

;D

Bonsoir, merci pour vos réponses,
En fait, ma question est mal formulé car la fonction que je vous ai présenté fonctionne bien. Effectivement, le résultat est le même que ‘strcpy’, mais la je souhaite corser le sujet( pour mon niveau) en utilisent en entrée char * entree et copier la valeur pointé dans char * sortie [9] (qui est un tableau de pointeurs) je souhaite que la valeur se retrouve dans sortie [0] par exemple.
Mais visiblement, il y à quelque chose que je ne saisie pas.

char * Recu[9];
char * PointeurDeChar2 = "abc";
    int q = 0;
    while (PointeurDeChar2[q] != '\0')
    {
      Recu[0][q] = PointeurDeChar2[q];
      q++;
    }
  Recu[0][q] = '\0';

Tu déclares un tableau de 9 pointeurs :

char * Recu[9];

Chaque élément de ce tableau a une valeur dépendant de l'endroit où ce tableau est déclaré :

En global : char pointeur vaut zéro au départ.
Donc ta recopie de caractères de PointeurDeChar2 vers Recu[0] recopie les caractères vers l'adresse 0.
Pas vraiment ce que tu veux non ?

En local : char pointeur a une valeur indéterminée au départ.
Donc ta recopie de caractères de PointeurDeChar2 vers Recu[0] recopie les caractères vers une adresse indéterminée.
Pas vraiment ce que tu veux non plus non ?

Donc :

char Recu[9][X];

A toi de donner à X une valeur appropriée.

@+

Bonjour hbachetti,

Ce que je fais dans ma boucle while me parait être ce que tu propose

Recu[0][q] = PointeurDeChar2[q];

Mais je ne parviens pas au résultat.

Dans la console, j'affiche la valeur que je souhaite copier '300000' par exemple, j'exécute la fonction et je compare avec 'Recu[0]' mais je n'obtiens pas ce que je souhaite.

Ceci fonctionne parfaitement pour moi

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
char Recu[9][10];
char * PointeurDeChar2 = "300000";
    int q = 0;
    while (PointeurDeChar2[q] != '\0')
    {
      Recu[0][q] = PointeurDeChar2[q];
      q++;
    }
  Recu[0][q] = '\0';  
  Serial.println(Recu[0]);     
}

void loop() {
  // put your main code here, to run repeatedly:
}

Je ne déclare 'Recu' comme toi. Je le déclare en tableau de pointeur char * Recu[9];

Oui mais je t'ai expliqué en #11 pourquoi cela ne PEUT PAS FONCTIONNER.
Chacun de tes pointeurs pointe dans le vide.

Merci hbachetti,
Je passe donc char * Recu[9] en char Recu[9].

Bonne soirée!