Pour clarifier ma programmation, j'utilise les operateurs et je vous encourage à le faire.
Ce tutorial est dans la continuité de celui sur DPString (En fait il utilise les fonctions windows cachées par des operateurs)
Source / Exemple :
/*
je considere que pour une programmation lisible, on declare d'abord puis on definit
voire la declaration dans un header et la definition dans un source
comme ca on a juste à faire un include dans un autre source pour pouvoir utiliser la classe
Ce tutorial ne necessite que peu de connaissances en c++
/**************************************************************************************/
// MaClasseAvecOps.h
#include <windows.h>
class MaClasseAvecOps
{
INT entier;
CHAR caractere;
/*
les types definis par windows sont les memes que les types de
base du C++ mais en majuscule (ils sont sur 32 bits ce qui est plus rapide)
j'utiliserai ceux-ci par habitude mais vous pouvez faire comme vous le voulez.
public: // les operateurs DOIVENT etre publics.
BOOL operator ==(INT i); // l'operateur == renvoie un booleen et prend en parametre le type voulu
BOOL operator ==(CHAR c); // on surcharge l'operateur ==
// comme ca si on fait "truc == caractere" ou "truc == nombre", le compilateur choisit la fonction
BOOL operator ==(MaClasseAvecOps C); // truc super bien des operateurs : on compare deux classes de meme type utilisateur
VOID operator =(INT i); // l'operateur = est comme == mais ne renvoie rien
VOID operator =(CHAR c);
VOID operator +=(INT i);// +=, -=, ++ et -- retournent VOID
VOID operator -=(INT i);
VOID operator ++();// ++ et -- ne prennent aucun parametre
VOID operator --();
};
/**************************************************************************************/
// main.cpp
void main()
{
MaClasseAvecOps Ops;
/*
on instancie sans new avec pointeurs car il existe deja des operateurs pour les pointeurs ex:
MaClasseAvecOps *Ops = new MaClasseAvecOps;
// impossible:
Ops = 'a';
// je crois qu'il faut faire un truc du genre
(*Ops) = 'a';
//ou
Ops->operator =('a'); // appel explicite
// c'est moins pratique et on perd le fait qu'un operateur soit un operateur (mais possible)
Ops = 1; // le int membre est egal à 1
Ops = 'b'; // le char membre est egal à 'b'
Ops++; // le int membre est egal à 2
Ops -= 15; // le int membre est egal à -13
}
/**************************************************************************************/
// MaClasseAvecOps.cpp
BOOL MaClasseAvecOps::operator ==(INT i)
{
return (entier == i); // on utilise ici l'operateur par defaut du c++ sur les int
// on se rapporte toujours aux connaissances de base
}
BOOL MaClasseAvecOps::operator ==(CHAR c)
{
return (caractere == c);
}
BOOL MaClasseAvecOps::operator ==(MaClasseAvecOps C);
{
return ((C.caractere = caractere) && (C.entier = entier))
}
VOID MaClasseAvecOps::operator =(INT i)
{
entier = i;
}
VOID MaClasseAvecOps::operator =(CHAR c)
{
caractere = c;
}
VOID MaClasseAvecOps::operator +=(INT i)
{
entier += i;
}
VOID MaClasseAvecOps::operator -=(INT i)
{
entier -= i;
}
VOID MaClasseAvecOps::operator ++()
{
entier++;
}
VOID MaClasseAvecOps::operator --()
{
entier--;
}
Conclusion :
J'ai conçu ce code "à la main" au notepad, il n'a donc pas été testé mais devrait etre compatible avec Dev-C++.
Si vous avez des erreurs faites les parvenir
Visitez
http://dreamproject.free.fr
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.