matrices et c++

Bonjour,

je debute en c++ et j'ai quelques problemes avec les tableaux...

D'abord, y a t'il un moyen d'avoir pour resultat d'une fonction un tableau ? Parce que des declarations de type :

int[][] = mafonction();
ca marche pas

D'autre part, quand on declare une classe, peut on declarer une matrice sans savoir sa taille ?
je voulais quelque chose de type double mat[n][m] avec n et m inconnus ou disons declares dans le constructeur. Pour eviter les problemes de compilation j'ai declare mat** mais voila , au moment de l'initialisation, je ne peux visiblement pas faire :
new double[n][m]
donc pour initialiser la table je passe dans toute la matrice et comme elle sont grosses, je trouve pas ca tres efficace... Est ce que quelqu'un pourrait m'aider a faire quelque chose de plus propre ?

Al

zezette

En 100% dynamique ca donne:

float** mat;
int n=10;  // lignes
int m=12;  // colonnes

mat = new float*[m]; // colonnes

for (DWORD i=0; i<m; i++)  // colonnes
{
mat[i] = new float[n];  // pour chaque colonne, on alloue n elements
}

et apres:
mat[5][6] = 4.02f;   // colonne 5 ligne 6

Attention a la desallocation !

C'est l'inverse "pour chaque colonne, on alloue n elements" -> "pour chaque ligne, on alloue n elements"
Un simple std::valarray<double> v(n*m) est beaucoup mieux, et bourquoi s'embeter avec des new et des delete ?
Il y a des bibliothèque ou c'est deja fais (boost, mtl, blitz++).

C`est purement arbitraire.
Ici j`alloue m pointeurs sur des tableaux, 1 par colonne.
Puis pour chaque colonne j`alloue un tableau de n float (car n est le nombre de ligne).
J`ai fait une boucle sur m = mb colonnes.

On aurait aussi pu allouer n pointeurs sur des tableaux pour les lignes, puis allouer m float par ligne.

Il y a effectivement des bibiotheques pour les matrices.
Mais parfois c`est plus rapide de les refaire plutot que de chercher comment elle fonctionnent.

Oui je suis d'accord tu peux choisir, mais dans un vrai tableau multidimensionnelle les données sont organisée en ligne et l'indexation d'une matrice se fais en (ligne, colonne). Il faut garder la meme sémantique pour un tableau de pointeurs par seprit de modularité.

On est pas obliger d'utiliser une bibliotheque mais si c'est pour refaire autant bien faire les choses.
Un truc dans ce genre la:

#include <valarray>
#include <cstddef>

template <typename Type>
class matrix
{
public:
    typedef std::size_t size_type;
    ...
private:
    std::valarray<Type> _data;
    size_type _nLines;
    size_type _nColumns;
public:
   ...
   pointer operator [] (size_type line)
   {
         return & data[line * _nColumns];
   }
   ...
};

Google -> "MTL" pour les matrices.

Et la rendre "STL compliant" pour pouvoir beneficier des nombreux algos de la STL.

merci a tous je vais essayer de faire un truc un peu plus propre que ce que j'avais :)

zezette

Pour une matrice dynamique en utilisant malloc voici une exemple: int nbr_l,nbr_c;//nombre de ligne et de colonne float **Mat cin>>nbr_l;//lire le nombre de lignes cin>>nbr_c;//lire le nombre de colonnes Mat=(float**) malloc(sizeof(float *)*nbr_l); for(i=0;i