Discussion :

[méphistopheles]

Bonjour a tous

Suite à un certains projet assez tordu à la base, j'en suis venu, pour résoudre un certain nombre de problèmes successif, à avoir besoin d'une classe un peu particulière.....

En effet, cette classe est template, par exemple comme cela :

Code :

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

 template<class objet> class Maclasse{};

Or cette classe va contenir un tableau de pointeurs sur des objets (ceux template) mais elle doit empêcher que ceux-ci soient détruits sans qu'elle ai auparavant effectué un traitement préalable .

J'ai donc naturellement pensé à allouer dynamiquement les objets, mais le problème est que l'utilisateur doit avoir la possibilité d'accéder à ces objet et d'en appeler les méthodes... mais pas de les supprimer...
La fonction doit donc pouvoir transmettre toutes les méthodes des objets qu'elle contient, mais interdire leur destruction ou du moins gérer cette destruction au travers d'une fonction spéciale... (en supposant que les objets n'ont pas de méthode d'autodestruction a part ~objet(); ) (je sait, on se croirais dans Fonction Impossible).

donc, maintenant que les prémices sont finies, posons les questions:

1. Est-ce réalisable ou du moins envisageable ?
2. Si oui comment ? sinon, peut-on contourner la difficulté ?
3. Avez-vous mal à la tête comme moi ?

Bref, si vous avez une solution meilleure que le tube d'aspirine, Merci de me la soumette et toutes mes excuse si ce sujet vous a fatigué.

Merci d'avoir lu jusque là et bonne chance si vous comptez y réfléchir.

Cordialement

Méphistophelès


PS:

BOUM !

[Luc Hermitte]

Ben file un handle-proxy à tes utilisateurs, et seul toi sera à même de déclencher sa destruction et tout ce qui est dessus en cascade.

[méphistopheles]

[...] handle-proxy [...]

? quésako ?

désolé, c'est une contrainte personelle est je ne suis pas pro, comme je suis quelque-peu tordu, je me casse la tête a résoudre ce problème...

Sinon, pourrais-tu expliciter ce qu'est un handle proxy ? (google n'a pas pu m'aider...)

merci

[loufoque]

Je vois pas en quoi fournir des références vers ces objets n'est pas suffisant ?
La durée de vie est gérée par ton conteneur, donc les utilisateurs n'ont pas à détruire tes objets. Qui serait assez stupide pour faire un delete sur une référence de toutes façons ? (enfin, y'a bien des gens qui font des delete en dehors de destructeurs, alors pourquoi pas...)

[méphistopheles]

disons qu'à la limite, ce serait acceptable si je pouvais détecter un delete sur un des objet, même apres que ce soit fait... le problème est que justement, l'auteur pourrais être ammené à détruire un objet mais il serait utile qu'à cette occasion, ma classe modifie un certains nombre de valeurs...

[JolyLoic]

Un truc genre (il y a de l'enrobage à faire) :

Code :

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

1
2
3
4
5
6
7
8
9
class ObjectHandle
{
public:
  ObjectHandle(object* initValue);
  void destroy() {/*Tu fais ce que tu veux ici*/}
  object* operator->() {return myObj;}
private:
  object *myObj;
};

Et tu retourne cet objet partout.
Peut-être un simple shared_ptr avec un custom deleter ferait aussi ce que tu veux.

[JeitEmgie]

Est-ce réalisable ou du moins envisageable ?
Si oui comment ? sinon, peut-on contourner la difficulté ?
Avez-vous mal à la tête comme moi ?

une solution théorique serait l'instrumentation du code…
regardez du côté d'AspectC…

[Obsidian]

J'ai problablement loupé quelque chose, mais comme l'a suggéré Loufoque, je ne vois pas pourquoi tu aurais besoin de pointeurs et d'allocation dynamique, à moins que, comme souvent, le véritable problème se situe ailleurs, dans un contexte qui n'est pas décrit par les précédents posts.

Si tu crées directement un tableau d'objets en tant que donnée-membre de ta classe et non un tableau de pointeurs sur des objets, eux, créés dynamiquement, alors le problème est résolu de lui-même : l'utilisateur ne pourra détruire ni le tableau ni un de ses membres sans détruire l'instance de la classe entière.

Si tu as besoin d'envoyer un signal à une autorité particulière à la disparition d'un objet (pour compter des références ou que sais-je), tu peux aussi remplacer tes classes templates par une classe unique de ton choix, et faire dériver tous les autres objets de celle-ci. Tu utilises donc le concept de l'interface (avec en plus les données de gestion), pour n'utiliser que des classes compatibles avec les manips que tu veux leur faire subir.

Si la taille de ton tableau est variable et que c'est dans la nature de la classe de gagner ou perdre des objets, c'est à la classe elle-même qu'il faut le demander, à mon avis, au travers de méthodes adéquates. Sinon, dans tous les cas, le mieux que tu aies à faire est d'utiliser une classe-conteneur intelligente. Donc soit std::vector<>, soit un conteneur de ta création, voire même un dérivé du précédent. Ainsi, tu peux renvoyer des références sur les éléments.

Avec ces approches, tu peux toujours contrôler, à mon avis, l'étape de destruction.

[méphistopheles]

Je crois finalement avoir trouvé la solution.

Il est apparement possible d'hériter d'un template.
En définissant une classe héritant du template, classe dont ma classe principale sera amie, il apparait qu'il suffit de redéfinir l'opérateur delete pour avoir la possibilité d'exécuter un petit script avant que l'objet ne soit détruit.
Avec un peu de chance, le polymorphisme s'appliquera bien et je n'aurais même pas besoin de redéfinir les constructeurs par copie du template.(enfin là, je rêve un peu ).

Bon, y'a plus qu'à comme on dit.

Merci à tous, je m'y attache de pied ferme