Manipulation de Tableaux, structures en C++ [Résolu]

Signaler
Messages postés
47
Date d'inscription
jeudi 27 avril 2006
Statut
Membre
Dernière intervention
24 juin 2011
-
Messages postés
47
Date d'inscription
jeudi 27 avril 2006
Statut
Membre
Dernière intervention
24 juin 2011
-
Bonjour,
Je travaille actuellement sur un projet (en stage) dans lequel je dois envoyer deux trames: l'une d'entre elles faisant 88 et l'autre 161 octets.

J'ai dans un premier temps pensé à créer un tableau par trame :

class C_Construction    //classe permettant de construire mes trames
{
    public :
        unsigned char trame1[88];    // Mes tableaux
        unsigned char trame2[161];    //
        //J'ai utilisé le type "unsigned char" afin de garder mes 88 et 161 octets de données.
        ConstruireTrame1();
        ConstruireTrame2();
};

Mon idée était de passer des tableaux en paramètres dans différentes classes afin qu'elles les remplissent; exemple :

C_Construction::ConstruireTrame1()
{
    C_Header l_header;                            // classe permettant la création de l'entête
    unsigned char bHeader[20] ={0};        // déclaration d'un tableau
    l_header.ConstruireHeader( bheader );  
    // appel de la méthode ConstruireHeader (voir ci-dessous)    

    for(i=0; i<20; i++)            
    {    
        trame1[i] = (bHeader)[i];    //je recopie dans trame1 ce que j'ai rempli dans CHeader
    }
    ...
}

C_Header::ConstruireHeader( unsigned char *p_header )
{
    for( i=0; i<2; i++ )    // on remplit le tableau passé en argument ...
    {
            p_header[i] = ((unsigned char*)(&m_MessageId))[i];   
            //m_MessageId: variable membre de C_Header
    }
    ...
}

Ainsi, je remplissais bien mon tableau (trame1) grâce aux différentes classes (Header étant une classe parmis plusieurs)

Le problème est que certaines de mes valeurs composant la trame sont négatives ou bien sont supérieurs à 255 (comme par exemple "m_MessageId").

- Pour les valeurs supérieurs à 255, j'utilise plusieurs octets: la variable est donc décomposée, ce qui fonctionne mais qui est génant pour la récupération de la valeur, je m'explique :
Dans le cas de "m_MessageId", j'aurai pour une valeur de 500: p_header[0]= 1 et p_header[1]=244
car 500(décimal) vaut 1F4(héxa) : 1=1 et F4=244 --> Ce qui n'est pas très facile à manipuler, pour la récupération (au niveau du code).

- En ce qui concerne les valeurs négatives je n'ai pas de solutions... Car si je déclare mon tableau en "signed char", alors les valeurs ne pourront dépasser les 127.
Déclarer le tableau "float" changerai la taille des données(4x88 et 4x161) car j'envoie ensuite directement le tableau sur udp.

J'en suis venu à la conclusion qu'il fallait utiliser des structures.
Mon projet étant plutôt gros (27 classes), j'aimerai éviter de reprendre toutes mes classes en changeant les tableaux par des structures.

Est-ce possible de garder mes tableaux?
Si non, comment utiliser les structures (au niveau de la méthodologie)?
Je ne sais vraiment pas ce que je peux faire...
J'espère avoir été clair : n'hésitez pas à me poser des questions si vous n'avez pas tout compris ( ->pas facile d'expliquer un projet sur lequel on bosse depuis longtemps ^^)

D'avance merci!

2 réponses

Messages postés
2023
Date d'inscription
mardi 24 septembre 2002
Statut
Membre
Dernière intervention
28 juillet 2008
5
Imaginons un tableau de "unsigned char" ou "char", ca ne change rien. Ca n'a d'influence que si tu affiches les données a l'écran, ou si tu fais des opérations mathématiques.

Imaginons que les 4 premiers octets de ton tableau sont en fait un int qu'on a copier dedans.

unsigned char tab[10] = { 0 };
int value = 44444;

memcpy((void*)tab, &value, sizeof(int)); <= la je copie dans le tableau le contenu des 4 octets de l'entier)

D'après ce que j'ai compris, tu voudrais donc récupérer facilement la valeur. Mais si tu sais ou se trouvent les valeurs ya pas de pb. Par exemple:

int valeur_stockee = *(int*)&tab[0]; // par exemple

Ou la meme chose avec la fonction de memcpy;

int valeur_stockee;
memcpy((void*)&valeur_stockee, (const void*)&tab[0], sizeof(int)); // note: tab = &tab[0];

De meme pour les valeurs signés, le type que tu donnes a un tableau ne modifie pas la valeur des bits, seulement la facon dont les octets sont gérés par les fonctions math ou d'affichage.
char octet *(char*)&tab[5]; // c'est pas équivalent à char octet tab[5] <= car la on a conversion des types.

Le plus intuitif restant donc:
memcpy((void*)&octet, (const void*)&tab[5], sizeof(char)); // on copie les bits de tab[5] dans octet.

J'espère avoir répondu un peu a ta question :)
Messages postés
47
Date d'inscription
jeudi 27 avril 2006
Statut
Membre
Dernière intervention
24 juin 2011

Parfait!!
Je ne voyais pas du tout la chose de cette façon!!!
En tout cas merci beaucoup!!
A+