Version imprimable
bonjour,
Je cherche un tuto pdf expliquant les étapes nécessaires à réaliser dans un code source écrit en C afin de le convertir en C++.
par exemple:
ajouter des classes en C++
ajouter des objets en C++
remplacer des fonctions du C par des constructeurs en C++
remplacer typedef en C par je ne sais quoi d'autre en C++
etc...
merci de votre aide
:whistle: Cela va fortement dépendre de 1) comment le code C a été écrit 2) sur quoi concerne le code C
Et ensuite, il y a aussi les différences entre le C et C++ qui nécessite soit de coder plus soit d'adapter fortement :mrgreen:
Par exemple :
- Les constructeurs par copie et / ou l'opérateur d'affectation sont souvent nécessaires.
- Si en C tu n'as pas casté tes malloc (ou plus généralement les retours void) tu vas morfler
- Le code en C n'a pas de notions de polymorphisme, d'encapsulation, de surcharge, de virtuel, ... et cela il faudra analyser le code C pour le transformer en objet/ le simplifier/ ajouter des patrons de conception/ ...
Pour le point 1 par exemple, moi, à chaque fois que je fais une structure XXX, en dessous il y a toujours des fonctions/ procédures en rapport qui commencent toutes par XXX (le nom de la structure)
Donc si tu prends mon code, tu peux facilement transformer mon code C en code C++
D'autant plus qu'il y a les fonctions XXX_create / XXX_init / XXX_reset pour faire les constructeurs et XXX_delete pour les destructeurs
Mais si le codeur code façon puzzle cela va être chaud :aie:
Pour le point 1 par exemple, il y a aussi la gestion des variables globales.
Si le codeur a tout collé dans le main.c, un truc simple à faire mais un peu crade c'est de faire un singleton.
Sinon, si le codeur a éparpillé les variables globales, tu vas morfler.
Pour le point 2, si le codeur a codé, par exemple, une pile (stack - lifo), une file (queue - fifo) et une liste chaînée, tu peux soit utiliser la bibliothèque standard soit tout passer en template C++
Mais cela, le gars qui fait un tutoriel ne peut pas forcément le prévoir :mrgreen:
En conclusion :mrgreen:, tu n'as pas vraiment besoin de tutoriel pour transformer ton code C en code "C++ with classes", ce qui est le plus rapide en terme de temps et pour le commencement.
Intuitivement, je partirais dans la direction suivante :
- Faire compiler le code C avec un compilateur C++
Il y a une liste des incompatibilités en annexe C de la norme.
- Toutes les histoires de type de retour de malloc
- Gestion des extern "C" pour les parties qu'on ne peut/veut pas convertir
- Remplacement des noms de variables qui correspondent à des mots clef du C++
- ...
- Rendre, s'il ne l'est pas déjà, le code propre à être manipulé et refactoré sans risques
- Tests unitaires
- Tests d'intégration automatisés
- Supprimer la gestion manuelle de la mémoire
- Utiliser des strings partout où il y a des char*
- Remplacer tous les tableaux dynamiques par des vectors
- Remplacer tous les tableaux statiques par des vectors (s'il n'avaient pas une très bonne raison d'être statiques) ou des array
- Mettre des wrappers RAII autour de chaque ressource gérée manuellement (FILE*, toute fonction se nommant close, uninit, destroy...)
- Supprimer tous les free (et par la même occasion, tous les malloc). Clarifier la propriété de chaque objet pointé
- Expliciter les abstractions utilisées
- Remplacer les structs qui ont une sémantique forte par des classes, établir des invariants, mettre en place de l'encapsulation
- Remplacer des séries de pointeurs de fonction par des classes et des fonctions virtuelles
- Si approprié, virer tous les codes de retour indiquant si une fonction s'est bien exécutée et les ifs testant ces codes, et mettre en place une gestion d'erreurs à base d’exception
Il n'est pas nécessaire d'aller au bout du processus pour en tirer des avantages, et il ne faut pas se leurrer: Si on veut aller au bout, ça ressemblera à terme plus à une réécriture totale qu'à quelques changements à droite à gauche. Mais une réécriture qu'on aura pu faire graduellement et incrémentalement, là où ça avait le plus de sens (par exemple, on peut vouloir mettre plus d'efforts sur un moteur qui pourrait être réutilisé plus tard que sur le main).