Surcharge d'opérateur [Résolu]

Signaler
Messages postés
15
Date d'inscription
dimanche 18 mai 2008
Statut
Membre
Dernière intervention
15 avril 2010
-
Messages postés
2023
Date d'inscription
mardi 24 septembre 2002
Statut
Membre
Dernière intervention
28 juillet 2008
-
Bonjour,

J'ai des trous de mémoires de de compétences sur la surcharge d'opérateur.

A quoi ca sert?

Par exemple ici: pourquoi surcharge t'on les opérateur -> et * ? 

Fichier CPtr.h

#if !defined __CPTR_H__

#define __CPTR_H__

namespace std

{

template <typename T> // Pourquoi ne met on pas template <class T> Quelle est la différence?
class CPtr

{

protected :

T * m_Ptr;

public :

CPtr (void);

~CPtr (void);

T & operator * (void) throw ();

const T & operator * (void) const throw (); // non obligatoire??
T * operator -> (void) throw ();

const T * operator -> (void) const throw (); // non obligatoire??

private

CPtr & operator = (const CPtr & Ptr);

CPtr (const CPtr & Ptr);

}; // CPtr

} // namespace std

#include "CPtr.hxx"

#endif /* __CPTR_H__ */

Fichier CPtr.cxx

#if !defined __CPTR_HXX__

#define __CPTR_HXX__

#include "CPtr.h"

#define TEMPL template <class T> // class ou typename?
#define TEMPLINL TEMPL inline

#define CPTR std::CPtr <T>

TEMPLINL CPTR:: CPtr (void) { m_Ptr = new T(); }

TEMPLINL CPTR::~CPtr (void) { delete m_Ptr; }

TEMPLINL

T & CPTR::operator * (void) throw () { return *m_Ptr; }

TEMPLINL

const T & CPTR::operator * (void) const throw () { return *m_Ptr; }

TEMPLINL

T * CPTR::operator -> (void) throw () { return m_Ptr; }

TEMPLINL

const T * CPTR::operator -> (void) const throw () { return m_Ptr; }

#undef CPTR

#undef TEMPLINL

#undef TEMPL

#endif /* __CPTR_HXX__ */

Merci pour votre aide, j'ai rajouté quelques autres questions qui me trotter dans la tête...

1 réponse

Messages postés
2023
Date d'inscription
mardi 24 septembre 2002
Statut
Membre
Dernière intervention
28 juillet 2008
5
"pourquoi surcharge t'on les opérateur -> et * ?"

Pour pouvoir écrire ca:
CPtr<float> myPtr;
*myPtr = 4.0f;

ou ca:
CPtr myObject;
myObject->UneMethodeQuelconque();

" template <typename T> // Pourquoi ne met on pas template <class T> Quelle est la différence?"
Aucune différence ici.

"const T & operator * (void) const throw (); // non obligatoire??
const T * operator -> (void) const throw (); // non obligatoire??"
Si, c'est nécessaire, sinon un code de ce genre de pourra pas fonctionner:

void UneFonction(const CPtr & _unObject)
{
    _unObject->UneMethode();
    // L'objet est ici (const CPtr), donc l'opérateur "const T * operator -> (void) throw ();" n'est pas disponible. Seule la version "const" l'est.
}

#define TEMPL template <class T> // class ou typename?
Pareil: c'est équivalent ici.