Problème avec les matrices

Fermé

secret Messages postés 7 Date d'inscription lundi 6 août 2012 Statut Membre Dernière intervention 25 janvier 2013 - 24 janv. 2013 à 20:56
mamiemando Messages postés 33093 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 4 mai 2024 - 25 janv. 2013 à 22:36

Bonsoir,
j'arrive pas a corriger mon programme est ce que vous pouvez m'aider.

voila mon programme:
____________________________main.cpp_____________________________________
#include <iostream>
#include <cstdlib>
#include "AlgorithmeDePrim.h"
using namespace std;

int main()
{
matrice m;
int n;
cout<<"veuillez entrez le sommet de depart:";
cin>>n;
m.matrice(n);
m.saisir();
m.afficher();

return 0;
}
_______________________________________________________________________
#include "AlgorithmeDePrim.h"

matrice::matrice(int d)
{
DIM=n;
m = new int*[DIM];
}
void matrice::saisir()
{
int i,j;
for (i=0;i<DIM;i++)
{
for(j=0;j<DIM;j++)
{
cout<<" entrer "<<"M["<<i<<"]["<<j<<"]:";
cin >>m[i][j];
}
cout<<endl;
}
}

void matrice::afficher(){
int i,j;
for (i=0;i<DIM;i++)
{
for(j=0;j<DIM;j++)
{
cout<<m[i][j]<<"\t";
}
cout<<endl;
}
}

void matrice::liberer()
{
delete [] m;
}
______________________________header__________________________________
#ifndef ALGORITHMEDEPRIM_H_INCLUDED
#define ALGORITHMEDEPRIM_H_INCLUDED

class matrice
{
int DIM;
int **m;
public:
matrice(int);
void afficher ();
void saisir();
void liberer();

};

#endif // ALGORITHMEDEPRIM_H_INCLUDED

A voir également:

Problème avec les matrices
Matrices excel ✓ - Forum Excel
Matrices pascal - Forum Pascal
Application pour calculer les matrices - Télécharger - Calcul & Conversion
Multiplication de matrices ✓ - Forum Python
Algorithme produit de deux matrices ✓ - Forum Algorithmes / Méthodes

7 réponses

Réponse 1 / 7

mamiemando Messages postés 33093 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 4 mai 2024 7 751
24 janv. 2013 à 21:46

Truc pas clair, pourquoi ta matrice est un tableau 1D dans le constructeur et un tableau 2D dans le reste du code ?

De deux choses l'une
- soit tu encodes ta matrice dans un tableau int * et la valeur de la case (i,j) est stockée dans la case i*nb_colonne + j (si i est le numéro de ligne)
- soit tu encodes ta matrice dans un tableau int ** et il faut allouer nb_lignes tableaux int * de nb_colonnes cases.

Au moment de libérer la mémoire, tout dépend de l'approche que tu as retenue :
- pour la première approche, on désalloue simplement le tableau int *
- pour la seconde approche, on désalloue d'abord les nb_lignes tableaux int *, et ensuite on désalloue le tableau int **.

Bonne chance

Réponse 2 / 7

secret Messages postés 7 Date d'inscription lundi 6 août 2012 Statut Membre Dernière intervention 25 janvier 2013
24 janv. 2013 à 23:07

Bonsoir mamiemando?,
merci beaucoup pour votre réponse.
je m'explique
le but de mon programme est de créer une matrice dont la dimension est entré par l'utilisateur ensuite je veux saisir les composante de la matrice puis les affiché

Réponse 3 / 7

mamiemando Messages postés 33093 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 4 mai 2024 7 751
25 janv. 2013 à 10:40

Oui j'ai compris ce que tu voulais faire, mais as-tu compris dans mon message précédent ce qui n'allait pas ?

J'espère que tu as fait un cours sur les pointeurs et les structures sinon la suite risque de paraître assez éloignée de ce que tu as déjà appris.

Pour commencer je te suggère d'écrire une structure de matrice ce sera beaucoup plus lisible :

typedef struct _matrix_t {
  size_t num_rows;
  size_t num_cols;
  int ** values;
} matrix_t;

Ensuite tu écris une fonction par "action" (ce qu'on appelerait des méthodes en C++) par exemple :

matrix_t new_matrix(size_t num_rows, size_t num_cols);
void delete_matrix(matrix_t * matrix);
int get_value(const matrix_t * matrix, size_t i, size_t j);
void set_value(const matrix_t * matrix, size_t i, size_t j, int value);
matrix_t load_matrix();
void print_matrix();

Ceci est proche à ce qu'on mettrait dans un header (matrix.h), mais pour le moment on va raisonner juste sur un fichier (par exemple main.c). Maintenant détaillons le contenu de chaque méthode (ce qu'on mettrait dans matrix.c).

#include <assert.h>
#include <stdlib.h>

matrix_t new_matrix(size_t num_rows, size_t num_cols) {
  size_t i;
  matrix_t matrix;
  matrix.num_rows = num_rows;
  matrix.num_cols = num_cols;
  matrix.values = malloc(sizeof(int) * num_rows);
  for(i = 0; i < matrix.num_rows; ++i) {
    matrix.values[i] = calloc(sizeof(int), num_cols);
  }
  return matrix;
}

void delete_matrix(matrix_t * matrix) {
  size_t i, j;
  for(i = 0; i < matrix->num_rows; ++i) {
    free(matrix->values[i]);
  }
  free(matrix->values);
}

int get_value(const matrix_t * matrix, size_t i, size_t j) {
  assert(i < matrix->num_rows);
  assert(j < matrix->num_cols);
  return matrix->values[i][j];
}

void set_value(const matrix_t * matrix, size_t i, size_t j, int value) {
  assert(i < matrix->num_rows);
  assert(j < matrix->num_cols);
  matrix->values[i][j] = value;
}

// load_matrix, print_matrix

int main() {
  // On alloue la mémoire
  matrix_t m = new_matrix(5, 3);

  // On utilise la matrice
  print_matrix(m);
  set_value(m, 0, 2, 5); // affecte 5 dans m, ligne 0, colonne 2
  print_matrix(m);

  // On désalloue la mémoire
  delete_matrix(m);
  return 0;
}

Si tu as compris ce que j'ai écrit, normalement tu ne devrais pas avoir de difficulté à écrire tes deux fonctions.

Bonne chance

Réponse 4 / 7

secret Messages postés 7 Date d'inscription lundi 6 août 2012 Statut Membre Dernière intervention 25 janvier 2013
25 janv. 2013 à 15:50

merci énormément pour vos explication
tout d'abord je doit travailler avec une classe que j'ai nommé matrice et qui prend 2 instances :
un nombre qui sera la dimension de la matrice (car la matrice elle est toujours carré).
la deuxième instance un tableau multidimensionnel ou seront stocké les valeur de la matrice car je vais les utiliser par la suite.
dans le constructeur de la classe, il y aura un message qui demande a l'utilisateur d'entré un nombre .
la taille du tableau qui va contenir les composante dépendra de ce nombre.
la fonction saisir permet de récupérer les éléments de la matrice.
le fonction affiché permet de les affiché.
j'espère que vous avez compris ce que je veux exactement

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question

Réponse 5 / 7

mamiemando Messages postés 33093 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 4 mai 2024 7 751
Modifié par mamiemando le 25/01/2013 à 21:35

Ben si tu dois faire des classes C++ tu peux faire encore plus simple et directement utiliser des std::vector, en plus ça te fera des matrices génériques.

matrix.hpp

#ifndef MATRIX_HPP 
#define MATRIX_HPP 

#include <vector> 
#include <ostream> 

template <typename T> 
class matrix_t { 
    private: 
        std::size_t num_rows; 
        std::size_t num_cols; 
        std::vector<std::vector<T> > values; 
    public: 
        matrix_t(){} 

        matrix_t( 
            std::size_t num_rows0, 
            std::size_t num_cols0, 
            const T & t0 = T() 
        ): 
            num_rows(num_rows0), 
            num_cols(num_cols0) 
        { 
            values = std::vector<std::vector<T> >(num_rows, std::vector<T>(num_cols, t0)); 
        } 

        inline std::size_t get_num_rows() const { 
            return num_rows; 
        } 

        inline std::size_t get_num_cols() const { 
            return num_cols; 
        } 

        inline std::vector<T> & operator[](std::size_t i) { 
            return values[i]; 
        } 

        inline const std::vector<T> & operator[](std::size_t i) const { 
            return values[i]; 
        } 
}; 

template <typename T> 
std::ostream & operator << (std::ostream & out, const matrix_t<T> & matrix) { 
    for(std::size_t i = 0; i < matrix.get_num_rows(); ++i) { 
        for(std::size_t j = 0; j < matrix.get_num_cols(); ++j) { 
            out << matrix[i][j] << '\t';  
        } 
        out << std::endl; 
    } 
    return out; 
} 

template <typename T> 
matrix_t<T> operator + ( 
    const matrix_t<T> & a, 
    const matrix_t<T> & b 
){ 
    if (a.get_num_rows() != b.get_num_rows() 
    ||  a.get_num_cols() != b.get_num_cols()) throw; 

    std::size_t num_rows = a.get_num_rows(); 
    std::size_t num_cols = a.get_num_cols(); 
    matrix_t<T> c(num_rows, num_cols); 
    for(std::size_t i = 0; i < num_rows; ++i) { 
        for(std::size_t j = 0; j < num_cols; ++j) { 
            c[i][j] = a[i][j] + b[i][j]; 
        } 
    } 
    return c; 
}     

template <typename T> 
matrix_t<T> operator * ( 
    const matrix_t<T> & a, 
    const matrix_t<T> & b 
){ 
    std::size_t num_rows = a.get_num_rows(); 
    std::size_t num_cols = a.get_num_cols(); 
    if (a.get_num_cols() != b.get_num_rows()) throw; 
    matrix_t<T> c(a.get_num_rows(), b.get_num_cols()); 
    for(std::size_t i = 0; i < a.get_num_rows(); ++i) { 
        for(std::size_t j = 0; j < a.get_num_cols(); ++j) { 
            for(std::size_t k = 0; k < b.get_num_cols(); ++k) { 
                c[i][k] += a[i][j] * b[j][k]; 
            } 
        } 
    } 
    return c; 
} 

template <typename T> 
bool operator == ( 
    const matrix_t<T> & a, 
    const matrix_t<T> & b 
){ 
    if (a.get_num_rows() != b.get_num_rows() 
    ||  a.get_num_cols() != b.get_num_cols()) throw; 

    std::size_t num_rows = a.get_num_rows(); 
    std::size_t num_cols = a.get_num_cols(); 
    matrix_t<T> c(num_rows, num_cols); 
    for(std::size_t i = 0; i < num_rows; ++i) { 
        for(std::size_t j = 0; j < num_cols; ++j) { 
            if (a[i][j] != b[i][j]) return false; 
        } 
    } 
    return true; 
}     


template <typename T> 
matrix_t<T> identity(std::size_t n) { 
    matrix_t<T> m(n, n); 
    for(std::size_t i = 0; i < n; ++i) m[i][i] = T(1); 
    return m; 
} 

#endif

main.cpp

#include <iostream> 
#include "matrix.hpp" 

int main() { 
    matrix_t<int> m1(3, 5, 1); 
    m1[1][2] = 7; 
    matrix_t<int> m2(3, 5, 2); 
    matrix_t<int> m3 = m1 + m2; 
    matrix_t<int> m4(3, 3, 4); 
    m4[2][1] = 5; 
    matrix_t<int> i3 = identity<int>(3); 
    matrix_t<int> i5 = identity<int>(5); 
    std::cout << "m1 =" << std::endl << m1 << std::endl 
              << "m2 =" << std::endl << m2 << std::endl 
              << "m3 =" << std::endl << m3 << std::endl 
              << "m4 =" << std::endl << m4 << std::endl 
              << "id =" << std::endl << i3 << std::endl 
              << std::endl 
              << "m4 * m1 =" << std::endl << m4 * m1 << std::endl 
              << "i3 * m1 == m1 ? " << (i3 * m1 == m1) << std::endl 
              << "m1 * i5 == m1 ? " << (m1 * i5 == m1) << std::endl 
              << std::endl; 
    return 0; 
}

... ce qui donne à l'exécution :

m1 =
1       1       1       1       1
1       1       7       1       1
1       1       1       1       1

m2 =
2       2       2       2       2
2       2       2       2       2
2       2       2       2       2

m3 =
3       3       3       3       3
3       3       9       3       3
3       3       3       3       3

m4 =
4       4       4
4       4       4
4       5       4

id =
1       0       0
0       1       0
0       0       1


m4 * m1 =
12      12      36      12      12
12      12      36      12      12
13      13      43      13      13

i3 * m1 == m1 ? 1
m1 * i5 == m1 ? 1

Dans ce code comme tu peux le voir j'ai défini sur la classe matrix générique (ici utilisée avec des int, mais que tu pourrais utiliser avec n'importe quoi d'autre).

J'ai défini les opérateurs +, *, et <<. Dans ton cas il ne te reste plus qu'à implémenter >> ce qui devrait être une formalité si tu as pris le temps de comprendre.

Bonne chance

Réponse 6 / 7

secret Messages postés 7 Date d'inscription lundi 6 août 2012 Statut Membre Dernière intervention 25 janvier 2013
25 janv. 2013 à 22:23

bonsoir mamiemando ,
mon niveau en C++ est très modeste ,
j'ai pas étudier les Template ni les matrices génériques.
j'ai testé votre code il marche a merveille mais j'ai rien compris.
si vous pouvez me donné un coup de pouce en m'expliquant qu'est ce que je doit modifier dans mon code afin qu'il marche

Réponse 7 / 7

mamiemando Messages postés 33093 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 4 mai 2024 7 751
25 janv. 2013 à 22:36

Moi je te conseille plutôt d'apprendre les templates, ce sera du temps mieux investi ;-) J'avoue ne pas avoir vraiment le mental pour corriger le code que tu proposes..

Pour rendre le code que je t'ai donné "plus compréhensible", tu peux remplacer partout matrix_t<int> par matrix_t et enlever tous les "template <typename T>", et remplacer tous les T restants par int.

Si à l'issue de ça le code n'est toujours pas clair, je t'invite à regarder ton cours de C++ car je suppose que tu as vu comment déclarer des constructeurs, des méthodes et des opérateurs. Si ce n'est toujours pas clair tu peux repartir du code C que j'ai donné dans mon précédent message et le rendre plus "C++", normalement c'est très simple.

Bonne chance

Discussions similaires

produit de deux matrices sous python

algoritheme pour calculer le produit de deux matrices de degré n

produit & somme de deux matrice carree(urgen)

Comment faire l'addition de deux matrices en c a l'aide d'une fonction

les matrices en algorithme

Discussions similaires

Newsletters