Existe t'il un environnement de développement qui permet de:
Ajouter un méthode à un ensemble de classe.
Ajouter un include à un ensemble de fichiers.
Ajouter un heritage à un ensemble de classe.
En fait j'ai 71 classes, qui doivent desormais implémenter une nouvelle
interface.
Pour chacune il faut donc que, j'ajoute l' include qui va bien, la
dérivation qui va bien, la declaration de la méthode à surcharger, et le
corps de la méthode.
Bien sur il faudra que je me tape le code pour chacune d'entre elles,
mais si je pouvais déjà faire le squelette en trois click de souris...
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Fabien LE LEZ
On Mon, 03 Oct 2005 16:42:14 +0200, JBB <anonyme>:
Pour chacune il faut donc que, j'ajoute l' include qui va bien, la dérivation qui va bien, la declaration de la méthode à surcharger, et le corps de la méthode.
Si tu n'es pas trop regardant sur la position des éléments en question dans les fichiers, ça doit être scriptable assez facilement, non ?
a) Remplacer
class X { ... };
par
class X: public NouvelleInterface { private: void NouvelleFonction();
... };
ou
class X: ... { ... };
par
class X: ..., public NouvelleInterface { private: void NouvelleFonction();
... };
Avec la liste des fichiers et des classes dans un tableur, pondre une série de commandes "gsar" et le tour est joué. Faut juste faire un peu attention aux sauts de lignes, particulièrement sous Windows.
b) rajouter
void X::NouvelleFonction() { }
à la fin de X.cpp
-> encore plus simple, il suffit de générer une série de commandes echo xxx >> X.cpp et c'est terminé.
c) Rajouter #include <nouvelle_interface.h> au début de X.h
Sous Windows, c'est peut-être un millipoil plus compliqué, mais je ne pense pas qu'il faille plus de 10 minutes pour l'automatiser.
Sous *nix, avec un shell décent, j'ose espérer que c'est trivial.
On Mon, 03 Oct 2005 16:42:14 +0200, JBB <anonyme>:
Pour chacune il faut donc que, j'ajoute l' include qui va bien, la
dérivation qui va bien, la declaration de la méthode à surcharger, et le
corps de la méthode.
Si tu n'es pas trop regardant sur la position des éléments en question
dans les fichiers, ça doit être scriptable assez facilement, non ?
a) Remplacer
class X
{
...
};
par
class X: public NouvelleInterface
{
private:
void NouvelleFonction();
...
};
ou
class X: ...
{
...
};
par
class X: ..., public NouvelleInterface
{
private:
void NouvelleFonction();
...
};
Avec la liste des fichiers et des classes dans un tableur, pondre une
série de commandes "gsar" et le tour est joué. Faut juste faire un peu
attention aux sauts de lignes, particulièrement sous Windows.
b) rajouter
void X::NouvelleFonction()
{
}
à la fin de X.cpp
-> encore plus simple, il suffit de générer une série de commandes
echo xxx >> X.cpp
et c'est terminé.
c) Rajouter #include <nouvelle_interface.h> au début de X.h
Sous Windows, c'est peut-être un millipoil plus compliqué, mais je ne
pense pas qu'il faille plus de 10 minutes pour l'automatiser.
Sous *nix, avec un shell décent, j'ose espérer que c'est trivial.
On Mon, 03 Oct 2005 16:42:14 +0200, JBB <anonyme>:
Pour chacune il faut donc que, j'ajoute l' include qui va bien, la dérivation qui va bien, la declaration de la méthode à surcharger, et le corps de la méthode.
Si tu n'es pas trop regardant sur la position des éléments en question dans les fichiers, ça doit être scriptable assez facilement, non ?
a) Remplacer
class X { ... };
par
class X: public NouvelleInterface { private: void NouvelleFonction();
... };
ou
class X: ... { ... };
par
class X: ..., public NouvelleInterface { private: void NouvelleFonction();
... };
Avec la liste des fichiers et des classes dans un tableur, pondre une série de commandes "gsar" et le tour est joué. Faut juste faire un peu attention aux sauts de lignes, particulièrement sous Windows.
b) rajouter
void X::NouvelleFonction() { }
à la fin de X.cpp
-> encore plus simple, il suffit de générer une série de commandes echo xxx >> X.cpp et c'est terminé.
c) Rajouter #include <nouvelle_interface.h> au début de X.h
Sous Windows, c'est peut-être un millipoil plus compliqué, mais je ne pense pas qu'il faille plus de 10 minutes pour l'automatiser.
Sous *nix, avec un shell décent, j'ose espérer que c'est trivial.
