Programmation Générique en C

Bonjour à tous,

Voilà j'ai un programme qui fonctionne (pour l'instant) très bien mais ce, avec un seul et unique type de données, un struct déclaré comme ceci :
Code:

1 2 3 4 5 typedef struct{ uint16_t type; uint64_t word; } obj;
J'aurais aimé faire en sorte de remplacer le uint64_t word par deux tableaux de type uint8_t de longueurs variables. Certains me diront que je n'ai qu'a stocker deux variables de type uint8_t* qui seront allouées dynamiquement à l'exécution mais cela me fait stocker deux pointeurs supplémentaires, ce que je ne souhaite pas. La mémoire utilisée est d'une importance cruciale pour moi.

J'ai cherché sur internet comment faire ceci sans avoir à dupliquer dupliquer mon code pour toutes les tailles de tableau possibles (dans une certaine limite), je ne souhaite pas traiter séparément chaque cas correspondant à une longueur x et y de mes tableaux. Je suis tombé sur ce tuto de programmation générique en C :
http://cecilsunkure.blogspot.de/2012...ming-in-c.html

J'ai donc écris ce code dans un fichier obj.h (j'ai changé les noms de variables et structures):
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 #ifndef DEF_OBJ #define DEF_OBJ #include <stdio.h> #include <stdlib.h> #include <stdint.h> #define DECLARE_TAB(A,B) \ typedef struct _LINE_##A##_##B \ { \ uint8_t tab1[A]; \ uint8_t tab2[B]; \ } LINE_##A##_##B; #define DECLARE_OBJ(A,B) \ typedef struct _OBJ \ { \ uint16_t type; \ LINE_##A##_##B obj; \ } OBJ; \ \ OBJ *CREATE_OBJ(A,B); #define CREATE_OBJ(A,B) \ OBJ *CREATE_OBJ(A,B) \ { \ return (OBJ*)malloc(sizeof(DECLARE_OBJ(A,B)));\ } #endif
Ma première question est donc : puis-je utiliser le type OBJ dans du code qui n'est pas du macro, c'est à dire qui n'est pas executé par le préprocesseur ? Ou suis-je obligé de réécrire tout mon programme (ce que je ne ferais pas) dans ce style macro si je veux pouvoir l'utiliser ?
Ma deuxième question est : ce code est-il valide d'après vous ?

Je vous remercie encore de votre aide et vous souhaite une excellente journée et/ou soirée ;)

Alors je vais répondre a ta derniere question non ce genre de code n'est pas valide pour moi , rien ne empeche mais je trouve que c'est abusé les macro , en plus pour faire des struct :roll:
Pour la fonction , il y a le inline , la ça me semble un peu dangereux de faire une fonction sur du macro elle n'est pas appelé , elle ne fait que la creer .

Déjà as tu pensé a utiliser le mot clé union ou les comparaison/decage bit a bit , qui permet justement ecrire/de comparer sur chaque bit (ou chaque octet).

Merci de ta réponse Kennagi :)

Alors, quand tu dis que ce code n'est pas valide pour toi, tu veux dire que tu n'écrirais pas ce code si c'était ton programme, mais que potentiellement il marche quand même ?

L'idée du code que j'ai posté est juste de présenter les struct que je souhaite créer, si le code marche j'en viendrais à créer toutes les fonctions associées pour la manipulation de ces struct. Je veux juste savoir si je peut utiliser le type OBJ, qui enveloppe le type "dynamique" LINE_##A##_##B, dans une fonction qui n'est pas du macro. En réalité, j'ai essayé d'utiliser ce type dans ma fonction main() (avec un #include "obj.h") mais j'obtiens juste une erreur du compilateur, "type non défini" :(

J'ai bien pensé au mot clé inline mais celui-ci ne résout pas mon problème, à savoir que je souhaite écrire un seul code pour une multitude de types sans avoir a passer par des void*. Le problème de l'union, c'est que l'espace utilisé est celui du plus grand type stocké. Donc si je déclare un union contenant par example uint8_t t1[1], uint8_t t2[2], ..., uint8_t t64[64], peu importe le tableau tx que j'utilise, mon union utilisera en mémoire 64*sizeof(uint8_t) :(

Citation:

Alors, quand tu dis que ce code n'est pas valide pour toi, tu veux dire que tu n'écrirais pas ce code si c'était ton programme, mais que potentiellement il marche quand même ?

C'est exactement ça , je l'écrirais jamais , mais le code marche.
Après je te déconseille ce genre écriture.

Pas sur de comprendre ton probleme de union mais :
Code:

1 2 3 4 5 6 7 8 9 10 11 typedef union { char type[2]; short word; } obj; obj o; o.word = 0; o.type[1] = 1; printf("%d\n",o.word); // affiche 256 donc ça marche bien
ça fait ce que tu demande type[0] écrit sur le premier octet et type[1] sur le deuxième.
J'ai mis short ,mait tu peux créer un type personnalisé avec la taille que tu veux.

Merci mais je suis désolé, probablement mon explication n'est pas clair car ce n'est pas ce que je souhaite.

Actuellement, j'ai ceci :
Code:

1 2 3 4 5 typedef struct{ uint16_t type; uint64_t word; } obj;
Je traite l'entier word d'une certaine manière mais en réalité, c'est une mauvaise représentation. En effet, j'interdis à l'utilisateur de mon programme de rentrer des données supérieurs à 64 bits grosso modo. Et si l'utilisateur rentre des données sur 8 ou 9 bits, je les stocks dans mes entiers word de 64 bits mais du coup, je sous-utilise la mémoire. Car cette structure obj, je l'alloue potentiellement des milliards de fois.

Ce que je voudrais, dans l'idéal, c'est :
Code:

1 2 3 4 5 6 typedef struct{ uint16_t type; uint8_t tab1[x]; uint8_t tab2[y]; } obj;
x et y peuvent être n'importe quoi entre 1 et 1024 par exemple. Pour réaliser ce type de structure, on me conseillerait de faire :
Code:

1 2 3 4 5 6 typedef struct{ uint16_t type; uint8_t* tab1; uint8_t* tab2; } obj;
Et d'allouer dynamiquement tab1 et tab2 a l'exécution de mon programme. Or on conviendra que si mon processeur est 64 bits, et que je ne souhaite allouer dans tab1 et tab2 que disons deux cases, je me retrouve à stocker deux pointeurs sur 64 bits pour seulement stocker 2x2 cases de 8 bits ...

C'est pour cela que j'avais envisagé d'utiliser les macros avec l'opérateur ## :
Code:

1 2 3 4 5 6 7 #define DECLARE_TAB(A,B) \ typedef struct _LINE_##A##_##B \ { \ uint8_t tab1[A]; \ uint8_t tab2[B]; \ } LINE_##A##_##B;
Avec ceci, je peut lire mes données, décider que tab1 doit contenir 2 cellules et tab2 4 cellules. De ce fait, j'initialise le type LINE_2_4 qui définit un struct contenant un tableau tab1 de 2 cellules et un tableau tab2 de 4 cellules.

J'aurais ensuite déclaré ceci :
Code:

1 2 3 4 5 6 7 #define DECLARE_OBJ(A,B) \ typedef struct _OBJ \ { \ uint16_t type; \ LINE_##A##_##B obj; \ } OBJ;
OBJ serait en quelque sorte une enveloppe pour mon type dynamique dont le nom est fixe. L'idée est d'utiliser dans mon code qui sera compilé le type OBJ partout, et de préciser seulement à l'allocation d'un struct OBJ les valeurs de A et B pour l'allocation du type LINE_##A##_##B qui est situé dans OBJ.

Or j'ai peur que cela ne soit pas possible car les "types" OBJ et LINE_##A##_##B n'existe qu'à l'exécution, mais le code est compilé d'abord et pour le compilateur, OBJ et LINE_##A##_##B n'existe pas (ou pas encore du moins ...). C'est ma déduction, je ne suis sur de rien, et j'aurais aimé avoir confirmation :)

Je ne sais pas si je suis plus clair que dans mon premier message ou non.

En fait, c'est tout a fait possible d'utiliser le type "dynamique" OBJ déclaré en macro dans vos fonctions standard (pas écrite en macro), genre votre main(). Il faut juste ne pas être nounouille comme moi et oublier d'appeler ses define qui, eh bien qui définissent votre type "dynamique".

Exemple :

obj.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
#define DECLARE_TYPE(A,B)                           \
    typedef struct _LINE_##A##_##B                  \
    {                                               \
        uint8_t tab1[A];                            \
        uint8_t tab2[B];                         \
    } LINE_##A##_##B;                       \
    typedef struct _OBJ                              \
    {                                               \
        uint16_t type;                              \
        LINE_##A##_##B obj;                   \
    } OBJ;
 
#define DECLARE_FUNCTION()                           \
    OBJ *CREATE_OBJ()                  \
    {                                               \
        return (OBJ*)malloc(sizeof(OBJ));                            \
    }                       \

main.c

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include "inttypes.h"
 
int main()
{
    DECLARE_TYPE(1,2);
    DECLARE_FUNCTION();
    OBJ *truc = CREATE_OBJ();
    truc->type = 1;
    truc->container->tab2[1] = 128;
    printf("truc->type = %" PRIu16 "\n", truc->type);
    printf("truc->container->tab2[1] = %" PRIu8 "\n", truc->container->tab2[1]);
 
    return 0;
}

L'exécution de ce main affichera bien :

Citation:

truc->type = 1
truc->container->tab2[1] = 128

Tadaaaaaaaaam :)

Je reviens une dernière fois sur ce topic pour dire que cela ne marche pas x)

Ma première déduction était la bonne : l'expansion des macros au restant du code est une étape effectué par le préprocesseur préliminaire à la compilation. Autrement dit, on ne peut pas lire des données, extraire des infos de ces données et passer ses infos en paramètre d'un macro qui définit un type car le type doit être définit avant le restant du code compilé.

Le code que j'ai mis juste au dessus fonctionne car j'appelle

Citation:

DECLARE_TYPE(1,2);

Avec les constantes 1 et 2 qui ne changent pas à l'exécution du programme.

Je ne peut donc pas faire :
Code:

1 2 3 4 int size_1 = 1; int size_2 = 2; DECLARE_TYPE(size_1,size_2);
Voilà c'est un fail :)

Citation:
Envoyé par Wizard50
Je ne peut donc pas faire :
Code:

1 2 3 4 int size_1 = 1; int size_2 = 2; DECLARE_TYPE(size_1,size_2);
Voilà c'est un fail :)
Oui normal vu que comme tu le dis , la structure ce fait pendant la compilation.

Sinon je le répète c'est vraiment mal coder faire une declaration de structure en define... de meme pour une déclaration de fonction.
Pour être honnête je sais pas je que tu essaye de faire exactement , il y a aussi le type void* pour justement avoir un pointeur generique et choisir comme tu vas lire tes donnés ensuite (char , int , structure ect).
si tu veux écrire octet par octet tu peux utiliser la comparaison bit a bit , & 0xFF ,& 0xFF00 ect ou decalage bit a bit.

par exemple :
Code:

1 2 3 4 5 6 7 8 short word = 0; word = 128 << 8; // j'ecris sur le deuxieme octet int dword = 0; dword = 128 << 16; // j'ecris sur le troisieme octet

Bonjour,

Citation:

Envoyé par Kannagi

si tu veux écrire octet par octet tu peux utiliser la comparaison bit a bit , & 0xFF ,& 0xFF00 ect ou decalage bit a bit.

Pourquoi chercher compliqué ?
Code:

1 2 3 4 union { uint8_t bytes[8]; uint64_t data; };
Citation:

. Car cette structure obj, je l'alloue potentiellement des milliards de fois.

Je pense que tu as un problème de conception. Il faudrait que tu nous dises exactement ce que tu comptes faire de cette structure pour qu'on puisse en réduire la complexité mémoire.

Citation:

Envoyé par Neckara

Pourquoi chercher compliqué ?

Je n'ai aucune idée de ce qu'il veut en faire ,quelque fois écrire octet par octet et nécessaire quelque fois inutile c'est a lui de juger si c'est nécessaire ou pas.
Mais j'avais proposé les union mais apparemment ce n'est pas ce qu'il recherche.