Discussion :

[achibani]

Bonjour,
Je débute en C. Je veux déclarer un tableau qui se remplie aléatoirement jusqu'à atteindre une demande fixe, dans l'exemple (demande=50)

Ce que je veux faire c'est de mettre une contrainte sur chaque case pour que la valeur affecté aléatoirement doit être entre 0 et un max dans l'exemple (0, (tableau[j].capacite_max).

Voici un code qui tourne chez moi pour un tableau de 4 cases qui correspondent à (4 fournisseurs dans mon problème).

Cependant, lorsque je retire les commentaire dans le main pour mettre une condition sur chaque case ça ne marche pas. Je pense que j'ai fait une erreur lors de l'appelle de la procédure. Merci

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
#include <math.h>
#include <time.h>
#include <stdbool.h>
 
#define nbre_fournisseurs 4
#define demande 50
#define randomize() srand((unsigned)time(NULL))
 
int main()
{
    /*tableau[0].capacite_max = 10;
    tableau[1].capacite_max = 20;
    tableau[2].capacite_max = 30;
    tableau[3].capacite_max = 40;*/
    initialise_population();
}
 
typedef struct fournisseurs fournisseurs;
struct fournisseurs
{
    int capacite_max;
};
 
fournisseurs tableau[nbre_fournisseurs];
 
/*
******************************************
* initialise_population *
* Creates and initialize a population *
******************************************
*/
 
initialise_population()
{
    randomize();
    int myrand(int min, int max)
    {
        return rand()%(min-max+1)+min;
    }
 
    int  j;
    int pos;
    int s=0;
    int tableau[nbre_fournisseurs];
 
    while (s!= demande)
    {
        for ( j = 0 ; j < nbre_fournisseurs ; j++)
            tableau [j] = 0;
        s = 0;
        for ( j = 0 ; j < nbre_fournisseurs ; j++ )
        {
            pos = myrand(0, nbre_fournisseurs);
 
            if (tableau[pos] == 0)
            {
                if ( s == demande )
                    tableau[j] = 0;
                else
                {
                    if ( tableau[j] <=  demande - s )
                    {
                        // tableau[j] = myrand(0, (tableau[j].capacite_max));
                        tableau[j] = myrand(0, 40);
                    }
                    else
                    {
                        tableau[j] = myrand(0, (demande - s));
                    }
                }
 
                s+= tableau[j] ;
            }
        }
    }
 
 
//Affichage de ses valeurs pour vérifier
    for (j = 0 ; j < nbre_fournisseurs ; j++)
    {
        printf("%d\n", tableau[j]);
    }
    {
        printf("\n");
    }
}

[mith06]

Bonjour,

Commençons par rajouter les options de compilation -Wall -Wextra -Werror -pedantic.

Car en C standard ce code ne doit même pas compiler....

[achibani]

Je comprends pas très bien ce que tu dis mais le code il compile chez moi.

[Metalman]

Baah... il devrait pas...

Donc compile avec les options que mith06 t'a dit et tu auras une mauvaise surprise qui te mettra très TRES probablement sur la bonne voie !

[achibani]

Est ce que vous pouvez m'expliquer ces options ? Comme j'ai dit au début, je viens de débuter en c. Si ce forum est pour les experts merci de m'indiquer un endroit où on peut répondre à des questions "simplistes"

[Bktero]

Aoutch !

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
||=== C, Debug ===|
D:\Users\pgradot\Documents\C\dvpez.c||In function 'main':|
D:\Users\pgradot\Documents\C\dvpez.c|15|warning: implicit declaration of function 'initialise_population' [-Wimplicit-function-declaration]|
D:\Users\pgradot\Documents\C\dvpez.c|33|warning: return type defaults to 'int' [enabled by default]|
D:\Users\pgradot\Documents\C\dvpez.c||In function 'initialise_population':|
D:\Users\pgradot\Documents\C\dvpez.c|35|warning: implicit declaration of function 'srand' [-Wimplicit-function-declaration]|
D:\Users\pgradot\Documents\C\dvpez.c|36|warning: ISO C forbids nested functions [-pedantic]|
D:\Users\pgradot\Documents\C\dvpez.c||In function 'myrand':|
D:\Users\pgradot\Documents\C\dvpez.c|38|warning: implicit declaration of function 'rand' [-Wimplicit-function-declaration]|
D:\Users\pgradot\Documents\C\dvpez.c||In function 'initialise_population':|
D:\Users\pgradot\Documents\C\dvpez.c|44|warning: declaration of 'tableau' shadows a global declaration [-Wshadow]|
D:\Users\pgradot\Documents\C\dvpez.c|24|warning: shadowed declaration is here [-Wshadow]|
D:\Users\pgradot\Documents\C\dvpez.c|81|warning: implicit declaration of function 'printf' [-Wimplicit-function-declaration]|
D:\Users\pgradot\Documents\C\dvpez.c|81|warning: incompatible implicit declaration of built-in function 'printf' [enabled by default]|
D:\Users\pgradot\Documents\C\dvpez.c|84|warning: incompatible implicit declaration of built-in function 'printf' [enabled by default]|
D:\Users\pgradot\Documents\C\dvpez.c|86|warning: control reaches end of non-void function [-Wreturn-type]|
out\Debug\formatting.o:formatting.c|| multiple definition of `main'|
out\Debug\dvpez.o:dvpez.c|| first defined here|
||=== Build finished: 2 errors, 11 warnings (0 minutes, 1 seconds) ===|

Quel compilateur utilises-tu ? Comment l'utilises-tu (ligne de commande ou IDE) ?

[achibani]

Merci pour la réponse. J'utilise Code::Blocks c'est un IDE gratuit et libre.
Le compilateur sélectionné par défaut est : GNU GCC Compiler.
Mon code il tourne et m'affiche un tableau. Je suis vraiment surpris

[Bktero]

J'utilise aussi Code Blocks Je l'ai utilisé pour mon précédent message. Beaucoup de monde l'utilise, c'est un IDE très répandu. gcc est quand à lui un des compilateurs C les plus célèbres, notamment sous Linux. D'ailleurs utilises-tu Linux ?

Pour activer, les options, tu peux aller dans les options du projet (Project / Build options) et tu auras une fenêtre semblable à ceci :


Dans l'onglet Compiler Settings, tu auras une liste d'options. Tu dois cocher au moins -Wall. Je te conseille aussi fortement -Wextra. Recompile ton code ensuite et tu verras.

[_iri_]

Je suis également surpris que ça tourne

Dans C::B, tu peux définir les options de compilations de gcc (soit par défaut, pour tous les projets, soit pour ce projet en particulier).

- Par défaut :
Menu Settings > Compilers and debuggers

- Pour ce projet particulier :
Une fois le projet ouvert dans C::B, menu Projet > Build options
Choisir l'onglet « Compiler flags »

Dans les deux cas, sélectionner les options de base mentionnées par un intervenant précédent.

[achibani]

Alors la ! Je viens d'inclure toutes vos remarques.

Le code il tourne !

[Bktero]

NNNOOOOONNNN !!!!

Tu as coché la case -w, c'est la case du mal ! Il ne faut jamais cocher cette case !
Lis sa description… Attentivement…

Et puis, non, tu n'as pas inclus toutes nos remarques car tu n'as pas coché -Wall. C'est la case à cocher en premier car elle donne les warnings les plus "basiques" et donc essentiels.

[Sve@r]

Bonjour

Je trouve que vous n'êtes pas sympa avec lui. Il débute en C, tout ce qu'il veut c'est compiler son code et vous le noyez dans des considérations annexes sur les options à mettre au compilateur sans lui expliquer en quoi ça va l'aider. Je serais presque tenté de dire que vous l'avez carrément envoyé chier. Et malgré ça, lui pas méchant, qui s'excuse même croyant s'être trompé de forum, il revient demander gentiment où est-ce qu'il pourrait trouver la rubrique des débutants. C'est un coup à le dégoûter définitivement du C (et peut-être même aussi de ce forum) !!!
Je ne dis pas que ces options ne sont pas utiles mais c'est peut-être pas primordial d'en parler de suite...

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
#include <math.h>
#include <time.h>
#include <stdbool.h>

#define nbre_fournisseurs 4
#define demande 50
#define randomize() srand((unsigned)time(NULL))

int main()
{
    /*tableau[0].capacite_max = 10;
    tableau[1].capacite_max = 20;
    tableau[2].capacite_max = 30;
    tableau[3].capacite_max = 40;*/
    initialise_population();
}

typedef struct fournisseurs fournisseurs;
struct fournisseurs
{
    int capacite_max;
};

fournisseurs tableau[nbre_fournisseurs];

/*
******************************************
* initialise_population *
* Creates and initialize a population *
******************************************
*/

initialise_population()
{
    randomize();
    int myrand(int min, int max)
    {
        return rand()%(min-max+1)+min;
    }

    int  j;
    int pos;
    int s=0;
    int tableau[nbre_fournisseurs];

    while (s!= demande)
    {
        for ( j = 0 ; j < nbre_fournisseurs ; j++)
            tableau [j] = 0;
        s = 0;
        for ( j = 0 ; j < nbre_fournisseurs ; j++ )
        {
            pos = myrand(0, nbre_fournisseurs);

            if (tableau[pos] == 0)
            {
                if ( s == demande )
                    tableau[j] = 0;
                else
                {
                    if ( tableau[j] <=  demande - s )
                    {
                        // tableau[j] = myrand(0, (tableau[j].capacite_max));
                        tableau[j] = myrand(0, 40);
                    }
                    else
                    {
                        tableau[j] = myrand(0, (demande - s));
                    }
                }

                s+= tableau[j] ;
            }
        }
    }


//Affichage de ses valeurs pour vérifier
    for (j = 0 ; j < nbre_fournisseurs ; j++)
    {
        printf("%d\n", tableau[j]);
    }
    {              // Pourquoi ici un bloc ?
        printf("\n");
    }
}

Il y a un point essentiel à connaitre quand tu compiles, c'est que le compilateur est séquentiel. Il regarde la ligne 1 et si elle est correcte, alors il passe à la ligne 2.

Or, dans ton main, tu demandes à remplir en ligne 11 une variable "tableau[x]" qui n'est crée qu'en ligne 24. C'est normal que le compilo râle !!!
Ceci est le seul point bloquant car quand on place les lignes dans le bon ordre (création de la structure, définition de la variable puis remplissage de la variable) le programme compile (sous Linux gcc 4.4.5 et il compilait déjà dans la version d'origine quand les lignes bloquantes sont commentées).

Maintenant, il y a d'autres points essentiels qu'il te faudra prendre en compte si tu veux pouvoir programmer sans souci. Tout d'abord, lorsque le compilo te met un "warning", ça signifie qu'il n'est pas certain d'avoir bien saisi ce que tu veux faire. Il prend alors une décision mais il t'informe que ce n'est peut-être pas la bonne. Les options indiquées par les autres intervenants mettent le compilateur en mode "paranoïa" c'est à dire qu'il te prévient dès qu'il y a le moindre doute sur quoi que ce soit.
A ce moment là, ce n'est pas parce que le compilateur a compilé qu'il faut laisser pisser (surtout si le compilo met un warning alors qu'il n'est pas en mode paranoïa). 9 fois sur 10 ça fonctionnera mais la 10ème te fera regretter toutes les autres fois où tu ne t'en es pas soucié.
Donc quand on a un warning, il faut aller voir la ligne indiquée et régler le soucis.

Un second point c'est qu'une fonction doit toujours être typée. Sinon le compilo la place en "int" par défaut. Or la fonction "initialise_population()" ne renvoie rien donc elle doit être typée "void". Malheureusement, elle est appelée dans le main avant d'être créée. Et là, lorsque le compilo la prend en compte, il la positionne en "int". Si après il voit que tu la mets en "void", là il va râler.
2 solutions
1) tu écris son code avant de l'utiliser. C'est faisable dans 99% des cas. Là où cela ne l'est plus, c'est si tu as deux fonctions qui s'appellent mutuellement
2) tu écris juste son prototype (sa signature) avant de l'utiliser. Ca prévient juste le compilo qu'une fonction de ce type existe et sera créée après. Suffit d'écrire void "initialise_population(); là où tu crées tes structures et tes types.

Sinon c'est à peu près tout ce qui est, pour l'instant, vraiment important. Car en C, ce n'est pas parce qu'un programme compile qu'il fonctionne, et ce n'est pas parce qu'il fonctionne qu'il n'y a pas un truc d'illégal qui y est fait. Malheureusement quand le truc illégal se décide à faire planter, ça peut se passer bien longtemps après donc toujours être super rigoureux => là le mode paranoïa du compilo peut t'aider.

D'autres petits détails à prendre en compte si tu veux progresser rapidement:

• les macros s'écrivent en majuscules et sont protégées par des parenthèses (pour éviter les pb liés aux priorités des opérations)
• les variables peuvent avoir des majuscules mais leur nom est majoritairement composé de minuscules
• c'est bien de nommer ta structure "s_fournisseur" et ton type "t_fournisseur" comme ça on ne confond pas "fournisseur" avec un nom de variable
• l'utilisation des globales est fortement déconseillé (en fait, on ne met de globales que si vraiment vraiment on ne peut pas faire autrement ce qui est loin d'être le cas ici)
• l'initialisation du random() ne se fait qu'une seule fois (d'où son nom "initialisation") donc généralement dans le main. Partant de là, a-t-on vraiment besoin d'une macro pour ça ?
• si tu indentes proprement ton code il sera mieux lisible pour tout le monde (y compris pour toi)

PS: concernant la fonction myrand() je ne savais pas qu'on pouvait la définir dans une autre fonction. Peut-être une évolution du C que je ne connais pas. Toutefois, là l'usage d'une macro peut s'envisager.

Donc voici ton programme corrigé. Normalement là (sans présumer de la logique sur laquelle il est basé), il devrait fonctionner et, même s'il ne passe pas les options -Wall -Wextra -Werror -pedantic qui sont, il faut le dire, vraiment bien casses-c.... (surtout en ce qui concerne les commentaires "//" qui ne sont pas acceptés), être assez propre pour que le compilo standard s'en accomode...

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
#include <math.h>
#include <time.h>
#include <stdbool.h>
#include <stdio.h>
 
#define NBRE_FOURNISSEURS (4)
#define NBRE_DEMANDE (50)
#define RANDOMIZE() (srand((unsigned)time(NULL)))
 
typedef struct {
	int capacite_max;
} t_fournisseurs;
 
void initialise_population();
int myrand(int, int);
 
int main()
{
	t_fournisseurs tableau[NBRE_FOURNISSEURS];
 
	tableau[0].capacite_max = 10;
	tableau[1].capacite_max = 20;
	tableau[2].capacite_max = 30;
	tableau[3].capacite_max = 40;
	RANDOMIZE();
	initialise_population();
}
 
int myrand(int min, int max)
{
	return rand()%(min-max+1)+min;
}
 
/*
******************************************
* initialise_population *
* Creates and initialize a population *
******************************************
*/
 
void initialise_population()
{
 
	int  j;
	int pos;
	int s=0;
	int tableau[NBRE_FOURNISSEURS];
 
	while (s!= NBRE_DEMANDE)
	{
		for ( j = 0 ; j < NBRE_FOURNISSEURS ; j++)
			tableau [j] = 0;
		s = 0;
		for ( j = 0 ; j < NBRE_FOURNISSEURS ; j++ )
		{
			pos = myrand(0, NBRE_FOURNISSEURS);
 
			if (tableau[pos] == 0)
			{
				if ( s == NBRE_DEMANDE )
					tableau[j] = 0;
				else
				{
					if ( tableau[j] <=  NBRE_DEMANDE - s )
					{
						// tableau[j] = myrand(0, (tableau[j].capacite_max));
						tableau[j] = myrand(0, 40);
					}
					else
					{
						tableau[j] = myrand(0, (NBRE_DEMANDE - s));
					}
				}
 
				s+= tableau[j] ;
			}
		}
	}
 
 	// Affichage de ses valeurs pour vérifier
	for (j = 0 ; j < NBRE_FOURNISSEURS ; j++)
	{
		printf("%d\n", tableau[j]);
	}
	printf("\n");
}

PS: je ne sais pas si c'est voulu mais il n'y a aucun lien entre la variable "tableau" du main() et la variable "tableau" de initialise_population(). Et même dans ton code précédent, cette variable "tableau" occultait complètement la variable globale "tableau" (c'est déjà un des dangers d'utiliser des globales). Donc comme je t'ai dit, ceci est un code qui compile sans erreur mais qui ne correspond peut-être pas à la logique que tu lui veux (surtout quand tu dis que tu remplis tableau dans le main pour que l'initialisation puisse initialiser correctement, il convient à un moment ou à un autre que initialisation ait accès aux informations qui y sont stockées)...

Car en C standard ce code ne doit même pas compiler....

Tout dépend de la définition de "C standard". Toutefois cette définition doit être chez-toi très rigoureuse car chez-moi (et semble-t-il chez-lui) ça compile. Or mon compilo (gcc 4.4.5 Debian, qui est aussi celui de beaucoup d'autres) me parait très conforme au "C standard" standard...

[grim7reaper]

Car en C standard ce code ne doit même pas compiler....

Tout dépend de la définition de "C standard".

Non, ça ne dépend pas de la définition, pour la simple et bonne raison qu’il n’y a pas 42 définitions.
Le langage C possède un standard normalisé, ce n’est pas une définition perso…

Certes, il y a plusieurs standard C, mais le code présenté n’est valide dans aucun standard (rien que par la présence d'une fonction imbriquée (au passage, ces fonctions sont implémentées par gcc via des trampolines ce qui oblige à garder la pile exécutables, génial niveau sécu’…)) donc mith06 est toujours dans le vrai.

Toutefois cette définition doit être chez-toi très rigoureuse car chez-moi (et semble-t-il chez-lui) ça compile.

C’est pas une histoire d’être très rigoureux ou pas.
Le standard, tu le respectes ou tu ne le respectes pas. C’est binaire.

Or mon compilo (gcc 4.4.5 Debian, qui est aussi celui de beaucoup d'autres) me parait très conforme au "C standard" standard...

GCC est connu pour être très laxiste par défaut : il produit moins d’avertissements que clang et il active des extensions GNU par défaut (donc non, gcc par défaut n’est pas conforme au C standard) :

By default, GCC provides some extensions to the C language

Donc dire « ça compile avec gcc par défaut » c’est vraiment pas un argument valable…

[Sve@r]

Le standard, tu le respectes ou tu ne le respectes pas. C’est binaire.

Oui mais ils évoluent avec le temps. Tu as des écritures conformes au standard d'aujourd'hui qui ne l'étaient pas hier...

Donc dire « ça compile avec gcc par défaut » c’est vraiment pas un argument valable…

Je n'ai pas posé ça comme argument mais comme illustration. Surtout que je n'ai pas absolument pas dit que le code le code d'achibani était sans erreur, j'ai dit qu'il n'était pas encore capable de les comprendre et probablement même pas de les voir. Et vu que ça compile chez-moi, j'ai admis son affirmation disant que ça compilait aussi chez-lui. Le reste n'était que de l'ironie vu que mith06 (et aussi Metalman) ont fait une affirmation sans la vérifier...

[Metalman]

Juste pour faire une remarque dans le même genre je-vais-pas-affirmer-comme-les-vilains : il n'a jamais dit qu'il compilait sur gcc ou CodeBlocks au départ...

Et si j'ai répondu comme ça, c'était "un peu" sur le même ton que lui avec sa remarque :

Je comprends pas très bien ce que tu dis mais le code il compile chez moi.

C'est surtout ce smiley avec la phrase qui me gène perso :