Yop !

Je reviens vers vous en ce jour ensoleillé, après une longue absence pour poser 2 nouvelles questions orientées objet.

1. Je souhaite surcharger l'opérateur d'affectation par pointeur dans une classe mère, de sorte à pouvoir faire tourner du code générique quand je sauve le pointeur vers une instance d'une classe fille ( MaClassFille* test = &uneInstanceFille )

Je tatone avec quelque chose du genre
MaClassMere* MaClassMere::operator=(MaClassMere* in)
{
}
mais j'ai du mal à comprendre pourquoi ce code n'est pas appelé quand j'effectue l'affectation du pointeur.

2. Le code exécuté dans la surcharge de l'opérateur d'assignation par référence, se fait après copie brute des types ordinaux et pointeurs/ref d'une classe à l'autre, si je ne me trompe pas.
Est-il possible d'obtenir le même comportement dans le constructeur par recopie, et du coup ne pas avoir à swap/copier manuellement les données d'une classe à l'autre ?

Merci d'avance à ceux qui lirons ceci, et encore plus à ceux qui y répondront

A+

Si tu utilises l'opérateur = sur un pointeur sans le déréférencer alors tu utilises l'opérateur = du type pointeur, pas celui de ton type MaCLassMere.

C'est ce que je cherche à faire, je ne surcharge pas l'opérateur d'assignement par référence mais par pointeur ( et je ne sais même pas si c'est faisable en fait :/ )

Ce que tu cherches a faire n'est pas possible. Si c'est vraiment ce que tu veux faire (ce dont je doute). Il te faut creer ton propre type de pointeur a la maniere d'un iterateur et utiliser ce type la.

Je ne sais même pas moi-même si c'est ce que je cherche à faire en fait, c'est la première fois que je me retrouve dans un cas comme celui-là.

Pour résumer, je partage 5 classes entre du C++ et du Lua. J'ai voulu insérer un système de comptage de référence générique, pour ne deleter l'objet uniquement quand toutes les références vers l'objet on été mises à NULL.
Je pensais que surcharger l'assignation par pointeur dans une classe mère, et ajouter le destructeur qui va bien suffirait à gérer ces compteurs et serait la manière la plus générique de procéder, du coup je n'ai pas vraiment pensé à d'autre solutions.

Du coup, il va falloir penser à incrémenter et décrémenter les compteurs à chaque assignation et destruction, ça risque d'être un peu plus lourd et sujet à oubli.

Mais lua n'appellera pas cette fonction de toute facon.

Ah pardon, pour lua effectivement j'incrémente et décrémente manuellement, quand je push et détruit l'objet, coté C++ donc (c'est acceptable ? ), donc la question ne concerne que le C++

" J'ai voulu insérer un système de comptage de référence générique, pour ne deleter l'objet uniquement quand toutes les références vers l'objet on été mises à NULL. "

Il me semble que C++11 introduit de nouvelles classes dans l'en-tête <memory>, à savoir shared_ptr et weak_ptr qui servent à cela mais je ne les connais pas encore assez pour t'en dire plus (je ne sais même pas si ça correspond bien à ce que tu cherches), regarde ici si cela t'intéresse :

http://msdn.microsoft.com/fr-fr/library/vstudio/hh279669.aspx
http://msdn.microsoft.com/fr-fr/library/vstudio/hh279672.aspx

Cela-dit il faut bien évidemment un compilateur C++ qui supporte ces fonctionnalités, autrement tu peux essayer de créer une classe similaire toi-même.

Au passage je viens de remarquer que sur les liens que je t'ai filé c'est du français très approximatif, je m'en excuse. Faut dire qu'ils ne font pas très attention aux pages en français sur MSDN, on dirait limite du google translate.

Pour étoffer un peu mon dernier message, histoire de ne pas réfléchir pour rien, j'ajouterais que je veux simplement pouvoir faire une affectation propre du pointeur en une ligne.

J'ai quelque chose de fonctionnel, mais qui ressemble à
MaClasseFille* test = (MaClasseFille*)test->clean_assign(&uneInstance);

ce qui ne plait pas. C'est là où j'ai voulu porter cette méthode vers l'opérateur d'assignation.

[Cross-post] je vais voir du coté C++11, mais il me semble que avoir lu quelque part que ces features ne sont pas accessibles sur XCode 4.2 et OSX 10.6, que j'utilise pour ce projet (ça m'apprendra ... ^^ ). Merci en tout cas

En effet ce sont des "smart pointers" qu'il te faut. Mais encore une fois, ces "smart pointer" ne franchirront probablement pas la barriere entre C++ et Lua

Je vais donc voir de ce coté, merci

Pour ma curiosité personnelle, qu'est-ce qui te fais douter du fait de pouvoir s'en servir en lua, puisque les méta-méthodes utilisent le code C++ ?
S'en servir exactement de la même façon ok, mais il est toujours possible d'obtenir le même comportement à plus bas niveau et moyennant un poil d'abstraction, à moins que je sois passé à coté de quelque chose ?

je ne sais pas, je n'ai jamais fait d'interfacage avec un langage de script.
Mais mon experience (indirecte) d'interfacage entre ocaml et C donne une gestion de la memoire assez bizarre.

Au passage si l'OP tient quand même à utiliser des pointeurs intelligents je viens de me rappeler qu'il y en a aussi dans Boost.