Déclaration tableau à plusieurs indices / C

[FBMeca]

Bonjour à tous,

Je recherche simplement à créer une fonction qui calcule la somme de tous les éléments d'un tableau à plusieurs indices. Par contre, pour déclarer mon tableau, je ne vois pas comment faire, puisqu'il me dit que "array has incomplete element type". J'ai ici simplement utilisé la même méthode que pour un tableau à un indice, mais j'imagine qu'on peut pas ?
Aussi, j'ai vu qu'on pouvait utiliser les pointeurs pour résoudre ce problème. Les ayant pas encore vus, y aurait-il une autre méthode ?

Merci d'avance !

#include <stdio.h>

int somme_fonction(int t[][], int i, int j) ;
void appel_fonction(int t[][], int i, int j) ;

int main() {

int i, j ;

printf("Combien de lignes fera votre tableau: ") ;
scanf("%d", &i) ;
printf("Combien de colonnes fera votre tableau: ") ;
scanf("%d", &j) ;

int tableau[i][j] ;

appel_foncton(tableau, i, j) ;
somme_fonction(tableau, i, j) ;

return 0 ;

}

// ---------------------------------

int somme_fonction(int t[][], int i, int j) {
    int m, n, som=0 ;
    for (m=0 ; m<i ; m++) {
        for (n=0 ; n<j ; n++) {
            som += t[i][j] ;
        }
    }
    return som ;
}

void appel_fonction(int t[][], int i, int j) {
    int m, n ;
    for (m=0 ; m<n ; m++) {
        for (n=0 ; n<j ; n++) {
            printf("Valeur [%d][%d] du tableau: ", i, j) ;
            scanf("%d", &t[i][j]) ;
        }
    }
}

-----

[pm42]

Tu ne peux pas passer un tableau à plusieurs dimensions sans les indiquer, en tout cas cel
Dans ton cas, le plus simple est de changer tes déclarations pour faire :

int somme_fonction(int i, int j, int t[i][j]) ;
void appel_fonction(int i, int j, int t[i][j]) ;

Et de changer le reste du code pour qu'il corresponde. Cela nécessite que tu utilises un compilateur à la norme C99 mais il y a de bonnes chances que ce soit le cas.
Sinon, il y a d'autres solutions avec des pointeurs et globalement, on n'est pas obligé de passer la 1ère dimension mais c'est plus compliqué et moins lisible que celle ci-dessus.

[FBMeca]

Merci pour ton message. Comme ceci tu dis ? Ca me met des messages d'erreur étranges : "Undefined symbols for architecture x86_64:
"_appel_foncton", referenced from:
_main in 43-4bd3f4.o
ld: symbol(s) not found for architecture x86_64
clang: error: linker command failed with exit code 1 (use -v to see invocation)"

Et le changement de l'ordre des arguments, c'est nécessaire ?

#include <stdio.h>

int somme_fonction(int i, int j, int t[i][j]) ;
void appel_fonction(int i, int j, int t[i][j]) ;

int main() {

int i, j ;

printf("Combien de lignes fera votre tableau: ") ;
scanf("%d", &i) ;
printf("Combien de colonnes fera votre tableau: ") ;
scanf("%d", &j) ;

int tableau[i][j] ;

appel_foncton(i, j, tableau) ;
somme_fonction(i, j, tableau) ;

return 0 ;

}

// ---------------------------------

int somme_fonction(int i, int j, int t[i][j]) {
    int m, n=0, som=0 ;
    for (m=0 ; m<i ; m++) {
        for (n=0 ; n<j ; n++) {
            som += t[i][j] ;
        }
    }
    return som ;
}

void appel_fonction(int i, int j, int t[i][j]) {
    int m, n ;
    for (m=0 ; m<n ; m++) {
        for (n=0 ; n<j ; n++) {
            printf("Valeur [%d][%d] du tableau: ", i, j) ;
            scanf("%d", &t[i][j]) ;
        }
    }
}

[pm42]

Ca me met des messages d'erreur étranges : "Undefined symbols for architecture x86_64:
"_appel_foncton", referenced from:

Ce n'est pas étrange : vu que tu as défini appel_fonction mais qu'ensuite tu as tapé appel_foncton, ça ne marche pas.

Et le changement de l'ordre des arguments, c'est nécessaire ?

Oui.

[A voir en vidéo sur Futura]

[FBMeca]

A présent c'est parfait, merci !

Pour l'ordre des arguments, on ne peut pas mettre un argument x qui dépend de y et z avant de lui avoir fourni y et z, c'est environ ça la logique?

[jojo150393]

Tu ne peux pas utiliser de variable pour déclarer ton tableau. La dimension du tableau se fait au niveau de la compilation alors que les variables sont connues à l'execution. Ici la taille de ton tableau sera aléatoire.
Pour pallier à cela, tu dois utiliser une constante (une define par exemple) spécifiant la taille MAX du tableau. Ex:

#define MAX_ARRAY_SIZE 32
int tableau[MAX_ARRAY_SIZE][MAX_ARRAY_SIZE]

ou plus simplement mais moins propre:

int tableau[32][32]

C'est ensuite dans ton programme que tu devras vérifier que l'utilisateur n'entre pas une taille trop grande par rapport à celle que tu as prévu.
Pour ce qui est de ta fonction, tu peux utiliser ta constante:

int somme_fonction(int i, int j, int t[MAX_ARRAY_SIZE][MAX_ARRAY_SIZE]);
void appel_fonction(int i, int j, int t[MAX_ARRAY_SIZE][MAX_ARRAY_SIZE]);

[pm42]

Tu ne peux pas utiliser de variable pour déclarer ton tableau.

Lire ce qui a été écrit ici notamment sur le C99 éviterait de dire des choses fausses comme ça.

[jojo150393]

Complique pas les choses, il apprend. Quand on apprend, il vaut mieux utiliser les choses qui éviter les erreurs. D'ailleurs, même si il est possible que C99 l'autorise (j'en doute mais bon) personne fait ça!
On utilisera l'alloc dynamique mais bon je ça ne concerne pas le sujet présent.
Du coup, pour ma curiosité perso, tu aurais un lien qui confirme ton post précédent ?

[pm42]

il est possible que C99 l'autorise (j'en doute mais bon) personne fait ça!

Se renseigner avant de dire des trucs faux serait la moindre des choses.

tu aurais un lien qui confirme ton post précédent ?

Tu as du mal à trouver une norme qui a plus de 20 ans et qui est supportée par tous les compilateurs actuels ?

[jojo150393]

Il faut vraiment éviter de l'utiliser car ça pose pas mal de problème de sécurité et ça alourdi et ralenti le code.
D'ailleurs, arrives-tu a compiler ? Il faut souvent le spécifier au compilo pour utiliser du C99

[pm42]

Il faut vraiment éviter de l'utiliser car ça pose pas mal de problème de sécurité et ça alourdi et ralenti le code.

C'est là aussi parfaitement faux. C'est la solution que tu as proposé qui alourdi le code parce qu'elle oblige à vérifier qu'on ne dépasse pas les limites arbitraires comme celle de ton MAX_ARRAY_SIZE.
De plus, cela augmente la consommation mémoire et le risque de dépassement.

[Jack]

D'ailleurs, même si il est possible que C99 l'autorise (j'en doute mais bon)

Si, C99 autorise les VLA. Mais bizarrement c'est devenu optionnel avec C11.

[pm42]

Si, C99 autorise les VLA. Mais bizarrement c'est devenu optionnel avec C11.

En pratique, cela ne concerne guère que des compilos très spécialisés pour de l'embarqué. Sur la page wikipedia du C99, seul le TinyC ne le supporte pas mais gcc, clang, VisualC++ et les autres oui.

[Jack]

J'ai du mal à voir la relation entre la citation et ce que tu dis.

[pm42]

J'ai du mal à voir la relation entre la citation et ce que tu dis.

Je parlais du caractère optionnel en C11. Il semblerait que ce soit du à une tension classique entre 2 types d'utilisateurs du C : ceux qui s'en servent pour un usage généraliste et ceux qui codent de l'embarqué.

Lors des débats pour la 1ère norme ANSI, ceux de l'embarqué expliquaient que stdio.h ne devraient pas faire partie de la norme parce qu'on n'en a pas besoin pour faire un contrôleur d'ascenseur.

Là, ils auraient voulu pouvoir faire des compilos à la norme C11 sans avoir à implémenter les VLA puisque c'est effectivement un besoin plus lié à des softs "interactifs".
Perso, je trouve assez ridicule de mettre une fonction aussi pratique dans une norme et de la rendre optionnelle 12 ans plus tard et ce d'autant que la gestion des tableaux en C est antédiluvienne et n'a comme avantage que de permettre aux compilos de générer du code efficace relativement facilement, au détriment d'en gros tout le reste : sécurité, lisibilité du code, etc.

[jojo150393]

C'est là aussi parfaitement faux. C'est la solution que tu as proposé qui alourdi le code parce qu'elle oblige à vérifier qu'on ne dépasse pas les limites arbitraires comme celle de ton MAX_ARRAY_SIZE.
De plus, cela augmente la consommation mémoire et le risque de dépassement.

Les VLA utilises la stack pour stocker le tableau. Si l'utilisateur entre un trop grand nombre tu auras un stack overflow. Il faut donc aussi contrôler. Ensuite, si tu utilises un trop grand nombre d'appel fonction, encore une fois, problème de stack.
En plus, il faut vérifier que l'utilisateur n'entre pas un nombre negatif, sinon comportement incertain.
Linus Torvarld le dit lui même :

USING VLA'S IS ACTIVELY STUPID! It generates much more code, and
much _slower_ code (and more fragile code), than just using a fixed
key size would have done.

Bon après si tu penses que pédagogiquement c'est intéressant de continuer à présenter ces détails complexes à un débutant, je préfère m'abstenir de continuer de débattre vainement.
FBMeca, si tu ne comprends rien c'est normal, je te conseille de suivre...mon conseil .

[pm42]

Linus Torvarld le dit lui même :

Quitte à le citer, ce serait bien de préciser ce qu'il a dit : "VLA's are problematic for embedded and systems programming because the stack is usually very limited".

C'est ici : https://www.realworldtech.com/forum/...rpostid=121621
Il précise même "Some people really don't seem to realize that embedded and system programming is different from "normal" programming. "

Cela tombe bien, le primo-posteur ne fait pas de programmation système ou embarquée mais justement du "normal" et son code n'est pas récursif.

[FBMeca]

FBMeca, si tu ne comprends rien c'est normal, je te conseille de suivre...mon conseil .

Je dois avouer que de prendre de l'avance sur mon niveau actuel n'est sûrement pas la meilleure idée. Par contre, j'ai un peu perdu le fil maintenant.
Quelles sont les deux options, et en quoi diffèrent-elles ? Une qui consiste à utiliser une variable, et l'autre pas, c'est bien ça ? Mais alors pourquoi dit-on aux débutants qu'on ne peut utiliser une variable ? Quel est le problème qui s'offre à nous à ce moment là ?

Merci pour ton aide

[pm42]

Quelles sont les deux options, et en quoi diffèrent-elles ?

C'est simple : la solution que je t'ai proposée est la plus facilement compréhensible par un débutant et elle marche très bien dans de nombreux cas.
Mais c'est aussi la plus récente : le C est un vieux langage et pendant des années, on ne pouvait pas utiliser un tableau dont la taille était précisée par une variable.
C'était notamment un sujet pour les tableaux à 2 dimensions ou plus.

Donc il y avait 2 solutions : soit on prenait un tableau plus gros soit on faisait à la main avec un tableau de pointeurs ou un pointeur de pointeurs...
Dans les 2 cas, c'est typique du coté "bas niveau" du langage C qui t'oblige à te concentrer sur des concepts très proches de la machine.
Et l'expérience montre que c'est très compliqué pour les débutants.

Dans ton cas, j'ai choisi de te proposer la solution la plus simple qui te permettait d'avancer compte tenu de ton niveau en sachant que si tu continues, tu devrais maitriser ces concepts là mais qu'avant, tu as d'autres choses à apprendre.

[FBMeca]

C'est clair, merci