[mogg41]

Bonjour à tous.

Je souhaite trier par ordre décroissant chaque ligne d'une matrice. J'ai donc codé une fonction permettant de rechercher le maximum d'une ligne et une autre permettant d'échanger 2 cellules.

Mon problème est lors de la déclaration de mes fonctions. Je souhaite pouvoir trier des matrices de taille différente mais devc++ me rejette:

int recherche_maximum(int matrice[][],int colonne,int premier_element,int dernier_element);
void echange_cellule(int matrice[][],int colonne_a,int ligne_a,int colonne_b,int ligne_b);

il me retourne cette erreur: invalid use of array with unspecified bounds

La seule solution que j'ai trouvé est de fixer le nombre de colonne que possède la matrice passée en paramètre, ce qui m'obligerais à écrire plusieurs fonctions faisant la même chose...

En espérant que vous ayez une piste à me donner, je vous remercie par avance.

Mogg41


PS:2 posts dans l'après midi; j'espère ne pas abusez de votre gentillesse.

[zours]

Le C est assez clair à ce niveau : il n'y a que la dernière dimension d'une matrice que tu peux ne pas spécifier. Toutes les autres doivent l'être.

Donc, généralement, pour gérer des trucs plus complexes comme ce que tu veux faire, on fait des pointeurs et donc des chaînages de structures. Je détaille pas, c'est des concepts de base du C, tu peux en trouver un paquet sur le net en googlant "liste chaînée".

[mogg41]

Je vais googler un coup pour me renseigner sur les "listes chainées".

Merci pour cette piste!

Mogg41

[hypothetik]

Ou alors... tu utilise le fait que le tableau ne soit représenté que dans une seule dimension dans la memoire.

En effet, pour accéder a tab[2][3] en fait tu peux y accéder par tab[2*nbcolonnesdetontableau+3]. Ainsi tu peux passer a ta fonction un tableau a un seul élément.

Inconvénient: c'est un peu lourd manipuler.

a+

[S3cur3D]

Rebonjour mogg,

Donc tu veux manipuler si j'ai bien compris des tableaux à deux dimensions de taille a priori inconnue à la compilation. Ca ne te rappelle rien ?
Si on prends le passage d'arguments du shell au point d'entrée main, c'est bien (int argc, char ** argv) ou (int argc, char * argv[]) qui sont des notations équivalentes.
argv est un tableau de pointeurs vers des tableaux de caractères, ce qui construit finalement une matrice de caractères dont on connait la dimension maximale grâce à argc.
Donc dans ton cas un tableau de pointeurs vers des tableaux d'entiers devrait le faire, à savoir int ** matrice ou int * matrice[] pour les amoureux des crochets, reste donc à passer également en paramètre les deux dimensions pour ne pas aller regarer au-delà des tableaux.


Edit : Désolé au passage du déterrage, mais vu que ce n'était pas poinçonné "Résolu" et que je connais pas mal de gens qui ont mal intégré ce genre de notions en C..

S3cur3D

[mogg41]

Effectivement je n'avais pas modifié le titre en résolu, sûrement un oubli de ma part.

Je m'étais débrouillé autrement pour ce problème car j'avais eu du mal a assimiler ces notions. Il m'a fallu déjà pas mal de temps pour me familiariser avec les pointeurs donc je pense que les tableaux de pointeurs m'en demanderont pas mal aussi, mais je ne désespère pas.

Merci de ta réponse.

Mogg

[_o_]

(int argc, char ** argv) ou (int argc, char * argv[]) qui sont des notations équivalentes.

<chinoiserie>Je ne suis pas d'accord</chinoiserie>

Pour ceux qui n'auraient pas compris : à gauche, argv est un pointeur de pointeur de caractères, à droite il s'agit d'un pointeur sur un tableau de taille indéfinie de caractères (ou le contraire, d'ailleurs). Bon, d'accord, dans la pratique, je ne vois pas de différences (mais il doit bien y avoir des cas tordus dans lequel un compilo râlera sur l'une des formes et pas sur l'autre).

[S3cur3D]

mais il doit bien y avoir des cas tordus dans lequel un compilo râlera sur l'une des formes et pas sur l'autres

A vrai dire, non, puisque par définition les tableaux et les pointeurs sont équivalents au passage vers une fonction. Ainsi, void func(int * vals) est équivalent à void func(int vals[]) et même à void func(int vals[5]).

Pour t'en convaincre, tu peux tout simplement coder 4 fonctions, l'une prenant en paramètre un tableau, l'autre un pointeur, une autre prenant un pointeur de tableau et une dernière un pointeur de pointeur. Ensuite on créé un tableau lambda et on le passe aux deux premières fonctions et son adresse aux deux autres. Un petit coup d'oeil au code assembleur généré montrera que le passage d'argument entre les fonctions 1 et 2 (resp. 3 et 4) se font exactement de la même façon.
La notation [] peut permettre de faciliter la compréhension mais est selon moi trompeuse effectivement.

Enfin bon, j'imagine que ce ne sont pas des considérations qui vont intéresser mogg au final ^^

S3cur3D

[_o_]

Pas d'accord.

Je ne parle pas du résultat final, qui, dans la plupart des cas, fournira effectivement le même code assembleur. Mais dans la sémantique du C, la nuance est de mise. Voir par exemple :
http://www-clips.imag.fr/commun/bernard.cassagne/Introduction_ANSI_C/node67.html

Où l'on notera d'ailleurs que ton exemple est juste (un paramètre formel de fonction de type tableau est considéré comme un pointeur), mais que c'est un cas particulier :
Le point important à comprendre dans la règle 2 est que tableau de X est la même chose que pointeur vers X uniquement dans le cas de paramètre formel de fonction. Donc void fonc (int t[]) { ... } est équivalent à void fonc (int * t) { ... }. Les types des objets déclarés de type tableau ou de type pointeur sont différents dans tous les autres contextes, que ce soit déclaration de variables globales ou locales à une fonction.

M'enfin, je disais ça, c'était vraiment pour chinoiser.

[S3cur3D]

A vrai dire, non, puisque par définition les tableaux et les pointeurs sont équivalents au passage vers une fonction. Ainsi, void func(int * vals)

Je me cite bien "au passage vers une fonction" et je ne pense pas avoir été ambigu à ce niveau là.
D'ailleurs le point de départ que tu réfutais était (int argc, char ** argv) ou (int argc, char * argv[]), qui sont bien des paramètres formels de fonction et donc équivalents.

Après je suis d'accord que dire ça pourrait faire penser à des débutants qu'il en est de même tout le temps, ce qui est effectivement faux dès qu'on sort du contexte de passage d'arguments à une fonction, mais bon ça je pense que c'est du ressort de la distinction de base entre pointeurs et tableaux..


Allez le HS n'a que trop duré je pense qu'on peut proclamer le EOT


S3cur3D