Discussion :

[vinowan]

bonjour,

en essayant de compacter mon code je suis arriver a une solution qui fonctionne mais je ne comprend pas bien pourquoi, bizarre direz vous.

voila j'utilise une procedure qui convertit un code decimale (ici unsigned short donc 16 bit) en code ascii, je passe en argument la valeur decimale, la procedure crée un tableau de 3 valeur contenant les code ascii pour centaine, dizaine et unité.
la procedure renvoi alors l'adresse du tableau.

voici cette procedure:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
//procedure qui renvoi un pointeur sur un tableau
 
unsigned char* conversion_short_Ascii_C_D_U (unsigned short valeur_decimale) {
 
unsigned char tbl[3];
unsigned char centaine;
unsigned char dizaine;
unsigned char unite;
 
  	centaine = valeur_decimale / 100;
	dizaine = (valeur_decimale % 100 ) / 10;
	unite = (valeur_decimale % 100 ) % 10;
 
	centaine = conv_Ascii (centaine);
	dizaine = conv_Ascii (dizaine);
	unite = conv_Ascii (unite);
 
	if (centaine == '0'){
		centaine = ' ';
		if (dizaine == '0') {
			dizaine = ' ';
		}
	}	
 
	tbl[0] = centaine;
	tbl[1] = dizaine;
	tbl[2] = unite;
 
	return & tbl;
}

dans un premier temps j'utilisait un pointeur pour recuperer ces trois valeur, comme ceci.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
unsigned char *pt_sur_char;
 
   	pt_sur_char = conversion_short_Ascii_C_D_U (123);
	tbl_buffer_EA [0] = *pt_sur_char ; //centaine
             pt_sur_char ++;
	tbl_buffer_EA [1] = *pt_sur_char ; //dizaine
             pt_sur_char ++;
	tbl_buffer_EA [2] = *pt_sur_char ; //unité

mais en testant deux trois truc, j'ai vu que je pouvais aussi l'ecrire comme ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
unsigned char *pt_sur_char;
 
   	pt_sur_char = conversion_short_Ascii_C_D_U (123);
	tbl_buffer_EA [0] = pt_sur_char[0] ; //centaine
	tbl_buffer_EA [1] = pt_sur_char[1] ; //dizaine
	tbl_buffer_EA [2] = pt_sur_char[2] ; //unité

les resulats sont bon mais est ce correcte d'utiliser cette syntaxe.

je ne comprend pas pourquoi j'ai une erreur de compilation si je definit
unsigned char pt_sur_char [3]
comme tableau au lieu d'un pointeur comme ceci:
unsigned char *pt_sur_char;

quand je fais
pt_sur_char = conversion_short_Ascii_C_D_U (123);
je renvoi bien une adresse à un tableau mais cela ne veux pas se compiler.

pouvez vous m'eclairer la dessus?

merci de votre aide.

[pfeuh]

Salut,

Un 16 bits non signé va de 0 à 65535, donc trois digits ne suffiront pas, tu risques des débordements.

Le tableau tbl n'existera plus après le retour de la fonction conversion_short_Ascii_C_D_U, d'où génération probable d'une erreur de segmentation. Deux solutions, soit créer le tableau avec un malloc, mais c'est lourd, car il faut penser à le détruire après utilisation, soit tu passes en paramètre à ta fonction l'adresse du tableau de réception.

Faire un tableau de unsigned char pour quelque chose qui va être affiché, n'est pas une bonne idée.

Pour répondre à ta question, quand tu fais return &tbl, tu renvoies un pointeur (vers quelque chose qui n'existe plus, résultat indéterminé). J'avoue ne pas avoir vraiment compris ta question.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <stdio.h>
 
void conversion_short_Ascii_C_D_U (unsigned short valeur_decimale, char* retbuf)
{
    size_t index;
    size_t max_index;
    unsigned short divisor;
 
    // boucle de construction de la chaine
    max_index = 5; // 5 digits max pour un u16
    divisor = 10000; // plus grande puissance de 10 dans un u16
    index = 0;
    while(index < max_index)
    {
        // on suppose que les caracteres "0123456789" se suivent
        retbuf[index] = valeur_decimale / divisor + '0';
        valeur_decimale = valeur_decimale % divisor;
        divisor = divisor / 10;
        index++;
    }
    retbuf[index] = 0;
    // boucle d'elimination des zero d'entete
    max_index = 4; // si le dernier digit est un zero on le garde
    index = 0;
    while(index < max_index)
    {
        if(retbuf[index] == '0')
            retbuf[index] = ' ';
        else
            break;
        index++;
    }
}
 
int main(void)
{
    char printbuf[6];
 
    conversion_short_Ascii_C_D_U (65535, printbuf);
    printf("%s\n", printbuf);
    conversion_short_Ascii_C_D_U (123, printbuf);
    printf("%s\n", printbuf);
    conversion_short_Ascii_C_D_U (0, printbuf);
    printf("%s\n", printbuf);
 
    return 0;
}

[Melem]

quand je fais
pt_sur_char = conversion_short_Ascii_C_D_U (123);
je renvoi bien une adresse à un tableau mais cela ne veux pas se compiler

Bin non tu renvois juste l'adresse du premier élément du tableau. Voir FAQ.

je ne comprend pas pourquoi j'ai une erreur de compilation si je définis
unsigned char pt_sur_char [3]
comme tableau au lieu d'un pointeur comme ceci:
unsigned char *pt_sur_char;

Parce que dans le premier cas pt_sur_char est un tableau et non pointeur. Dans le deuxième cas, pt_sur_char est bel et bien un pointeur, du bon type, donc ça marche.

[vinowan]

Merci pour votre aide,

j'ai fais passer le tableau en argument (ou plutot l'adresse du tableau) afin d'utiliser directement le tableau dans la fonction comme "pfeu" la expliquer.

cela fonctionne bien "normalement direz vous",

comme je ne programme pas cette applicatio pour windows mais pour un microcontrolleur (8051) rien ne venais modifier le tableau detruit en sortant de la fonction car j'utilait directement les données, du le fait que cela fonctionait je ne m'était pas posser de question mais sous windows j'aurais surement des probleme et pas fazcile a debuger je pense.

donc merci mille fois pour votre aide. je vais faire un tour sur la faq car j'ai encore un peu de mal avec le fait de passe un tableau en argument.