Salut à tous,

j´ai cette fois un problème avec les opérateurs d´assignement. En fait j´aimerais pouvoir assigner une structure à un type de base ( ou presque, c´est LPVOID). Bon, le blem, c´est que, si j´ai bien compris, on est obligé de déclarer l´opérateur au sein de la classe ou de la struct. En clair, cela signifie-t-il il n´y a aucun moyen de le surcharger en tant qu´opérateur global ou par un autre procédé pour y parvenir?

Next, tant que j´y suis, est-ce que c´est cet opérateur que je dois surcharger si je veux pouvoir utiliser ma structure dans une fonction necessitant comme argument un void*?

Ex.: VirtualFree ( MaStruct , 0, 0);

Tuju ! J´ai rien compris a la question ! !!

Je crois qu´il parle du cast . .. ( enfin d´après ce que j´ai compris)

Bon, OK, de façon plus claire ( c´est mon code):

typedef struct {
LPVOID Pointer;
HMMMemType Type;
unsigned int Size;
bool Locked;
LPHMMInstance InstOwner;

HMMPointer& operator = ( LPVOID & ) ;
}HMMPointer, *LPHMMPointer;

Voilà, mais ce n´est pas ça que je veux, mon but étant de pouvoir convertir le HMMPointer en LPVOID.

Et donc le blem c´est que je ne peux pas créer d´opérateur global pour ça...

Hmm ya un truc qui me gène là dedans, en quoi ton HMMPointer est un pointeur ? tel que tu l´as défini dans l´exemple il ne s´agit pas du tout d´un pointeur . .. ca serait pas plutôt LPHMMPointer que tu veux convertir ?

Non, un autre ex.:

LPVOID Essai;
HMMPointer Temp;

//Et je voudrais qu´on puisse faire...:
Essai = Temp;
//Et que Essai prenne la valeur du membre Pointer de Temp

Si j´ai bien compris ( mais c´est po sur ! )

Ben y a une impossibilité ici ! !!!!

Extrait de la Doc Micro...
"The following operators can only be overloaded in class scope as nonstatic members: assignment operator ´=´, class member access operator ´->´, subscripting operator ´[]´, and function call operator ´( ) ´."

Voila comment je vois la chose "schematiquement":

class A {....}
class B {....}

A P1;
B P2;

P2 = P1;

ceci equivaux a
P2.=(P1);
Donc l´operateur = pris est celui definit par P2.

Or si P2 est de type void*
alors le = est le = du void* ( Heurk ! !)
C´est pour cela que que si P1 est de type different, tu est prié de faire un petit cast alors P2 = ( void*)P1; equivaux a P2.=((void*)P1)
-et ca ton compilo il aime ! !! -

La valeur retourné par l´operateur egal ne sert qu´a permetre un truc du style
P1=P2=P3;
Lors de l´execution cela ce traduit par :
P1.=( P2.=(P3));
Hors si l´operateur egal renvoie rien alors l´affectation de P1 ne se fait pas ( puisqu´il n´a rien a affecter)

A ta place je ferais soit :
P1 = P2.GetPtr(); //Accesseur normal

Si vraiment tu veux passer par un operateur
P2>>P1; // Note alors que j´ai contourné le probleme en placant P2 comme instance primaire de l´operation ! !!
La declaration de >> est donc
void* P2::operator >>(void* &);
Et la j´avoue que cela me file des bouton de filer une reference sur un pointeur ( mais chacun son avis )
Je prefere alors plutot
P2>>&1
avec
void* P2::operator >>(void** VoidPtr);

Cela te convient il ?

Ouf, merci Passage, alors oui, tu as bien compris, mais tu ne connais donc aucun moyen pour utiliser l´opérateur = ?
Mon but, mais tu dois l´avoir compris, c´est que ce type soit transparent aux pointers de base. La structure est en fait utilisée par mon gestionnaire de mémoire. Ce n´est pas vital mais ce serait sympa de simplifier leur utilisation.
Une idée?

J´reviens Lundi.

Merci mais ça ne m´avance pas beaucoup...

Nan, je reviens tout de suite.

Vue la doc cité dans mon message et l´utilisation j´crois bien qu´il y a impossibilité.

Bon bah mer... alors

M^me pas une toute petite idée?

Comme l´a dit Passage tu ne peux pas utiliser un opérateur global pour l´assignement, il faut qu´il appartienne à une classe ou structure . ..

Je sais pas si ca pourra t´aider mais tu peux toujours écrire un truc dans ce genre :

// b = a

1. define ASSIGN(a,b) a.operator =(b);

ce qui dans ton cas te permet d´utiliser ton opérateur

ASSIGN(Temp,Essai)

Désolé c´est tout ce que j´ai à te proposer : )

Non, le but c´était de simplifier.
Bon bah je crois que je vais abandonner, et puis c´est tout

Merci quand même

Oulala, mais si, c´est possible.
Seulement il faut pas essayer de surcharger l´opérateur d´assignement, mais de créer une "règle de conversion".

Cela donne:

typedef struct {
LPVOID Pointer;
HMMMemType Type;
unsigned int Size;
bool Locked;
LPHMMInstance InstOwner;

operator void* ( ) {return Pointer};

}HMMPointer, *LPHMMPointer;

Je crois que c´est ça mais en tout cas c´en est pas loin.
Et après on peut faire autant:

LPVOID a;
HMMPointer b;

a = b;

que:

CopyMemory(b,a,...);

Ca y est, je suis un dindon heureux

g rien compris a ce que vous dites lol g saisi les mots pointeurs et void ^^