Problème d'affectation de variables

Version imprimable

19/06/2007, 10h55
jamescook

Problème d'affectation de variables

Bonjour,
j'ai un problème depuis assez longtemps sur l'affectation de variable.
j'ai créer pas mal de structure avec principalement des doubles et je dois affecté la valeur des variables d'une structure par les valeurs de l'autres du genre :

variable->Rb=parametre->PARAM_C;

Mais voila la variable n'est pas affecté. la valeur dans le PARAM_C est 100000.
après cette ligne de code la valeur de Rb est 1.341997973E-307.
il faut savoir que PARAM_C est déclarer en float et Rb en double.

Ce problème apparait sur plusier variable et j'ai l'impression que c'est un problème de mémoire.

Si qq avait une solution sur ce bug je suis preneur
19/06/2007, 11h18
bandit boy
Salut
as tu essayé ?
Code:

1 2 variable->Rb = (double)parametre->PARAM_C;
19/06/2007, 12h01
jamescook

si c'était si simple

Non j'ai essayé de mettre (double)
cela ne change rien
j'ai meme essayé de déclarer les deux struct avec des variables floats toutes les deux
Marche pas il y a un problème memoire mais je sais pas lequel
19/06/2007, 12h58
jamescook

/****c'était bien un problème de memoire car j'avais bcp de structure. En les déclarant toutes les structures par new plus de problème.******/

Erreur toujours pas resolu vraiment c'est une grosse prise de tete
Les deux variables sont des float

variable->Rb contient 9.99999999959E+11
je l'affecte à parametre->PARAM_C :
parametre->PARAM_C=variable->Rb;

parametre->PARAM_C contient après : -1.1102230246E-16

La j'y comprends plus rien si qq pouvait m'éclairer car je suis pommer
19/06/2007, 17h42
jamescook

1 pièce(s) jointe(s)

j'ai fait tourner le CodeGuard et voila se que j'obtiens malheureusement j'y comprends rien

QQ peut m'aider

Pièce jointe 15342
19/06/2007, 18h41
diogene

On n'a pas assez d'éléments pour t'aider. Il est évident que le problème de base n'est pas l'affectation en elle-même
19/06/2007, 23h24
jamescook

Pour plus de details: j'utilise plusieurs structures dans un fichier struct.h
j'aloue toutes les structures en variables globales dans la form initiale avec l'instruction new.
Puis dans le prog je dois affecter les valeurs d'une structure à une autre

Je sais pas trop qu'est ce que vous attendez comme info en plus donc n'hesitez pas a me le dire je vous donnerais toutes les infos necessaire car la je suis bien bloqueé et je suspecte une mauvaise gestion des fichiers. Mais ou????
Merci pour votre aide
20/06/2007, 00h10
Crayon

Étant donné que tu utilises new il serais peut-être mieux de faire des classes plutôt que des structures. Il faut profiter au max de l'orienté objets. En plus dans le constructeur tu peux initialiser tous les attributs de ta classe, vive le C++!
20/06/2007, 08h20
rtg57

Bonjour,

pouvez-vous essayer d'utiliser le débogage CPU, afin de voir ce qui se passe réellement au niveau des instructions machines.
Une instruction

Code:

parametre->PARAM_C=variable->Rb;

est facile à déboguer en langage assembleur. Ce n'est qu'une copie d'une case mémoire vers une autre case mémoire.
Envoyez-nous une copie écran de la fenêtre CPU au moment de l'exécution de cette ligne...
20/06/2007, 08h37
jamescook

1 pièce(s) jointe(s)

Bonjour, voila l'imprime ecran CPU mais j'ai pas l'impression que ce soit l'affectation elle meme qui pose probleme. Mais je suis completement perdu

Merci pour votre aide

Pièce jointe 15382
20/06/2007, 10h09
rtg57

Re-bonjour,

c'est étrange la façon dont le compilateur a traduit la ligne

Code:

Variablecan->Rb = parametrecan->PARAM_C

Il utilise une procédure

Code:

call CG_DA_EPY()

dont le rôle est, je suppose, de convertir les formats de données. Il y a de fortes chances que le problème se situe à ce niveau.
Et 12 instructions assembleur pour faire une copie d'une case mémoire dans une autre, c'est lourd.
Il faudrait éviter cela: est-ce que Rb est du même type que PARAM_C ?
Si ce n'est pas le cas, il faudrait adapter les structures pour qu'elles soient compatibles.( Je ne sais pas si je suis clair :? )
Copier une variable dans une autre, ce n'est pas compliqué, dans la mesure où elles occupent le même nombre d'octets.
Au pire, il y a des instructions comme memmove ou memcpy, qui copient les octets mémoires d'une adresse vers une autre sans se soucier de la taille. Attention, on s'approche de la machine, et il n'y a plus de sécurité. Le plantage vous attend au tournant.

@+
20/06/2007, 10h53
diogene

Code:

call CG_DA_EPY()

doit être une instruction mise par CodeGuard

Si on n'a pas d'éléments du code, on ne peut rien faire, ce serait de la divination.
20/06/2007, 11h09
jamescook

les deux variables sont déclarer en float.
je pense pas que ce soit la le probleme, je me pencherais plus vers un code inadapté, un lien

le code est trés long et il y a plusieur fichier je vous montre la declaration des structures, les créations et la ligne de code :

declaration:

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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
 
/---------------------------------------------------------------------------
//-----------Structure des PARAMETRES envoyés sur le bus CAN ----------------
//---------------------------------------------------------------------------
 
typedef struct {
        int SN;
        int Version;
        unsigned char Vion;
        unsigned char Facq;
        unsigned char TImoy;
        unsigned char FCG;
        unsigned char MCG;
        unsigned char Pcal;
        unsigned char TypT;
        unsigned char TTmoy;
        unsigned char TdecT;
        float KHT;
        float KQ;
        float KP12;
        float KM12;
        float Rb;
        float Rh;
        float KzBB0;
        float KzBB1;
        float KzBB2;
        float KzBB3;
        float KzBB4;
        float KzBB5;
        float KgBB0;
        float KgBB1;
        float KgBB2;
        float KgBB3;
        float KzBH0;
        float KzBH1;
        float KzBH2;
        float KzBH3;
        float KzBH4;
        float KzBH5;
        float KgBH0;
        float KgBH1;
        float KgBH2;
        float KzHB0;
        float KzHB1;
        float KzHB2;
        float KzHB3;
        float KzHB4;
        float KzHB5;
        float KgHB0;
        float KgHB1;
        float KzHH0;
        float KzHH1;
        float KzHH2;
        float KzHH3;
        float KzHH4;
        float KzHH5;
        float KgHH0;
} VARIABLECAN;
//---------------------------------------------------------------------------
//------------------------------ Fin Struct --------------------------------
//---------------------------------------------------------------------------
 
//---------------------------------------------------------------------------
//-----------Structure des PARAMETRES envoyés sur le bus CAN ----------------
//---------------------------------------------------------------------------
 
typedef struct {
        unsigned char PARAM_0[4];
        unsigned char PARAM_1[4];
        unsigned char PARAM_2[4];
        unsigned char PARAM_3[4];
        unsigned char PARAM_4[4];
        unsigned char PARAM_5[4];
        unsigned char PARAM_6[4];
        unsigned char PARAM_7[4];
        float PARAM_8;
        float PARAM_9;
        float PARAM_A;
        float PARAM_B;
        float PARAM_C;
        float PARAM_D;
        float PARAM_E;
        float PARAM_F;
        float PARAM_10;
        float PARAM_11;
        float PARAM_12;
        float PARAM_13;
        float PARAM_14;
        float PARAM_15;
        float PARAM_16;
        float PARAM_17;
        float PARAM_18;
        float PARAM_19;
        float PARAM_1A;
        float PARAM_1B;
        float PARAM_1C;
        float PARAM_1D;
        float PARAM_1E;
        float PARAM_1F;
        float PARAM_20;
        float PARAM_21;
        float PARAM_22;
        float PARAM_23;
        float PARAM_24;
        float PARAM_25;
        float PARAM_26;
        float PARAM_27;
        float PARAM_28;
        float PARAM_29;
        float PARAM_2A;
        float PARAM_2B;
        float PARAM_2C;
        float PARAM_2D;
        float PARAM_2E;
        float PARAM_2F;
        float PARAM_30;
        float PARAM_31;
        float PARAM_32;
        float PARAM_33;
        float PARAM_34;
        float PARAM_35;
        float PARAM_36;
        float PARAM_37;
        float PARAM_38;
        float PARAM_39;
        float PARAM_3A;
        float PARAM_3B;
        float PARAM_3C;
        float PARAM_3D;
        float PARAM_3E;
        float PARAM_3F;
        unsigned char RECUP_0_7;
        unsigned char RECUP_8_F;
        unsigned char RECUP_10_17;
        unsigned char RECUP_18_1F;
        unsigned char RECUP_20_27;
        unsigned char RECUP_28_2F;
        unsigned char RECUP_30_37;
        unsigned char RECUP_38_3F;
 
} PARAMCAN;

les créations :

Code:

1
2
3
 
VARIABLECAN *variablecan= new VARIABLECAN;
PARAMCAN *parametrecan= new PARAMCAN ;

le remplissage des structures sachant que PARAMCAN est deja rempli :
Appel par ue fonction :

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
 
void ChargeParamVariable(PARAMCAN* parametrecan,VARIABLECAN* variablecan)
        {
        variablecan->SN=parametrecan->PARAM_0[3]*256+parametrecan->PARAM_0[2];
        variablecan->Version=parametrecan->PARAM_0[1]*256+parametrecan->PARAM_0[0];
        variablecan->Vion=parametrecan->PARAM_1[0];
 
        variablecan->Facq=parametrecan->PARAM_2[3];
        variablecan->TImoy=parametrecan->PARAM_2[2];
        variablecan->FCG=parametrecan->PARAM_2[1];
        variablecan->MCG=parametrecan->PARAM_2[0];
 
        variablecan->Pcal=parametrecan->PARAM_3[0];
 
        variablecan->TypT=parametrecan->PARAM_4[1];
        variablecan->TTmoy=parametrecan->PARAM_4[0];
 
        variablecan->TdecT=parametrecan->PARAM_6[0];
 
        variablecan->KHT=parametrecan->PARAM_8;
        variablecan->KQ=parametrecan->PARAM_9;
        variablecan->KP12=parametrecan->PARAM_A;
        variablecan->KM12=parametrecan->PARAM_B;
        variablecan->Rb=parametrecan->PARAM_C;
        variablecan->Rh=parametrecan->PARAM_D;
 
        variablecan->KzBB0=parametrecan->PARAM_10;
        variablecan->KzBB1=parametrecan->PARAM_11;
        variablecan->KzBB2=parametrecan->PARAM_12;
        variablecan->KzBB3=parametrecan->PARAM_13;
        variablecan->KzBB4=parametrecan->PARAM_14;
        variablecan->KzBB5=parametrecan->PARAM_15;
        variablecan->KgBB0=parametrecan->PARAM_16;
        variablecan->KgBB1=parametrecan->PARAM_17;
        variablecan->KgBB2=parametrecan->PARAM_18;
        variablecan->KgBB3=parametrecan->PARAM_19;
 
        variablecan->KzBH0=parametrecan->PARAM_1C;
        variablecan->KzBH1=parametrecan->PARAM_1D;
        variablecan->KzBH2=parametrecan->PARAM_1E;
        variablecan->KzBH3=parametrecan->PARAM_1F;
        variablecan->KzBH4=parametrecan->PARAM_20;
        variablecan->KzBH5=parametrecan->PARAM_21;
        variablecan->KgBH0=parametrecan->PARAM_22;
        variablecan->KgBH1=parametrecan->PARAM_23;
        variablecan->KgBH2=parametrecan->PARAM_24;
 
        variablecan->KzHB0=parametrecan->PARAM_28;
        variablecan->KzHB1=parametrecan->PARAM_29;
        variablecan->KzHB2=parametrecan->PARAM_2A;
        variablecan->KzHB3=parametrecan->PARAM_2B;
        variablecan->KzHB4=parametrecan->PARAM_2C;
        variablecan->KzHB5=parametrecan->PARAM_2D;
        variablecan->KgHB0=parametrecan->PARAM_2E;
        variablecan->KgHB1=parametrecan->PARAM_2F;
 
        variablecan->KzHH0=parametrecan->PARAM_34;
        variablecan->KzHH1=parametrecan->PARAM_35;
        variablecan->KzHH2=parametrecan->PARAM_36;
        variablecan->KzHH3=parametrecan->PARAM_37;
        variablecan->KzHH4=parametrecan->PARAM_38;
        variablecan->KzHH5=parametrecan->PARAM_39;
        variablecan->KgHH0=parametrecan->PARAM_3A;
        }

20/06/2007, 15h48
jamescook

Grrrrrrrrrrrrrrrrrr
Après deux jours de recherche intensive, j'ai fini par avoir une version stable mais je ne comprend pas pourquoi
Mes structures étaient déclarés dans un struct.h et l'appel se faisait dans le struct.c
Si je faisais l'appel directement dans l'Unit Principal le CodeGuard m'avertissait d'un debordement.
J'ai donc essayé de déclaré les structs dans l'entete de l'unit principal et de faire la declaration dans le point c et eureka c'est stable.
Mais je ne vois pas pourquoi ca plantait avant (beug de borland ou Beug des liens)
Par contre est ce que qq a le lien pour les mises a jours du BCB 6.0 car depuis que borland a mis en place la version 7, j'arrive pas a accedé au mise a jour du Builder 6.0
21/06/2007, 12h08
diogene

Citation:

Après deux jours de recherche intensive, j'ai fini par avoir une version stable mais je ne comprend pas pourquoi

Je crains pour toi que cette stabilité soit "provisoire" si tu n'as pas trouvé de raisons à ce problème.