Passer une classe c++ en c

Version imprimable

Bonjour a toutes et tous

J'ai un problème donc je viens solliciter votre aide. Je bosse actuellement sur un programme rédigé en c++ que je dois passer en c. Dans l'ensemble je n'ai pas trop de problème sauf sur un point: je ne trouve pas l'équivalence d'une classe c++ en c (si cela existe). Donc avez-vous des idées à me suggérer ???

La classe que je souhaite convertir en c est super simple, c'est pas une classe très étoffé (je vous mets le code en dessous). Tellement simple que beaucoup d'entre vous vont certainement me dire que j'en ai pas besoin, mais à priori cette classe est très importante dans le programme en c++ et j'aimerai garder la même "forme" entre mon programme c++ et sa conversion en c.

tableau.h

Code:

1
2
3
4
5
6
7
8
class Tableau
{
public:
    Tableau(int const& taille);//: longueur(taille), elements(new char [taille]){}
 
    int longueur;
    char *elements;
};

tableau.cpp

Code:

1
2
3
4
5
6
7
8
#include "tableau.h"
/*=========================================
 * Description : Création d'un tableau de char
 *=========================================*/
Tableau::Tableau(int const& taille): longueur(taille), elements(new char [taille])
{
 
}

Je vous mets aussi un exemple de son utilisation dans une fonction pour comprendre en quoi la classe est importante pour le programme

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
void sendTrameWriteModBus(char adrSlave, char CodeCommande, int adresseData, int nbrData, Tableau *tableau)
{
    int variableLocale;
    qint64 nombreOctetsEcris;                                                   // variable de vérification pour l'écriture sur le port
    Tableau *bufferEmissionModBus = new Tableau((tableau->longueur * 2) + 9);   // + 9 car : 7 octets d'entêtes MODBUS, 2 octets de CRC
 
    bufferEmissionModBus->elements[0] = adrSlave;
    bufferEmissionModBus->elements[1] = CodeCommande;
    bufferEmissionModBus->elements[2] = adresseData / 256;
    bufferEmissionModBus->elements[3] = adresseData & 255;
    bufferEmissionModBus->elements[4] = nbrData / 256;
    bufferEmissionModBus->elements[5] = nbrData & 255;
    bufferEmissionModBus->elements[6] = nbrData * 2;
 
    variableLocale = 7;
    for(int i = 0; i < tableau->longueur; i++)
    {
        bufferEmissionModBus->elements[variableLocale] = tableau->elements[i] / 256;
        variableLocale++;
        bufferEmissionModBus->elements[variableLocale] = tableau->elements[i] & 255;
        variableLocale++;
    }
 
    addCRC16(bufferEmissionModBus,bufferEmissionModBus->longueur - 2);          // ajout du CRC sur les deux derniers octets du tableau 'bufferEmissionModBUS'
 
    nombreOctetsEcris = serialPort->write(bufferEmissionModBus->elements, bufferEmissionModBus->longueur);  // écriture sur le port série
}

05/03/2014, 10h13
Bktero

Bonjour,

Tu as réussi à passer le reste de ton projet mais pas cette classe ? Perso, je pense qu'une structure avec un tableau et une taille fera l'affaire. La fonction de création demande une petite boucle si tu veux dupliquer les éléments.

Question: est-ce que cette classe, dans l'utilisation qui en est faite peut être remplacer par un tableau classique en C du style char toto[8] par exemple parce que c'est ce que j'ai commencé à faire, j'obtiens ce résultat:

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
void sendTrameWriteModBus(char adrSlave, char CodeCommande, int adresseData, int nbrData, char tableau)
{
/*=========================================
 * Description : Formate la trame ModBus et envoi la trame creee
 *=========================================*/
    int variableLocale;
    long nombreOctetsEcris;                                                   // variable de vérification pour l'écriture sur le port
    char bufferEmissionModBus[(sizeof(tableau) * 2) + 9];   					// + 9 car : 7 octets d'entêtes MODBUS, 2 octets de CRC
 
    bufferEmissionModBus[0] = adrSlave;
    bufferEmissionModBus[1] = CodeCommande;
    bufferEmissionModBus[2] = adresseData / 256;
    bufferEmissionModBus[3] = adresseData & 255;
    bufferEmissionModBus[4] = nbrData / 256;
    bufferEmissionModBus[5] = nbrData & 255;
    bufferEmissionModBus[6] = nbrData * 2;
 
    variableLocale = 7;
    for(int i = 0; i < sizeof(tableau); i++)
    {
        bufferEmissionModBus[variableLocale] = tableau[i] / 256;
        variableLocale++;
        bufferEmissionModBus[variableLocale] = tableau[i] & 255;
        variableLocale++;
    }
 
    addCRC16(bufferEmissionModBus,sizeof(bufferEmissionModBus) - 2);          // ajout du CRC sur les deux derniers octets du tableau 'bufferEmissionModBUS'
 
    nombreOctetsEcris = write(bufferEmissionModBus, sizeof(bufferEmissionModBus));  // écriture sur le port série
}

Mais je ne sais pas si cela peut être viable

05/03/2014, 10h41
phi1981
Il est pas beau ce code C++ ....

Je crois même que j'ai repéré une fuite mémoire :
Code:

1 2 Tableau *bufferEmissionModBus = new Tableau((tableau->longueur * 2) + 9); // + 9 car : 7 octets d'entêtes MODBUS, 2 octets de CRC
Je vois pas où pourrait se trouver le delete qui correspond à ce new.

Comme dit Bktero, tu peux utiliser un tableau et une longueur, ça suffira.

Toutefois, un conseil, en ModBus on manipule des mots de 16 bits, donc perso plutôt que de manipuler un bête tableau de chars, je manipulerais un tableau de shorts.
Cela devrait simplifier l'écriture de l'adresse et de la taille (avec un byte-swap si nécessaire).
Mais bon je connais pas les autres contraintes.
05/03/2014, 10h42
gangsoleil

Bonjour,

Comme le dit Bktero, c'est une structure qu'il faut que tu utilises, pas un "simple tableau". Et c'est ta structure qui contiendra un entier pour longueur et un pointeur pour elements (attention a bien penser a allouer la zone memoire).

donc un truc du style:

Code:

1
2
3
4
5
6
 
struct tableau
{
     int longueur
     char *elements
}

05/03/2014, 11h23
ManusDei

Oui.
05/03/2014, 11h44
clairetj

Citation:

Envoyé par Bktero

Bonjour,

Tu as réussi à passer le reste de ton projet mais pas cette classe ? Perso, je pense qu'une structure avec un tableau et une taille fera l'affaire. La fonction de création demande une petite boucle si tu veux dupliquer les éléments.

Par contre j'ai pas trop compris l'histoire de la boucle pour la duplication, est-ce que l'on peut m'expliquer svp
05/03/2014, 12h05
Bktero

En C, tu ne peux pas copier des tableaux avec l'opérateur =. Tu dois donc faire une boucle (ou utiliser memcpy d'ailleurs :oops:). En fait, j'ai lu un peu vite et j'ai cru que tu avais un constructeur par copie mais ce ne semble pas être le cas.

Si on manipule des données de 16 bits, autant utiliser (u)int16_t que short, histoire d'être totalement certain de la portabilité et parce que ça indique clairement qu'on souhaite exactement 16 bits.
05/03/2014, 15h28
clairetj

autre question: dans ma fonction sendTrameWriteModBus, je passe en paramètre un tableau. Du coup quand je défini ma fonction est-ce cela marche ainsi avec les structure:

Code:

sendTrameWriteModBus(char adrSlave, char CodeCommande, int adresseData, int nbrData, struct tableau)

?
05/03/2014, 15h52
Bktero

Code:

sendTrameWriteModBus(char adrSlave, char CodeCommande, int adresseData, int nbrData, struct tableau unTableau)

Ton écriture est valable lors d'une déclaration (prototype sans corps de fonction) mais lors de la définition (avec le corps de la fonction), il te faut donner un nom au paramètre de type struct tableau.
05/03/2014, 16h02
clairetj

Citation:

Envoyé par Bktero

Code:

sendTrameWriteModBus(char adrSlave, char CodeCommande, int adresseData, int nbrData, struct tableau unTableau)

Ton écriture est valable lors d'une déclaration (prototype sans corps de fonction) mais lors de la définition (avec le corps de la fonction), il te faut donner un nom au paramètre de type struct tableau.

Je me doutais qu'il fallait que je donne un nom au tableau passé en paramètre mais je voulais en être sûr dans le doute
06/03/2014, 09h28
ManusDei

Je te conseille de jeter un oeil sur ces liens, même si tu dois connaître les 3/4 des infos, le quart restant est intéressant.
http://c.developpez.com/faq/?page=pointeurs

Comment créer un alias pour une structure
http://c.developpez.com/faq/?page=st...STRUCT_typedef

du coup est-ce que je peux écrire ceci:
Code:

1 2 3 4 5 struct Tablea { int longueur; char *elements[longueur]; };
???

06/03/2014, 10h06
Bktero

As-tu essayé ?

Remarque : en C, char* tab, char tab[] et char *tab[] ne créent pas du tout le même type de variables.
06/03/2014, 11h27
clairetj

J'ai essayé mais le compilateur me dit que longueur dans char *elements[longueur] est undeclared, du coup si je ne veux pas d'erreur il faut que j'écrive char *elements[] mais je ne sais pas si cela convient de déclarer un pointeur ver tableau sans dimension

char * elements[]; n'est pas un pointeur vers un tableau sans dimension, mais un tableau sans dimension de pointeurs.

Dépendant de la version du standard C ou des extensions que supporte ton compilateur, tu peux ou non terminer une structure par un tableau sans dimension zéro. En C90 pur, tu dois au moins donner une dimension de 1.
Ensuite, une telle structure est utilisable en allocation dynamique, avec un "tour de passe-passe" consistant à allouer plus que la taille de la structure. Pour déterminer la taille exacte, on utilise la macro offsetof définie dans stddef.h, et on y ajoute la taille en bytes du tableau:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 #include <stddef.h> struct Tablea { int longueur; char elements[1]; }; struct Tablea * AllocTablea(int longueur) { size_t tailleTableau = longueur * sizeof(char); size_t tailleTotale = offsetof(struct Tablea, elements) + tailleTableau; return malloc(tailleTotale); } struct Tablea * NewTablea(int longueur) { struct Tablea * pRet = AllocTablea(longueur); if(pRet != NULL) { pRet->longueur = longueur; } return pRet; }
Note: Ton pire ennemi dans la conversion C++->C, c'est toute classe ayant un destructeur, ou pire, une sémantique de mouvement, car c'est extrêmement dûr à ré-implémenter en C et le risque de fuite de mémoire est énorme.
Pratiquement tout le reste, y compris les fonctions virtuelles (dans un héritage simple non-virtuel) est relativement facile.

06/03/2014, 14h49
Bktero

En C99, tu peux utiliser des flexible array members : http://gradot.wordpress.com/2012/05/...y-members-c99/

Dans ton cas, je pense qu'il sera plus simple de faire une structure contenant un char* qui pointera vers une zone allouée avec malloc() ou calloc().
06/03/2014, 14h55
Médinoc

En fait, je dirais que ça dépend de si le tableau est censé être redimensionnable ou pas.