Discussion :

[clairetj]

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 :

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

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 :

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

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 :

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
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
}

[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.

[clairetj]

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 :

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
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

[phi1981]

Il est pas beau ce code C++ ....

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

Code :

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

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.

[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).

[clairetj]

donc un truc du style:

Code :

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

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

[ManusDei]

Oui.

[clairetj]

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

[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 ). 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.

[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 :

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

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

?

[Bktero]

Code :

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

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.

[clairetj]

Code :

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

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

[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

[clairetj]

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

Code :

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

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

???

[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.

[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

[Médinoc]

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 C :

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
#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.

[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().

[Médinoc]

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