Class matrice c++

Soyez le premier à donner votre avis sur cette source.

Vue 16 809 fois - Téléchargée 1 567 fois

Description

cette classe permet de faire les opérations usuelles dans les matrices :
- addition
- soustraction
- multiplication
- lecture des données a partir d'un fichier
- affichage de la matrice

Source / Exemple :


#ifndef __MATRIX_H__
#define __MATRIX_H__

#include <stdio.h>
#include <stdlib.h>

class Matrix
{
    int m_size;
    double ** m_matrix;
    FILE * m_log;
    
    public :
        Matrix(int n, FILE * m_log = stderr);
        double get(int i, int j);
        void set(int i, int j, double value);
        Matrix* add(Matrix * m);
        Matrix* subtract(Matrix * m);
        Matrix* multiply(Matrix * m);
        Matrix* inverse();
        bool read(char * file_name);
        void display(char * matrix_name);
        ~Matrix();
};

#endif

Conclusion :


calcul de l'inverse prochainement

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

FasteX_
Messages postés
44
Date d'inscription
lundi 5 juillet 2004
Statut
Membre
Dernière intervention
29 février 2008
-
Je suis parfaitement d'accord avec ctx_man et CptPingu. Les bonnes pratiques, ce n'est pas nécessairement ce qui est le plus rapide, mais c'est ce qui est le plus efficace à entretenir. À moins d'une différence de vitesse considérable, le mieux c'est d'utiliser les "features" actuels du langage et d'optimiser les algorithmes plutôt que d'utiliser quelque chose qui est moins supporté.

Ce n'est pas un prestige nécessairement de mettre une source sous le flag "expert", ça fait juste dire que les débutants et intermédiaires n'ont pas en moyenne les bagages qui faut pour bien comprendre. Souvent j'aime mieux réfléchir à une approche "débutante" pour un problème complexe donné. Ça permet d'aller chercher plus de monde et de partager des idées plus rapidement.
ctx_man
Messages postés
285
Date d'inscription
mardi 28 décembre 2004
Statut
Membre
Dernière intervention
20 janvier 2013
-
Un peu sévère le CptPingu, mais il a pas tort du tout ^^'
Personnellement ca a tendance aussi a me titiller quand je vois une source relativement basique être publié en "expert".
Je compte même plus les caculettes a deux francs (oui, des francs, ca ne vaut même pas des euros) en mode console et qui sont notée expert alors qu'elle ne peuvent même pas résoudre une expression un chouilla complexe ( ex: "3*15+4-(12/3)"). Ou quand elle le peuvent, le code qui le fait est une atroce succession de if/while imbriqué.
Ca me titille tellement que je vais finir par en poster une qui avec un parseur d'expression, utilisant massivement la stl et les foncteurs, peut être même boost::spirit, boost::phoenix et capable de dessiner les courbes correspondantes à des équation, et je metterai ca en "débutant", juste histoire de faire complètement l'inverse.

M'enfin, au final je sais pas si j'aurais le courage de perdre mon temps a faire ca...

La source ici n'est clairement pas a destination des experts, rien de bien compliqué, des mélanges C et C++, etc...
Au passage, il manque le constructeur par copie et la surcharge de l'opérateur '=', la classe n'est pas fiable en l'état.
Sans constructeurs par copie, le compilo en met un qui fait une copie "brutale" de la mémoire. Et donc il copie les pointeurs plutôt que de ré-allouer.
exemple :
Matrix* m1 new Matrix(2); // le constructeur fait m_matrix new double*[2]; etc...
Matrix m2 = *m1; // il y a copie, ca ne refait pas l'allocation
delete m1; // m2::m_matrix pointe sur une zone dés allouée et donc invalide.

Il y a des fopen mais aucun close du fichier, la classe possède un membre m_log jamais utilisé (celui dans le constructeur est local au constructeur et non a la classe, de plus il n'est pas utilisé). Aucune vérification n'est faite sur la réussite de l'ouverture du fichier, des allocations, du respect des bornes des paramètres (par exemple, on peut écrire Matrix* m = new Matrix(-12); ce qui vaudra une belle exception non contrôlée), etc...
En prime, les opération allouent une nouvelle matrice qu'il retournent par pointeur, autrement dit ils transfèrent la propriété a l'appelant qui doit donc impérativement penser à détruire le résultat.

J'ai pas envie de prendre le temps de monter un code pour comparer la vitesse de la STL et de la libc, j'y crois pas une seconde, sauf en mode débug. Mais une fois compilé avec les flag d'optimisation qu'il faut, je veux bien croire qu'il y ai un écart, mais certainement pas un ratio de 1000.
Et ce n'est pas "des habitudes que certains jugent bien", c'est juste ce qu'il faut faire. Le fait est que stdio c'est du C, pas du C++, qu'il soit possible d'appeler du C en C++ n'est pas une raison pour utiliser le C plutôt que le C++. Dans ce cas autant tout faire en C. C'est comme en .Net, on peut appeler du C via du p/invoke, ca veut pas dire qu'on doit s'amuser à utiliser stdio plutôt que System.IO.File.
cptpingu
Messages postés
3801
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
15 novembre 2019
90 -
>> je voix que tu as des confusions entre ce qui est habituelle et ce qui est obligatoire :)
Te conseiller d'adopter de bonnes pratiques n'est en rien une confusion.

>> les règles que tu me propose sont juste des habitudes que certains jugent bien.
Effectivement. Mais en quoi ne pas avoir de conventions est une bonne chose ? Je ne dis pas de suivre une convention pré-établie, mais d'en avoir au moins une.
Ici, on ne peut différencier facilement un attribut d'un argument. Si une convention a été établie, ce n'est pas peut être pas par hasard, non ?

>> pour la STL il ne me convient pas car sa lecture des fichiers est assez longue(1000 fois que stdio
>> tu pourra tester) or je vous faire les calcules pour des matrices aussi grand que possible stockés dans des fichiers quelque parts.
1) La STL n'est pas juste pour lire des fichiers... Y a aussi des conteneurs templatés qui sont particluièrements efficaces (en perfs).
2) Si tu parles de lenteur dans les stream, je rappelle qu'avant de dire que c'est lent, on se renseigne. La perte de perf est dû à la synchronisation avec les streams de la lib C. Désactiver cette synchro, résoud ce problème de perfs:
http://www.cplusplus.com/reference/iostream/ios_base/sync_with_stdio/
3) Si tu cherches à avoir des perfs extrêmement bonnes, ce n'est sûrement pas avec un FILE et un fscanf que tu y arriveras. Il te faudra aller un peu plus bas niveau que ça pour obtenir les meilleurs perfs. Je pense notamment à des conversions via modp_atoi (fonctions non standards issues du projet modp, trouvable sur google code).

Tout ça pour dire que ton argument envers la STL n'est pas justifié.

>> je préfère retourner un pointeur si on veut faire une dés-allocation avec celui-la.
Et le principe de RAII (Resource Acquisition Is Initialisation) ? C'est le principe le plus important du C++. Un objet qui alloue de la mémoire est chargé de sa destruction. Renvoyer un pointeur au lieu d'une référence ne peut pas se justifier par une soi-disante possiblité de désallocation. De plus, la référence est utile pour chaîner des actions.

>> je crois que l'option modifier existe pour les sources pour démarrer d'une version et de progresser ensuite tu pourra suivre l'avancement de cette source si tu veux
C'est vrai. C'est utile pour modifier une source, pour apporter des corrections par exemple. Mais pas pour finir un travail à peine commencé. Il y a les DCVS (git, svn, mercurial, etc...) pour ça. Bien différencier: corriger un travail et finir un travail.

>> désolé mais une critique commence par un salut ou un bonjour (pas par "Expert => Débutant.")
Pas forcément. J'aime aller droit au but. De plus, les sources ne sont pas le forum, ni une conversation privée. Je donne mon avis sur un code comme je le ferais sur un texte.

>> suivi par des remarques sur le code et sa conception.
Evidemment qu'il y a des remarques sur le code et la conception. D'une part tu postes dans la section ou l'on critique les codes, d'autre part, les remarques sont nécessaires, ton code étant améliorable sur de nombreux points.
elkasimi2007
Messages postés
20
Date d'inscription
lundi 19 mars 2007
Statut
Membre
Dernière intervention
26 mai 2011
-
je voix que tu as des confusions entre ce qui est habituelle et ce qui est obligatoire :)
les règles que tu me propose sont juste des habitudes que certains jugent bien.

pour la STL il ne me convient pas car sa lecture des fichiers est assez longue(1000 fois que stdio
tu pourra tester) or je vous faire les calcules pour des matrices aussi grand que possible stockés dans des fichiers quelque parts.

je préfère retourner un pointeur si on veut faire une dés-allocation avec celui-la.

je crois que l'option modifier existe pour les sources pour démarrer d'une version et de progresser ensuite tu pourra suivre l'avancement de cette source si tu veux

désolé mais une critique commence par un salut ou un bonjour (pas par "Expert => Débutant.") suivi par des remarques sur le code et sa conception.

de toutes façon je croix que la discussion était comme même fructueuse malgré ton premier message agressif.

à bientôt
cptpingu
Messages postés
3801
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
15 novembre 2019
90 -
> je ne pense pas que je suis débutant
Je ne pense pas que tu sois expert non plus...
De plus, on parle ici de la difficulté de la source et non du programmeur. Tu peux être expert en C++ et poster une source facile d'accès. Le niveau sera alors "destiné" aux débutants. Or la source que tu as posté est assez basique et aisément compréhensible par un débutant (pas de template, de redéfinition d'opérateur, etc...).

> j'ai posé ma propre conception de la classe matrice qui consiste en l'ajout de logger et la possibilité de lire a partir d'un stream
Tu lis des valeurs dans un fichier, rien d'extra-ordinaire, c'est du déjà vu (cf les 50 autres matrices que tu trouveras sur ce site). Le logger ? A part une variable qui traine et qui s'appelle logger, y a pas vraiment de log. De plus, un système de log est utile s'il est externe aux classes, et facilement insérable sans être intrusif. Ici, on a une composition entre log et matrice. Ce qui, en conception logiciel, n'est pas du tout une bonne solution.
De même, la classe display ne devrait pas prendre d'argument. C'est à l'utilisateur d'écrire ce qu'il veut avant, et cette méthode ne devrait faire que son travail: afficher la matrice. C'est aussi une maladresse de conception.
Je rajouterais aussi que le mélange C et C++ n'est pas du plus bel effet. A moins que tu es une contrainte (imposée ou choisie), tu ne devrais pas avoir de FILE, de "**" ou de scanf. Une utilisation de la STL aurait été plus judicieuse.
Par convention, une attribut de classe est différencié d'un argument (par exemple et le préfixant d'un _ ).
Pourquoi passer des pointeurs, là où une référence aurait été bien plus adaptées ?
Pourquoi n'y-t-il aucun const ?
Pourquoi ne pas utiliser la liste d'intialisation au lieu d'affecter les valeurs dans le constructeur ?

Au final:
- Pas d'originalité par rapport à ce qui est posté.
- Une qualité de code qui n'est pas exceptionnelle (Tu dis ne pas être débutant, mais en tout cas tu fais des erreurs de débutant)

> finalement mon travail est encore en cours ..
Pourquoi publier, si tu n'as pas fini ? Une source doit au moins être finalisé avant d'être postée...

> je ne crois pas que je stocke ma source sur ton serveur.
Non, mais dès le moment ou tu publies une source dans cette section, tu acceptes d'être soumis à la critique.

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.