Problème déplacement pointeur

Version imprimable

Bonjour, mon problème est le suivant:
je dois parcourir une zone mémoire qui ma 'été préalablement renvoié via le prototype suivant

Code:

void* fonction(void);

Je ne comprend pas pourquoi les lignes 7 & 8 font plantées mon programmes.
Le problème vient-il d'un cast "oublié", d'une grossière erreur de ma part, ... ?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 int nombreSequence(void* ptr){ char *pBalade=(char*)ptr; unsigned short offset=*(unsigned short*)pBalade; int cpt=1; while(offset!=0){ pBalade=pBalade+offset; offset=*(short*)(pBalade); cpt++; } return cpt; } }
Le plus bizarre, c'est que j'ai reussi a "contourné" le problème en remplaçant ces 2 lignes par

Code:

offset=*(unsigned short*)(pBalade+offset);

mais je voudrai comprendre pourquoi avant ce ne fonctionnait pas pour ne plus refaire l'erreur ! :)

Merci d'avance

13/11/2014, 19h19
Obsidian

Bonjour et bienvenue,

Ouille ! Pardon de te l'annoncer de but en blanc mais ton programme a l'air globalement incorrect d'un bout à l'autre. Qu'est censée faire ta fonction exactement ?

En premier lieu, ton code ne nous montre pas de quelle manière tu transmets le pointeur renvoyé par « fonction() » à « nombreSequence() ». Ensuite, la façon dont tu charges offset a l'air douteuse : de cette manière, tu considères que les premiers octets pointés par le pointeur que tu as reçu contiennent directement un unsigned short au format natif. Je soupçonne ton programme de pointer en réalité une chaîne de caractères. Si c'est le cas, il faudra la lire et interpréter ce qui est écrit pour en déduire une valeur, par exemple avec strtol().

Ensuite, dans la bouble, tu ajoutes itérativement la valeur offset à ton pointeur, si bien que même si offset ne change jamais, ton pointeur va avancer continuellement et ce n'est probablement pas ce que tu cherches à faire. Si c'est une liste chaînée que tu exploites, ça se fait soit en chargeant directement le nouveau pointeur, soit en utilisant effectivement un offset par rapport à une adresse de base, qu'il faut alors conserver.

Citation:

Le plus bizarre, c'est que j'ai reussi a "contourné" le problème en remplaçant ces 2 lignes par

Cela ne fonctionne que par accident : tant que l'adresse résultante reste dans l'espace d'adressage de ton processus, le micro-processeur n'y trouvera rien à redire, même si les données que tu y liras n'auront aucun sens.
13/11/2014, 19h40
diogene

Je pense que son bloc mémoire est structuré en segments, chaque segment étant composé d'un en-tête indiquant la longueur du segment en bytes sur un unsigned short, suivi des données du segment. Son programme compte le nombre de segments, le dernier segment étant suivi par convention d'un pseudo-segment de longueur nulle.

Ce que je ne vois pas, c'est pourquoi le programme après modification marche alors que le programme sans cette modification ne marche pas (ce qui me fait penser que le problème est peut être ailleurs) .
13/11/2014, 21h01
Obsidian

Citation:

Envoyé par diogene

Ce que je ne vois pas, c'est pourquoi le programme après modification marche alors que le programme sans cette modification ne marche pas (ce qui me fait penser que le problème est peut être ailleurs) .

C'est-à-dire que dans le premier cas, pBalade est mis à jour à chaque itération. Dans le second, seul offset l'est. Pour le reste, impossible de trancher mais comme la boucle est faite pour s'arrêter dès lors qu'offset devient nul, cela peut se produire dès la fin de la première itération.
14/11/2014, 16h25
Sve@r
Citation:

Envoyé par algra

Code:

unsigned short offset=*(unsigned short*)pBalade;

Bonjour

Cette ligne est terrifiante. Comme le dit Obsidian, ça signifie que la zone mémoire pointée par "pBalade" contient un short claqué direct en binaire. Es-tu sûr de ça ? Cette zone mémoire t'a été renvoyée par "fonction()" mais on ne sait pas ce qu'elle fait ni comment elle travaille.

Citation:

Envoyé par algra

Le plus bizarre, c'est que j'ai reussi a "contourner" le problème en remplaçant ces 2 lignes par

Code:

offset=*(unsigned short*)(pBalade+offset);

mais je voudrais comprendre pourquoi avant ce ne fonctionnait pas pour ne plus refaire l'erreur

J'ai deux hypothèses
1. la valeur *(pBalade + offset) est supérieure à 32768. Dans ce cas, casté en "short" elle devient négatif et ton offset recule au lieu d'avancer.
2. le vrai problème est bien plus profond et que tu es en face d'un "comportement indéterminé", comportement induit par une action illégale (bien souvent à base de pointeurs pointant vers des zones ne correspondant pas à ce qu'il faudrait qu'elles soient). Et dans ce cas, le comportement est réellement "imprévisible" dans le plus pur sens du terme. C'est à dire que le programme peut même "sembler" fonctionner correctement jusqu'au moment où tu modifies un truc totalement minime (remplacer un "unsigned short" par un "short" par exemple) et là tout explose.
J'espère que ce n'est que le cas n° 1 mais tant qu'on ne connaitra pas mieux "fonction", on ne pourra pas t'en dire plus...
14/11/2014, 16h31
Médinoc

Ce qu'il nous faudrait, c'est connaître le vrai format des données que tu traites. Et si ce n'est pas énorme, un échantillon.
15/11/2014, 10h53
algra
Effectivement, je dois être plus clair. le fonction getText04(void) retourne une zone memoire. celle-ci contient un certain de nombre de sequence, qui elles sont configurées de cette manière:
- unsigned short = offset
- unsigned char = position du morceau(1= premier morceau, ...)
- unsigned char = la longeur de ce morceau
- une suite de caratère non termine par '\n', constiuant le morceau du texte
Si l'offset = 0, cela signifie que c'est la dernière séquence.

La position du morceau n'est pas primordiale (on peut la calculer à partir des séquences précédentes) mais ça gêne pas. Et c'est pareil pour "offset" (qui est égal à la taille de la zone donc la taille des infos plus la longueur du morceau).
Mais ton morceau fera obligatoirement moins de 256 caractères vu que sa longueur est codée sur un unsigned char. Ce n'est pas un peu court pour un morceau (je présume "de musique") ??? Si c'est du midi ça ira "à peu près" mais si c'est du mp3 ça ne durera même pas 3 secondes. Et c'est dommage, tu n'as pas d'indication sur le point de départ exact de ton morceau (il commencera à "début de zone + sizeof (unsigned short) + sizeof(unsigned char) + sizeof(unsigned char) octets"...)

J'aime bien ta "suite de caractères non terminée par un '\n'". Et par quoi d'autre n'est-elle pas terminée cette suite ??? :lol:

Sinon voici une technique qui te permet de récupérer "d'un coup" les infos de ta zone
Code:

1 2 3 4 5 6 7 8 9 10 11 typedef struct { unsigned short offset; unsigned char num; unsigned char lg; } t_morceau; t_morceau zone; memcpy(&zone, pBalade, sizeof t_morceau); printf("offset=%hu\n", zone.offset); printf("num=%hu\n", zone.num); printf("lg=%hu\n", zone.lg);

15/11/2014, 12h05
algra
Ce n'est pas de la musique :) c'est un "jeu de piste", un texte a été découpe en séquence et je dois reconstitué ce texte grâce a ces séquences
Oui effectivement, j'avais crée une structure:
Code:

1 2 3 4 5 6 typedef struct Morceau { char * morceau; unsigned int posMorceau; unsigned int longeur; } Morceau;
Le but de cette fonction est de calcule le nombre de séquences totales ce qui me permettra de reconstitué le texte final par la suite :)
15/11/2014, 12h36
Sve@r

Citation:

Envoyé par algra

Oui effectivement, j'avais crée une structure:

Oui mais si tu regardes bien la mienne, je la calque exactement selon le schéma de la zone mémoire. Comme ça, en un seul memcpy() et tout est copié au bon endroit...
15/11/2014, 13h55
Médinoc

Attention avec les structures et les memcpy, avec les histoires d'alignement et de bourrage. Même si ici, ça a l'air bon pour la plupart des plate-formes.
15/11/2014, 14h31
Sve@r

Zut, t'as raison, ça m'était sorti de la tête.
@algra: ne tient pas compte de mes deux derniers posts, le danger exprimé par Medinoc existe. Certains compilos rajoutent en effet des octets bidons entre les éléments d'une structure pour "aligner" la structure sur des mots machine. Ca optimise l'accès à la structure (plus spécialement quand on a des tableaux de structures) mais la structure compilée n'est plus le reflet de la zone mémoire qu'on imagine.

Désolé, finalement vaut mieux que tu restes comme t'avais fait en récupérant les items un à uns...
15/11/2014, 17h41
algra

Citation:

Envoyé par Sve@r

Désolé, finalement vaut mieux que tu restes comme t'avais fait en récupérant les items un à uns...

Ok :D
Je me demande encore pourquoi je n'arrive pas a déplacé mon pointeur :weird:

Citation:

Envoyé par algra

Je me demande encore pourquoi je n'arrive pas a déplacé mon pointeur :weird:

Aucune idée, on n'est pas certain de ta zone

De mon coté, j'ai fait un petit test rapide d'écriture et de relecture et ça fonctionne nickel. Mais faut être hyper rigoureux dans ses décalages (j'avais oublié l'unsigned char équivalent à la variable lg dans offset => j'ai dégusté ma race !!!)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
#include <stdio.h>
#include <string.h>
 
void remplir(char *zone, char *text[])
{
	char *pt;
	unsigned char num;
	unsigned short offset;
	unsigned char lg;
 
	for (num=1,pt=zone; *text != NULL; text++, num++)
	{
		// Calcul longueur texte et offset
		lg=strlen(*text);
		offset=*(text+1) != NULL ?sizeof(unsigned short) + sizeof(unsigned char) + sizeof(unsigned char) + lg :0;
		printf("écriture: pt=%p, num=%d, offset=%d, lg=%d, text=[%s]\n", pt, num, offset, lg, *text);
 
		// Copie offset
		memcpy(pt, &offset, sizeof(unsigned short));
		pt+=sizeof(unsigned short);
 
		// Copie n° en cours
		memcpy(pt, &num, sizeof(unsigned char));
		pt+=sizeof(unsigned char);
 
		// Copie longueur
		memcpy(pt, &lg, sizeof(unsigned char));
		pt+=sizeof(unsigned char);
 
		// Copie texte
		memcpy(pt, *text, lg);
		pt+=lg;
	}
}
 
void lire(char *zone)
{
	char *pt;
	unsigned char num;
	unsigned char lg;
	unsigned short offset;
	char data[256];
	do
	{
		pt=zone;
 
		// Récupération offset
		offset=*(unsigned short*)pt;
		pt+=sizeof(unsigned short);
 
		// Récupération n° en cours
		num=*(unsigned char*)pt;
		pt+=sizeof(unsigned char);
 
		// Récupération longueur
		lg=*(unsigned char*)pt;
		pt+=sizeof(unsigned char);
 
		// Récupération datas
		memcpy(data, pt, lg);
		data[lg]='\0';
		printf("lecture: pt=%p, num=%hu, data=[%s]\n", zone, num, data);
 
		// Décalage de la zone (et non pas de pt, attention !!!)
		zone+=offset;
	} while (offset != 0);
}
 
unsigned char nb_zone(char *zone)
{
	unsigned char nb;
	unsigned short offset;
	for (nb=1; (offset=*(unsigned short*)zone) != 0; nb++, zone+=offset);
	return nb;
}
 
int main()
{
	char zone[1024];
	char *mots[]={"Hello", "World", "il", "fait", "beau !!!", NULL};
	remplir(zone, mots);
	lire(zone);
	printf("Nombre morceaux: %hu\n", nb_zone(zone));
}

Et ma fonction nb_zone() déplace correctement le pointeur et compte bien le bon nombre...