Discussion :

[bubuche87]

bonjour tout le monde.
Je fais du c++ et comme j'ai un petit problème de pointeur, je viens vous embeter ^^.

Bon, pour résumer la situation : j'ai fait une classe en c++ qui permet de creer des matrices. J'ai d'abord commencer par en faire des de taille 4*4 (la classe s'appelant Matrice4) puis j'ai changé tous les "4" en N et j'ai utilisé un define. Ce passage c'est fait sans problème : je pouvais encore les multiplier, les déclarer ect.

Maintenant, je voudrais pouvoir finir cette partie de taille (si je puis dire ) et donc générer une matrice de taille N avec n entré par l'utilisateur.

L'ennui c'est que j'ai cherché comme faire un tableau de n*n élément à l'aide du malloc, mais que dans tous les cas, j'obtiens des dépassement mémoire, et mon programme plante.

Je voulais donc savoir si vous aviez une idée de comment faire en C++ pour pouvoir retoucher cette partie sans devoir reprendre tout le code (genre en passant pas les alias, vu que la taille de la matrice est déterminée à la création).

Je vous met l'"en-tête" de ma classe, si vous avez besoin d'info sur telle ou tele méthode, vous demandez

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
#ifndef DEF_MATRICE
#define DEF_MATRICE
#define N 5
 
class Matrice
{
  public:
 
    Matrice();
    Matrice(unsigned int taille);
    Matrice(unsigned int taille, std::string type); //sert à creer des matrice de type ide ou autre
    //Matrice(unsigned int nbLigne, unsigned int nbColonne);//dans le futur, crées des matrices non carrées
    ~Matrice();
 
    void setElt(unsigned int ligne, unsigned int colonne, int value);
    int getElt(unsigned int ligne, unsigned int colonne);
    void affiche();
 
    void displayError(std::string error);//centralisation des message d'erreur, pour un meilleur controle du comportement (tout désactiver , attendre l'appui d'une touche)
 
    bool T1(int ligne, int value);
    bool T2(int ligne1, int ligne2);
    bool T3(int ligne1, int ligne2, int value);
 
 
    Matrice operator+(const Matrice matrice);//addition de matrice
    Matrice operator*(const Matrice matrice);//multiplication de matrice
    Matrice operator*(int valeur);//multiplication par un scalaire
    Matrice operator/(int valeur);//division par un scalaire
 
 
  protected:
 
    bool initialise(unsigned int nb_ligne, unsigned int nb_colonne);//prévu pour réserver l'espace mémoire, ne marche pas
 
 
    int **m_elt;// avant : m_elt[N][N]
    int m_largElt;//sert pour l(affichage, pour aligner tous les nombres il faut connaitre celui qui prend le plus de caractères.
    int m_nbLigne;
    int m_nbColonne;
 
 
};
 
 
#endif

[befalimpertinent]

[...]L'ennui c'est que j'ai cherché comme faire un tableau de n*n élément à l'aide du malloc, mais que dans tous les cas, j'obtiens des dépassement mémoire, et mon programme plante.

Je voulais donc savoir si vous aviez une idée de comment faire en C++ [...]

c++, malloc -->2 mots qui ne vont pas ensemble

E, c++ on utilise new et delete

Si tu as toujours un pb après ça montre nous justement le code où tu alloues ta mémoire

[Sylvain Togni]

Je dirais même plus, en c++ on utilise std::vector pour la gestion de la mémoire, c'est plus facile à utiliser que new/delete.

[Luc Hermitte]

La c'est bien.
Pour les vecteurs certes, mais quitte à faire cet exo de ré-invention de roue (ce n'est pas comme s'il existait profusion de bibliothèques matricielles), autant aller jusqu'au bout et gérer la mémoire à la main.

[Alp]

Voir même écrire les instructions machine...

Bref, si les deux dimensions sont fixes, tu peux utiliser boost::array.

[stephdim]

Je dirais même plus, en c++ on utilise std::vector pour la gestion de la mémoire, c'est plus facile à utiliser que new/delete.

Bref, si les deux dimensions sont fixes, tu peux utiliser boost::array.

Et puis quoi encore ?

un simple

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
new int [m_nbLigne*m_nbColonne];

fait largement l'affaire et est bien plus performant que n'importe quelle autre solution basée sur des lib stl, boost et j'en passe...

suffit de surcharger l'opérateur () pour faciliter l'accès au tableau

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
int& operator () (int col,int row)
{
  return m_elt[row*m_nbColonne+col];
}
 
int operator () (int col,int row) const
{
  return m_elt[row*m_nbColonne+col];
}

avec m_elt de type int* et non int**

c++, malloc -->2 mots qui ne vont pas ensemble

le malloc() est encore très pratique en c++ pour une seule raison : c'est la possibilité d'utiliser realloc() - c'est toujours mieux que de faire 2 new différents, un memcpy et un delete quand on veut agrandir une zone mémoire surtout si c'est faisable sur place par la CRT

d'ailleurs le new et delete donne sur malloc() et free() (s'ils ne sont pas surchargés ... )

[Montag]

Voir même écrire les instructions machine...

Bref, si les deux dimensions sont fixes, tu peux utiliser boost::array.

Il aurait peut-être fallu que tu lises le post initial plus précisément tu aurais alors remarqué que le but de bubuche87 est de gérer une matrice dont la taille est fournie par l'utilisateur. Ensuite je ne vois pas le mal qu'il y a à vouloir apprendre à gérer la mémoire "à la main". Alors oui dans le cadre professionnel il est préférable d'utiliser std::vector ou boost::array mais visiblement l'objectif de bubuche87 est d'apprendre donc les remarques du style "utilise vector" ou "utilise "boost::array" n'ont à mon avis pas grand intérêt.
Maintenant pour en revenir au sujet qui intéresse bubuche87, si tu tiens absolument à utiliser un int ** tu peux faire quelque chose comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include <new>
 
using namespace std;
 
 
 
int main(void)
{
 
  size_t N=5;
  int **matrix=NULL;
 
  //on alloue l'espace mémoire nécessaire pour la matrice
  matrix=new int *[N];
  for(size_t i=0; i<N; ++i)
    {
      matrix[i]=new int[N];
    }
 
 
  //...
 
 
  //libération de la mémoire
  for(size_t i=0; i<N; ++i)
    {
      delete[] matrix[i];
    }
  delete[] matrix;
 
  return 0;
 
}