argument d'une fonction

bonjour,

j'ai une question qui va vous sembler très bête mais bon...J'ai besoin de faire une fonction ayant un tableau multidimentionnel en paramètre. Qqn pourrait-il m'aider? J'ai fait:
void fonction(const int origine,const int nbNoeuds, const int distance[][]);
Merci beaucoup
Thomas

seule la première dimension peut être inconnue, les autres doivent êtres spécifiées...
void fonction(const int distance[][6]);

autre solution :

void fonction(const int* distance, int dim1, int dim2)
{
// case [x][y]
  int val = *(distance+dim2*y+x);
}
=> ce code montre pourquoi le compilo avait besoin de dim2 pour générer du code mais pas dim1


appel :
int tab[5][6];
fonction(&tab[0][0], 5, 6);

Merci pour ta réponse. Je l'ai essayé et j'ai encore un petit problème. Je te mets une partie de mon code:
bool bellmanFord(int origine, int nbNoeuds, float **distance)
        {
            int i,u,v;
            float d[nbNoeuds];
            int pi[nbNoeuds];
            ARETE a;
            vector<ARETE>::const_iterator itr = aretes.begin();
              vector<ARETE>::const_iterator fin = aretes.end();
                    /*Initialisation*/
            for(i=0;i<nbNoeuds;i++)
            {
                d[i] = INT_MAX;
                pi[i] = nbNoeuds + 1;
            }
           
            d[origine] = 0;

            for(i=0;i<nbNoeuds - 1 ; i++)
            {
                while(itr != fin)
                {
                    a = *itr;
                    if(d[a.destination] > d[a.origine] + distance[a.origine][a.destination])
                    {
                        d[a.destination] = d[a.origine] + distance[a.origine][a.destination];
                        pi[a.destination] = a.origine;
                    }
                    itr ++;
                }
            }
           
            itr = aretes.begin();
            while(itr!=fin)
            {
                a = *itr;
                if(d[a.destination] > d[a.origine] + distance[a.origine][a.destination])
                    return false;
                itr ++;
            }
           
            return true;
        };

Appelle de la fonction:
if(g.bellmanFord( 0 , 5 , &distance[0][0]))
        cout << "TRUE";
    else
        cout << "FALSE";

erreur sous KDE
main.cpp:776: error: no matching function for call to 'Graphe::bellmanFord(int, int, float*)'
Graphes.h:83: note: candidates are: bool Graphe::bellmanFord(int, int, float**)

distance est un pointeur simple (le multi-dimension est en fait une zone continue de lignes d'ou la nécessité de savoir la taille d'une ligne)

merci,
lorsque je change la specification comme ceci:
bool bellmanFord(int origine, int nbNoeuds, float *distance, int borneRoutage);
j`ai les erreurs suivantes:
Graphes.h: In member function 'bool Graphe::bellmanFord(int, int, float*, int)':
Graphes.h:105: error: invalid types 'float[int]' for array subscript
Graphes.h:107: error: invalid types 'float[int]' for array subscript
Graphes.h:118: error: invalid types 'float[int]' for array subscript

Merci beaucoup pour ton aide
Thomas

peux-tu mettre le code des lignes erronées ?

105: if(d[a.destination] > d[a.origine] + distance[a.origine][a.destination])
107: d[a.destination] = d[a.origine] + distance[a.origine][a.destination];
118:if(d[a.destination] > d[a.origine] + distance[a.origine][a.destination])
776 (du main):if(g.bellmanFord( 0 , 5 , &distance[0][0],borneRoutage))

Graphes.h:105: error: invalid types 'int[int]' for array subscript
Graphes.h:107: error: invalid types 'int[int]' for array subscript
Graphes.h:118: error: invalid types 'int[int]' for array subscript
main.cpp: In function 'void heuristique()':
main.cpp:776: error: no matching function for call to 'Graphe::bellmanFord(int, int, float*, int&)'
Graphes.h:83: note: candidates are: bool Graphe::bellmanFord(int, int, int*, int)
make: *** [main.o] Error 1

code:
bool bellmanFord(int origine, int nbNoeuds, int *distance, int borneRoutage)
        {
            int i,u,v;
            float d[nbNoeuds];
            int pi[nbNoeuds];
            ARETE a;
            vector<ARETE>::const_iterator itr = aretes.begin();
              vector<ARETE>::const_iterator fin = aretes.end();
                    /*Initialisation*/
            for(i=0;i<nbNoeuds;i++)
            {
                d[i] = INT_MAX;
                pi[i] = nbNoeuds + 1;
            }
           
            d[origine] = 0;

            for(i=0;i<nbNoeuds - 1 ; i++)
            {
                while(itr != fin)
                {
                    a = *itr;
                    if(d[a.destination] > d[a.origine] + distance[a.origine][a.destination])
                    {
                        d[a.destination] = d[a.origine] + distance[a.origine][a.destination];
                        pi[a.destination] = a.origine;
                    }
                    itr ++;
                }
            }
           
            itr = aretes.begin();
            while(itr!=fin)
            {
                a = *itr;
                if(d[a.destination] > d[a.origine] + distance[a.origine][a.destination])
                    return false;
                itr ++;
            }
           
            return true;
        };

Appelle de la fonction:
float distance[nbNoeuds][nbNoeuds];
...
if(g.bellmanFord( 0 , 5 , &distance[0][0],borneRoutage))
        cout << "TRUE";
    else
        cout << "FALSE";

Merci

Mais là tu n'as rien changer de ce que j'ai dit plus haut.

La fonction bellmanFord doit avoir le format suivant :
bellmanFord(int origine, int nbNoeuds, floayt* distance, int dim1, dim2, int borneRoutage)

distance[x][y] à remplacer par :
*(distance+y*dim2+x)

appeler comme suit :
float distance[nbNoeuds][nbNoeuds];
bellmanFord( 0 , 5 , &distance[0][0],  nbNoeuds, nbNoeuds, borneRoutage)

Etant donné que nbNoeuds semble être une variable globale (ou un define), tu peux skipper le passage en param et utiliser la var globale :
bellmanFord(int origine, int nbNoeuds, floayt* distance, int borneRoutage)
*(distance+y*nbNoeuds+x)
bellmanFord( 0 , 5 , &distance[0][0],  borneRoutage)

désolé je me suis trompé dans les indices des 2 dimensions :

distance[x][y] à remplacer par :
*(distance+x*dim2+y)