Voilà je croyais maitriser la syntaxe élémentaire du c++ et me voilà bloqué sur une con*erie...

J´ai dans mon main, une matrice
int mat[128][128];
et je voudrais pouvoir la passer par adresse à une fonction. sans faire l´horrible truc

void f(int m[128][128]);
//
f(mat);

alors j´ai fait

void f(int** m);
//
f(mat);

mais il ne compile pas...

void f(int** m);
//
f(mat);

--> fait plutot a l´appel :

f(&(mat[0]));

si tu ne veux pas passer comme ceci :
void f(int m[128][]);

ça peut etre une solution (moi j´aime pas les tableaux multidimentionnels )

ouais mais quand le but est de créer une fonction qui renvoie une matrice aléatoire c´est pratique qmeme ! :o)

Dis au fait, JYY, est-ce que tu as actualié le programme que tu fournis avec ton tuto pour créer de fonts ?

Pourquoi utiliser un pointeur de pointeur, sachant que ta matrice est un tableau d´entiers et non un tableau de pointeurs sur des entiers ?

Quelques rapels sur l´analogie pointeurs/tableaux en C et C++ :

Le nom d´un tableau seul est un pointeur constant vers le premier élément du tableau. Exemple, si :

int variable[10];

Les notations suivantes sont parfaitement équivalentes :

"variable" et "&variable[0]"
"*variable" et "variable[0]"
"variable+2" et "variable[2]"
"*(variable+2)" et "variable[2]"

(faut connaitre les notions d´arithmétique des pointeurs)

En outre, ce n´est pas parce que ton tableau fait 2 dimensions qu´il te faut un pointeur double : ca reste un pointeur simple.
Ainsi :

int mat[128][128];
void f(int *m)
{
//...
}

Sachant que, pour obtenir l´élément : m[y][x], il faut faire :

• (m+y*128+x)

Bon mais c´est pas forcément très clair à la relecture du code : la notation matricielle est préférable.

De toutes facons quelque soit la notation que tu emploies, tu est obligé de connaitre la largeur de ton tableau pour accéder aux éléments d´une matrice à 2 dimensions : donc void f(int mat[][128]); est bien (tu peux omettre le premier indice, ce qui prouve une fois encore la profonde analogie pointeurs/tableaux)

Bonus puis qu´on parle des tableaux, saviez vous que l´on peut tout aussibien écrire :

tableau[indice] que indice[tableau] en ANSI C (je sais pas pour le C++...) ?

Légitime un fois encore puisque indice et tableau sont castés en pointeurs cers le type de tableau, additionnés et l´addresse obtenue est déréférencée.
On peut ainsi obtenir des trucs marrants :

y[x[tableau]] Beuarg =D

"variable+2" et "&variable[2]"

Petite omission...

0xFFFF : tu es sur qu´un tableau à deux dimensions est un int* et non pas un int** ?
Je n´en suis pas sur, mais bêtement je dirait le contraire.

Bon je vérifierais demain pour être sûr, je peut me tromper.

Tout a fait sûr : J´en manipule tous les jours ou presque des tableaux à 2 ou 3 dimensions par le biais de pointeurs à une dimension. Encore une fois analogie pointeurs/tableaux.

La norme énonce d´ailleurs explicitement que l´identificateur du tableau seul désigne un pointeur constant vers son premier élément, sans qu´aucune remarque soit faite vis à vis de sa dimension et de la nature du pointeur en découlant.

De toute facon cela reste assez intuitif dans la mesure ou les éléments d´un tableau sont rangés consécutivement en mémoire.

fx a raison, mais il est parfois plus simple d´utiliser **mat pour passer une matrice a deux dimmension que de la passer en faisant *mat et de ce battre en suite avec des règles de calcul pour savoir où l´on est dans la matrice

^^^^^^ dans les analogies, je rajouterai le truc drolatique suivant :

"variable + index" et "index[variable]" (vu que c´est aussi naturellement "index + variable")

ce qui permet d´écrire des trucs drolatiques genre 2[array] ... mouahaha.. bref :D

Ca marche pas
j´arrive pas à compiler autrement que

int mat[128][128];
void f(int m[128][128]);
//
f(mat);
//

le truc de JYY ben ca colle pas non plus...
et mon algo est deja suffisemment compliqué pour ne pas utiliser les pointeurs simples et devoir se casser encore plus la tete pour savoir ou on est...

Si tu fait int mat[128][128], alors tu peux faire comme ca:
void f( int *m )
{
static int delta = 128;
for( int l = 0; l < delta; ++l )
for( int r = 0; r < delta; ++r )
*m++ = 0;
}

int main( )
{
int mat[ 128 ][ 128 ];
f( reinterpret_cast<int*>(mat) );
}

Au passage
void f( int m[128][128] )
{
static int delta = 128;
for( int l = 0; l < delta; ++l )
for( int r = 0; r < delta; ++r )
m[l][r] = 0;
}

int main( )
{
int mat[ 128 ][ 128 ];
f( mat );
}

fonctionne tres bien.

en fait je crois qu´il veut passer un tableau statique de taille variable.
dans ce cas, il est obligé de faire un passage par pointeur et il doit passer les dimension du tableau en parametre.

En fait je dois faire un programme qui génère une matrice aléatoire de dimension nxn (n étant choisi par l´utilisateur et limité à 128 par mon programme) qui soit du type suivant:
Chaque ligne contient une et une seule fois chaque nombre entre 1 et n, chaque colonne contient une et une seule fois chaque nombre entre 1 et n.

Et donc pour ce faire, j´ai fait un procédure à part qui calcule une telle matrice, et que j´appelle dans mon main, pour clarifier le tout quoi.
Pour l´instant j´ai fait mon prog en déclarant ma matrice en dehors du main, mais c´est pas très beau, et très peu interessant pour un plus grand programme. D´autre part, passer toute la matrice d´un coup prend énormément de temps, et ce n´est pas optimal non plus si je veux un jour pouoir calculer beaucoup de matrices d´un coup...

Une solutions serait de d´allouer ton tableau en dehors de ta fonction et de la passer en parametre a ta fonction.
Comme tu es en C++ tu pexu meme utiliser un objet array2D (cherche a tableaux multidimensionnel sur le forum, on en a deja parlé)

PS: on en avait parlé dans creation de jeu il y a un mois et demi

Haaa ca me donne une idée:

struct matrice_d_entiers
{
int m[TAILLE_MAX][TAILLE_MAX];
int dimL; //nbr de lignes
int dimC; //nbr de colonnes
}
typedef struct matrice_d_entiers MatriceInt
//
MatriceInt Mat;
Mat.dimL = Mat.dimC = 128;
//
void f(MatriceInt* M);
//
f(&Mat)

et travailler avec M.m[x][y]

Hééééé mais ca m´a l´air d´etre une bonne idée ca...

C´est un peu du chipotage, mais c´est relativement simple en fait !