soucis avec des pointeurs

Version imprimable

Bonjour, j'ai un petit soucis avec des pointeurs.

Voici mon code :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 //--- On extrait les informations des données du buffer pointeur = strtok(buffer,"\x0D\x0A"); printf("pointeur1 : %s\n",pointeur); if(pointeur != NULL) { temporaire = pointeur; temporaire = strtok(pointeur,"\x20"); printf("temporaire : %s",temporaire); printf("point : %s",pointeur); if(strcmp(temporaire,"+CMTI:") == 0) { printf("Message reçu"); // strcat(temporaire,"AT+CMGR="); } } while(pointeur != NULL) { pointeur = strtok( NULL, "\x0D\x0A" ); if(pointeur != NULL)..... }
J'utilise strtok afin de récupérer des chaînes de caractères bien précises. Le problème est que lorsque je récupère une des chaînes, je dois refaire un strtok afin de récuperer une autre chaîne, par exemple :
je peux recevoir : 1er cas : AT+CMGR=+33645644754\r\n>\x20\r\n ou 2ème cas : AT+CMTI:\x20"SM",2.
Pour la première chaîne, je la sous-divise en deux chaînes, AT+CMGR="+33645644754, puis >\x20 et l'autre chaîne est une seule et même chaîne, AT+CMTI:\x20"SM",2. Donc lorsque j'ai récupéré la première chaîne, je fais un nouveau strtok avec comme caractère de séparation, \x20 afin de savoir si je suis dans le 1er ou le 2ème cas. Or quand je fais ce test et que je reçois la chaîne du 1er cas, l'exécution ne repère plus la seconde chaîne (>\x20), comme si pointeur ne valait plus la même valeur. J'espère mettre bien exprimé, et si vous pouviez me donner des pistes, problèmes de pointeurs?de variables...
Je voudrais aussi pouvoir copier uniquement la valeur de pointeur dans temporaire pour que lorsque je modifie temporaire cela ne modifie pas pointeur.
Merci

14/05/2007, 12h46
Darwiz

Citation:

Envoyé par MSDN

char *strtok(
char *strToken,
const char *strDelimit
);

Parameters

strToken : String containing token or tokens.
strDelimit : Set of delimiter characters.

Return Value

Returns a pointer to the next token found in strToken. They return NULL when no more tokens are found. Each call modifies strToken by substituting a NULL character for each delimiter that is encountered.

Une facheuse impression que tu te mélanges un peu.

Si je comprends bien tu as donc 2 cas de réception :
AT+CMGR=+33645644754\r\n>\x20\r\n
ou
AT+CMTI:\x20"SM",2

pointeur = strtok(buffer,"\x0D\x0A");
Tu récupéres le chaine après un \x0D\x0A (\r\n) donc
pointeur = ">\x20\r\n";

temporaire = pointeur; // inutile
temporaire = strtok(pointeur,"\x20");

temporaire = "\r\n";

if(strcmp(temporaire,"+CMTI:") == 0)
Je ne vois pas quand on peux passer là dedans ...

quand je fais :
Code:

1 2 3 //--- On extrait les informations des données du buffer pointeur = strtok(buffer,"\x0D\x0A"); printf("pointeur1 : %s\n",pointeur);
et que je reçois le 1er cas, je récupère : AT+CMGR=+33645644754

et ensuite lorsqu'il y a :
Code:

1 2 3 4 5 6 7 8 while(pointeur != NULL) { pointeur = strtok( NULL, "\x0D\x0A" ); if(pointeur != NULL) { printf("%s",pointeur); } }
là je récupère >\x20, je l'ai testé et cela fonctionne bien. Le problème intervient quand je rajoute :
Code:

1 2 3 4 5 6 7 8 9 temporaire = pointeur; temporaire = strtok(pointeur,"\x20"); printf("temporaire : %s",temporaire); printf("point : %s",pointeur); if(strcmp(temporaire,"+CMTI:") == 0) { printf("Message reçu"); // strcat(temporaire,"AT+CMGR="); }
Avec cette partie de code, je veux récupérer AT+CMTI lorsque l'on est dans le second cas, mais cela ne doit pas intervenir dans le 1er cas. Or lorsque je suis dans le premier cas, et que je rajoute cette partie de code, il repère bien AT+CMGR=+33645644754 mais sort de la boucle et ne repère plus >\x20.

euh...

d'abord quand tu fais :

Code:

1
2
3
4
 
 
    temporaire = pointeur;
    temporaire = strtok(pointeur,"\x20");

tu écrases temporaire, et tu ne modifies pas pointeur...

Ensuite, pourquoi faire compliqué quand on peut faire simple :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
//--- On extrait les informations des données du buffer
pointeur = strtok(buffer,"\x0D\x0A");
printf("pointeur1 : %s\n",pointeur);
 
 if(pointeur != NULL)
{    
    if ( *(pointeur+6) == 'I' ) )  /* chaine CMTI */
      {
      }
    else
      {
          temporaire = strtok ( NULL, "\x20" ); / Première partie de la 1ere chaine */
      }
}

14/05/2007, 14h03
fabpeden

Meric beaucoup pour ta solution, cela fonctionne très bien. Je ne connaissais pas *(pointeur + 4) == 'I'.

Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 pointeur = strtok(buffer,"\x0D\x0A"); printf("pointeur1 : %s\n",pointeur); if(pointeur != NULL) { temporaire = pointeur; temporaire = strtok(pointeur,"\x20"); if(strcmp(temporaire,"+CMTI:") == 0) { printf("Message reçu"); // strcat(temporaire,"AT+CMGR="); } }
Je crois que ton problème vient du fait que le séparateur trouvé est remplacé dans la chaîne d'origine par 0:
Le premier strtok renvoie l'adresse du début de la chaîne et met 0 à la place du séparateur dans la chaîne.
Le deuxième strtok, ne va pas chercher l'élément suivant, puisque son premier argument n'est pas NULL, mais réanalyse la chaîne à partir du début jusqu'à sa fin marquée dans le premier cas par le 0 du premier strtok qui est placé AVANT \x20.

Il serait peut être préférable que le premier strtok utilise \x20 comme séparateur. Tu peux alors savoir si tu es dans le cas 1 ou 2 et poursuivre l'analyse en conséquence.

14/05/2007, 14h09
fabpeden

oui je pense que c'est un problème d'une chaîne qui prend la place d'une autre. J'ai réussi à trouver une solution (cf. ci-dessus). Merci de votre aide!

Citation:

Envoyé par fabpeden

Meric beaucoup pour ta solution, cela fonctionne très bien. Je ne connaissais pas *(pointeur + 4) == 'I'.

c'est la définition même d'un pointeur...
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 char c ; char *p ; c = 'a' ; /* c est un carctère contenant la lettre a */ p = &c ; /* p est un pointeur pointant vers un caractère : c'est donc l'adresse d'un caractère */ /* donc */ printf ( " caractère : %c", *p ); /* *p est le contenu du pointeur p, donc de ce qui est à ll'adresse &c , donc le caractère 'a' */
et comme un pointeur est une adresse, les opérations arithmétiques sur les pointeurs sont possibles, et donc p+4 devient la quatrième adresse après celle de p, et *(p+4) devient donc le contenu de ce qui est pointé à la quatrième adresse après p..

Et n'oublie pas le flag :resolu: