passage de matrice dans plusieurs fonctions - Page 1

Voila, j'ai une fonction qui cree une matrice de tailel variable matrice[][3]

j'aimerai que cette fonction me retourne l'adresse de cette matrice ,afin de pouvoir la reutiliser dans d'autrzes fonctions

j'ai penser a return matrice[0]

par contre, comment dois-je declarer la matrice, ainsi que son pointeur?

merci

ben, si elle est de taille variable, il va falloir utiliser l'allocation dynamique (fonction malloc() en C, opérateur new en C++...)

Tu as deux possibilités pour une matrice de taille de ligne (colonne on s'en fout) variable :
1) tu alloues un tableau de XxY cases et tu y accèdes en faisant toi même le calcul
2) tu alloues X tableaux de Y cases, plus un tableau contenant X pointeurs vers ces X tableaux.

La solution 1) est plus compacte et plus propre, mais un peu plus chiante à écrire. Ca donne qqc comme ça

typedef float * matrix;
#define INDEX(l, c, h, w)   ((l)*(w)+(c))

matrix i_want_a_matrix_please(int h, int w) {
    int l, c;
    matrix result;

    result = (matrix)malloc(h * w * sizeof(int));
    for (l = 0; l < h, ++l)
        for (c = 0; c < w; ++c)
            result[INDEX(l, c, h, w)] = 0.0f;
    return resultat;
}

w => width (largeur)
h => height (hauteur)
l => line
c => column

Note que c'est volontairement très lent, histoire de montrer comment accéder aux cases (un memset aurait fait le boulot très bien pour mettre la matrice à 0).

Note que si tu compiles avec GCC, tu peux tirer profit de l'utilisation de la macro pour vérifier que tu ne débordes pas de ta matrice =>

#ifdef __GNUC__
#define INDEX(l, c, h, w)   ({assert(l >=0); assert(c >= 0); assert(l < h); assert(c < w); (l)*(w)+(c);})
#else
#define INDEX(l, c, h, w)   ((l)*(w)+(c))
#endif

Hmmm en termes de performances par contre, si tu accèdes souvent à des éléments non consécutifs de ta matrice, le calcul de l'index va plomber tes performances par rapport à la méthode 2. A l'inverse, la méthode 1 profite bien mieux du cache que la méthode 2, dès lors que tu fais des traitements séquentiels.

L'idéal c'est encore la méthode 1 avec une matrice ayant des dimensions correspondant à des puissances de deux. Tu combines alors les données compactes et un faible temps d'accès.