TEMPLATE C++ DE NOMBRES COMPLEXES template, patron, complex, complexe, Source N°41652

Information sur la source

Catégorie :Maths & Algorithmes Classé sous : template, patron, complex, complexe Niveau : Initié Date de création : 26/02/2007 Date de mise à jour : 26/02/2007 19:21:20 Vu / téléchargé: 2 347 / 157

Auteur : emiaille

Ecrire un message privé

Note :
Aucune note

Commentaire sur cette source (5)

Ajouter un commentaire et/ou une note

Description

Bon ben voilà, je voulais faire une classe pour gérer les complexes et m'initier aux templates C++ alors j'ai fait cette petite classe qui allient les deux.

Cette classe surcharge les différents opérateurs, le transtypage (enfin je crois) et d'autres fonctions comme le module (absolute), le conjugué (conjugue) et la puissance (power).

Je sais que les classes pour gérer les complexes sont légions sur ce site et sur d'autres, mais ce qui m'intéresse le plus ici ce sont les templates.

C'est mon première essai avec les templates, alors d'un, soyez indulgents, et de deux, si vous avez des remarques constructives ou des conseils avisés, je suis preneur.

Pour ce qui est des complexes, j'ai terminé mes études il y a un petit moment maintenant, alors je suis pas tout à fait sûr des calculs (j'ai rajouté les développements en commentaires). Si quelqu'un à le courage de vérifier, merci.

Si vous avez des idées de traitements à rajouter, je suis également preneur à la condition que vous me fournissiez les algorithmes.

Le source en présentation ci-dessous correspond à la déclaration de la classe. Dans le zip, il y a la source complète et un fichier de test. J'ai réalisé les tests sous Windows avec MinGW 5.1.3

Source

template <typename T>
class complex
{
public:
// Constructor / destructor
complex(void);
complex(const complex<T> & cmp);
template <typename U>
complex(complex<U> & cmp);
complex(const T & re, const T & im);
~complex(void);
// Accessors / mutators
T & re(void);
T & im(void);
// Operator overloading
complex<T> & operator = (const complex<T> & cmp);
complex<T> operator + (const complex<T> & cmp) const;
complex<T> operator - (const complex<T> & cmp) const;
complex<T> operator * (const complex<T> & cmp) const;
complex<T> operator / (const complex<T> & cmp) const;
complex<T> & operator += (const complex<T> & cmp);
complex<T> & operator -= (const complex<T> & cmp);
complex<T> & operator *= (const complex<T> & cmp);
complex<T> & operator /= (const complex<T> & cmp);
bool operator == (const complex<T> & cmp);
bool operator != (const complex<T> & cmp);
complex<T> & operator = (const T & value);
complex<T> operator + (const T & value) const;
complex<T> operator - (const T & value) const;
complex<T> operator * (const T & value) const;
complex<T> operator / (const T & value) const;
complex<T> & operator += (const T & value);
complex<T> & operator -= (const T & value);
complex<T> & operator *= (const T & value);
complex<T> & operator /= (const T & value);
// Others operations
T absolute(void) const;
complex<T> conjugue(void) const;
complex<T> power(unsigned short n) const;
protected:
T m_re;
T m_im;
};

template <typename T>
class complex
{
  public:

    // Constructor / destructor

    complex(void);
    complex(const complex<T> & cmp); 
    template <typename U>	
    complex(complex<U> & cmp);
    complex(const T & re, const T & im);
    ~complex(void);

    // Accessors / mutators

    T & re(void);
    T & im(void);

    // Operator overloading

    complex<T> & operator = (const complex<T> & cmp);
    complex<T> operator + (const complex<T> & cmp) const;
    complex<T> operator - (const complex<T> & cmp) const;
    complex<T> operator * (const complex<T> & cmp) const;
    complex<T> operator / (const complex<T> & cmp) const;
    complex<T> & operator += (const complex<T> & cmp);
    complex<T> & operator -= (const complex<T> & cmp);
    complex<T> & operator *= (const complex<T> & cmp);
    complex<T> & operator /= (const complex<T> & cmp);

    bool operator == (const complex<T> & cmp);
    bool operator != (const complex<T> & cmp);

    complex<T> & operator = (const T & value);
    complex<T> operator + (const T & value) const;
    complex<T> operator - (const T & value) const;
    complex<T> operator * (const T & value) const;
    complex<T> operator / (const T & value) const;
    complex<T> & operator += (const T & value);
    complex<T> & operator -= (const T & value);
    complex<T> & operator *= (const T & value);
    complex<T> & operator /= (const T & value);

    // Others operations

    T absolute(void) const;
    complex<T> conjugue(void) const;
    complex<T> power(unsigned short n) const;
				
  protected:
			
    T m_re;
    T m_im; 
};

Conclusion

Cette source est régie par la licence CeCILL-C soumise au droit français et respectant les principes de diffusion des logiciels libres. Vous pouvez utiliser, modifier et/ou redistribuer cette source sous les conditions de la licence CeCILL-C] telle que diffusée par le CEA, le CNRS et l'INRIA sur le site "http://www.cecill.info".

1.0.0 : Création

Fichier Zip

Pour les "Membres Club", vous pouvez télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

complex
- maya
  - complex.hpp 12 837 octets
- makefile.windows317 octets
- test.cpp 10 267 octets

Télécharger le zip

Historique

26 février 2007 19:21:20 :: Remise en forme de la source affichée sur le site et ajout de l'intitulé de la licence.

Sources de la même categorie

Toutes les sources de la catégorie Maths & Algorithmes

Sources en rapport avec celle ci

Commentaires

Commentaire de sirdrako le 09/03/2007 21:31:59

En général, on met les opérateurs en friend.

bonne continuation !
Commentaire de emiaille le 09/03/2007 23:00:27

Merci.
J'aimerais savoir à quoi ça sert de les mettre en friend?
Commentaire de ketchupy45 le 10/03/2007 20:51:08

Bonjour, mettre en friend permet uniquement d'avoir accès aux données membres de la classe, alors que la fonction n'est pas utilisée avec un opérande de type Classe.
D'apres certains, les fonction en friend sont à éviter le plus possible. Il est conseillé d'utiliser une fonction d'accès aux données membres.
Voila j'espère avoir été clair.
Commentaire de emiaille le 10/03/2007 21:11:29

Merci j'avais déjà utilisé les fonctions friend dans d'autres développements que j'avais fait.
C'est vrai que j'évite de les utiliser mais ça peut être très pratique dans certains cas.

Ce que je ne vois toujours pas c'est quel en est l'intérêt de les utiliser sur les opérateurs dans mon cas.

Mes opérateurs sont en accès publique.
Est-ce que je devrais les mettre en accès protégé et faire un friend de ma propre classe sur elle-même? J'ai du mal à en comprendre l'utilité.
Commentaire de ketchupy45 le 10/03/2007 23:34:26

Désolé j'avait pas vu.
Euh non les opérateurs doivent etre public, par contre et c'est un des grands principes de la programmation orientée objet, les données membres (Re et Im) DOIVENT etre privée. Evidemment ça marche si elles sont publiques, mais n'importe qui y à accès de n'importe où ce qui peut etre catastrophique sur le résultat final. Parce que dans ta classe tout marche parce que tu sais exactement ce que tu as fait.
De plus ta classe étant une template elle est faite pour être réutilisée.

Ajouter un commentaire

Discussions en rapport avec ce code source

classe template par mimosa803

file par mimosa803

Problème d'opérateurs sur des classes filles par pcmanprogrammeur

template par amine390

template et l'héritage par imad_lol

Template C++ par luhtor

Classe contenant vecteur template par val3113

Spécialisation template et fonctions inline par Samaths

Heritage Templates par ricklekebekoi

pb DLL et template par axiagame