Discussion :

[D_bar]

bonjour, étant un petit nouveau dans la prog en C j'ai plusieurs questions, la première est celle-ci:

(j'utilise code block comme IDE)


le principe appliqué pour le tri est le suivant:

1. prendre la première valeur du tableau
2. la comparer à toutes les valeurs du tableau dont le pointeur est supérieur a celui de la valeur a comparer
3. si une valeur inférieure existe, l'échanger de place avec la première
4. répéter l'opération autant de fois que nécessaire pour que la plus petite valeur soit en premier
5. refaire l'opération à partir de la deuxième valeur, puis de la troisième,...

pour assigner et trier des valeurs dans un tableau, j'ai créé ce code (ci-dessous), la partie de création du tableau et celle d'assignation initiale des valeurs fonctionnent, en revanche la partie de tri ne fonctionne pas,
en fait, une des assignation ne se fait pas, c'est la deuxième.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
int main()
{
 
void imp_tab(int t[], int nb_elem)
{
int i;
 
for (i = 0; i < nb_elem; i++) printf("%d ",t[i]);
}
 
{
    int size=1;
    int table[size];
    int value = 0;
    int y = 0;
    int recup=0;
    int recup2=0;
    int res;
 
    printf("Entrez une valeur pour la taille : ");
            res = scanf("%i", &size);
 
 
    while(y<size)
        {
            printf("Entrez une valeur pour le rang %i : ",y);
            res = scanf("%i", &value);
            table[y]=value;
            y++;
        }
//algo de tri   (V)
for (int o = 0; o < y-1; o++)
    {
 
    for (int r = o+1; r < y; r++)
        {
                recup=table[o];
                recup2=table[r];
        if (table[r]<table[o])
            {
                table[r]=recup;
                table[o]=recup2;//l'assignation ne se fait pas
            }
 
        }
 
    }
 
 
imp_tab(table,y);
return 0;
}

si quelqu'un a une idée, je veux bien parce que là, je sèche.

[dalfab]

Bonjour,

En langage C, on ne peut pas définir une fonction à l'intérieur d'une autre. Ton compilateur semble tolérer cela mais les lignes 4 à 9 devraient être en dehors de la fonction main().

En langage C, on peut définir un tableau donc la taille dépend d'une variable. Mais cette règle était surtout source de problème et va disparaître, la preuve : Tu as utilisé cette capacité ligne 13 en créant un tableau dont la taille vaut finalement 1. Donc le seul indice utilisable est 0.
Ensuite tu écris dans ce tableau à des indices y qui peuvent être supérieur à 0. Et dans ce cas cela provoques des fonctionnement complètement erratiques. Et c'est vraisemblablement la cause de tes erreurs.
Ton tri, quant à lui, semble correct.

[Sve@r]

Bonjour

En langage C, on ne peut pas définir une fonction à l'intérieur d'une autre. Ton compilateur semble tolérer cela

Si le compilateur le tolère, c'est donc qu'on peut non ?

En tout cas mon gcc (8.3.0 sur debian10) l'accepte lui-aussi...

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
#include <stdio.h>
 
int main() {
	void toto() {
		printf("toto\n");
	}
 
	toto();
}

... et ça fait quelques mois que je m'en suis rendu compte. Donc force est de constater qu'apparemment maintenant on peut...

[Médinoc]

Avec les bonnes options de norme et -pedantic pour désactiver les extensions GNU?

[Ngork]

Comme l'indique dalfab, tu déclares un tableau de taille size, avec size initialisé à 1, par conséquent, ton tableau est aussi initialisé à 1.
Or ultérieurement, tu donnes une autre valeur à size, d'après l'entrée de l'utilisateur, et tu espères visiblement que le tableau va changer de taille pour s'adapter à la nouvelle valeur de size.
Ce n'est pas le cas.
Il te suffit de déplacer la ligne de déclaration de ton tableau après la saisie de l'utilisateur et il fera la bonne taille, ce qui devrait résoudre tes soucis ...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
 
  printf("Entrez une valeur pour la taille : ");
  res = scanf("%i", &size);
 
  int table[size];

Bien sûr, il faudrait quand même que tu contrôles un peu ce que rentre l'utilisateur histoire d'éviter les valeurs négatives ou la valeur nulle !

[foetus]

Il te suffit de déplacer la ligne de déclaration de ton tableau après la saisie de l'utilisateur et il fera la bonne taille, ce qui devrait résoudre tes soucis ...

Sauf que dans ce cas , ce n'est toléré que depuis C99 ... et je pense même que comme le tableau est un VLA (Variable-length array, lien wiki en anglais), il faut impérativement C99 (mais déprécié depuis C11)

Et si @D_bar voulait correctement faire un VLA, il faut passer la taille en paramètre ... mais dans son code ce n'est pas possible parce que la taille doit être demandée : donc à part faire une allocation dynamique, il faut créer le tableau le + grand possible


Et pour les fonctions imbriquées , cela fait partie de la GNU C (<- lien officiel gnu en anglais) apparemment cela ressemble à des lambdas qui sont déclarées au même niveau que les autres variables (en gros, on crée une variable lambda)

[Sve@r]

Avec les bonnes options de norme et -pedantic pour désactiver les extensions GNU?

Ben non, j'ai juste lancé un bête "gcc". C'est sûr que si on active les options qui interdisent ce type de programmation ben ça marchera pas. Avec "--pedantic" il me met un warning mais il le compile quand-même.

Et si @D_bar voulait correctement faire un VLA, il faut passer la taille en paramètre ... mais dans son code ce n'est pas possible parce que la taille doit être demandée

Euh non, là je ne suis pas d'accord. Les VLA (et ton lien le dit bien) sont des tableaux dont la taille est déterminée lors de l'exécution. Donc de mon point de vue, une taille saisie au clavier permet un VLA. D'ailleurs l'exemple C de ton lien montre un VLA qui reçoit la taille en paramètre mais rien ne dit que la taille en question n'a pas été saisie au clavier du côté appelant.

Mais bien éidemment si comme ici le VLA est créé avant que la taille ne soit saisie...

Et pour les fonctions imbriquées , cela fait partie de la GNU C (<- lien officiel gnu en anglais) apparemment cela ressemble à des lambdas qui sont déclarées au même niveau que les autres variables (en gros, on crée une variable lambda)

Ce serait marrant d'essayer de passer l'adresse d'une fonction incluse à une autre fonction voir si l'autre fonction peut l'appeler...

Edit: hé bien ça marche !!!

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
 
void caller(void (*)(char*));
 
int main() {
	void toto(char *s) {
		printf("%s\n", s);
	}
 
	caller(toto);
}
 
void caller(void (*f)(char*)) {
	(*f)("123");
	(*f)("456");
}

[foetus]

Euh non, là je ne suis pas d'accord. Les VLA (et ton lien le dit bien) sont des tableaux dont la taille est déterminée lors de l'exécution. Donc de mon point de vue, une taille saisie au clavier permet un VLA. D'ailleurs l'exemple C de ton lien montre un VLA qui reçoit la taille en paramètre mais rien ne dit que la taille en question n'a pas été saisie au clavier du côté appelant.

Mais bien évidemment si comme ici le VLA est créé avant que la taille ne soit saisie...

Tu as raison , il faudrait découper l'algo en 2 : dans un premier temps demander la taille du tableau et ensuite le créer, le remplir, et le trier.

Mais, je ne sais pas, je pense que lorsque j'ai vu le code de @Ngork et lui dire de le faire en 2 parties, avec la deuxième partie dans une fonction (pour passer la taille en paramètre), j'ai lâché l'affaire

Edit: hé bien ça marche !!!

Mais c'est une variable locale avec une notion de fermeture ("closure" en anglais, lien wiki en français)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include <stdio.h>
#include <stdlib.h>
 
 
typedef void (*t_func)(char*);
 
 
// Forward Declaration
void caller(t_func, char*, char*);
 
 
t_func give_me_the_func(char* debug_str, char* first_str, char* seconde_str) {
    void toto01(char *s) {
        if (s != NULL) {
            printf("%s\n", s);
        } else {
            printf("%s\n", debug_str);
        }
    }
 
    void toto02(char *s) {
        printf("%s\n", s);
    }
 
    toto01(NULL);
 
    caller(toto02, first_str, seconde_str);
 
    return toto02;
}
 
 
int main(int argc, char* argv[])
{
    t_func func01 = give_me_the_func("main - debug: take the first func", "first func: 01", "first func: 02");
    t_func func02 = give_me_the_func("main - debug: take the second func", "second func: 01", "second func: 02");
 
    caller(func01, "kaboum: 01", "kaboum: 02");
 
 
    return EXIT_SUCCESS;
}
 
 
void caller(t_func f, char* first_str, char* seconde_str) {
    (*f)(first_str);
    (*f)(seconde_str);
}

[Sve@r]

Tu as raison , il faudrait découper l'algo en 2 : dans un premier temps demander la taille du tableau et ensuite le créer, le remplir, et le trier.

C'est ce qu'il fait (lignes 20 et 21). Il faut juste qu'il définisse le tableau après la saisie.

Mais, je ne sais pas, je pense que lorsque j'ai vu le code de @Ngork et lui dire de le faire en 2 parties, avec la deuxième partie dans une fonction (pour passer la taille en paramètre), j'ai lâché l'affaire

C'est pas grave on est tous bénévoles. Si tu peux aider tu aides et si tu peux pas ben personne ne t'en voudra.
D'autant plus que je viens de reprendre son code et en fait il fonctionne. Juste définir le tableau après la saisie et c'est bon.

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <stdio.h>
int main() {
	void imp_tab(int t[], int nb_elem) {
		int i;
		for (i = 0; i < nb_elem; i++) printf("%d ",t[i]);
	}
 
	int size;
	int y;
	int res;
 
	printf("Entrez une valeur pour la taille : ");
	res = scanf("%i", &size);
	int table[size];
 
	for (y=0; y< size; y++) {
		printf("Entrez une valeur pour le rang %i : ",y);
		res = scanf("%i", &table[y]);
	}
 
	//algo de tri   (V)
	for (int o = 0; o < y-1; o++) {
		for (int r = o+1; r < y; r++) {
			if (table[r]<table[o]) {
				int tmp;
				tmp=table[r];
				table[r]=table[o];
				table[o]=tmp;
			}
		}
	}
 
	imp_tab(table,y);
	return 0;
}

Je l'ai un peu optimisé en enlevant les variables non nécessaires mais le code d'origine fonctionne aussi.

Comme quoi, voilà comment briller à peu de frais

[foetus]

Juste définir le tableau après la saisie et c'est bon.

@Ngork l'avait dit, sur ce je lui retoqué que c'est du C99 mais remarqué que ce n'est pas gênant parce que @D_bar utilisait déjà des VLA et toi tu es arrivé après