Discussion :

[carriebradshaw]

Bonjour,
Voilà je suis nouvelle sur ce forum et j'ai un gros problème:
Je fais des cours d'informatique langage C mais on est 20 (oui je vous assure) dans la classe et le prof est complètement débordé qui fait qu'il va vite sur les corrections alors j'ai essayé de les revoir je voudrais savoir si c'est bon ce que j'ai fait

Recherche:
Ecrire un programme qui crée un tableau de n cases. Les n cases seront alors remplies avec des caractères demandés à l'utilisateur.
Le programme demandera à l'utilisateur quel est le caractère à rechercher. Le programme parcoura le tableau et affichera "Oui, je suis dedans" ou "Non, je ne suis pas là" en fonction de la présence ou de l'absence de ce caractère

Voilà le code:

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
#include<stdio.h>
int main(void){ 
char tab[n]; 
int nb; 
int i; 
char c; 
printf("Combien de cases voulez-vous remplir?") 
scanf("%d", nb); 
if(nb>=n){  printf("Erreur: 200 cases maximum!");  
return 1; 
} 
for(i=0, i<nb, i++) 
{ 
printf("Veuillez saisir le caractère present a la case %d:", i);
getchar(tab[i]); 
} 
printf("Quel caractère voulez vous rechercher? "); 
getchar(&c); 
i=0; 
do 
{ 
if(tab[i]==c) printf("oui je suis dedans\n"); 
else 
printf("non je ne suis pas dedans\n"); i++; 
} 
while(i<nb);

Il y a ct exercice là aussi je pense que c'est dans le même style que le premier sauf qu'on affiche 2 tableaux à la suite enfin je ne sais pas vraiment comment faire.....
Addition/multiplication:
Ecrire un programme qui crée 2 tableaux de n*n cases. Les cases des tableaux sont respectivement remplies des valeurs de la table d'addition et multiplication de n. Votre programme permettra d'afficher les 2 tableaux à la suite

Merci

[Médinoc]

Ben non, c'est mauvais dès la troisième ligne: Le compilateur ne connait pas "n".
Puisque le programme limite à 200 cases maximum, et que je suppose que vous n'avez pas encore vu l'allocation dynamique, tu peux commencer par déclarer un tableau de 200 cases. Ou définir une constante N (en majuscule, c'est une convention pour les constantes) qui sera égale à 200 et utilisée pour la taille du tableau).

Ensuite, tu auras quelque problèmes avec la fonction getchar(), qui ne fait pas précisément ce que tu penses. Tu sembles l'employer comme on emploierait un scanf("%c")...

Enfin, ta boucle do-while n'est pas correcte, puisqu'elle affichera toujours n fois ou n-1 fois le message "non"...

[Thierry Chappuis]

Voici une petite correction commentée:

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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
#include <stdio.h>
 
/* -tc- Definit la taille maximale du tableau a utiliser */
#define MAX 200
 
/* -tc- Permet de purger le contenu du tampon d'un flux entrant */
static void
fpurge(FILE *fp)
{
    if (fp != NULL)
    {
        int c;
 
        while ((c = fgetc(fp)) != '\n' && c != EOF)
        {
        }
    }
}
 
int
main(void)
{
    /* -tc- La taille d'un tableau doit etre definie par une expression
       constante. C'est par ailleurs une bonne pratique que d'initialiser toutes
       les cases d'un tableau de char a la valeur 0 */
    char tab[MAX + 1] = {0};
    int nb;
    int i;
    int c;
    int rv; /* -tc- valeur retournee par scanf() */
    int end = 0; /* -tc- drapeau de sortie pour la boucle de saisie des caracteres*/
    int ok = 0; /* -tc- drapeau pour la recherche du caractere */
 
    /* -tc- Je recommande de securiser un peu la saisie. Ici, le choix de scanf()
       n'est pas optimal et je prefere en general utiliser une solution a base
       de fgets() */
    do
    {
        printf("Combien de cases voulez-vous remplir? ");
        /* -tc- Ici, il est necessaire de forcer l'affichage de l'invite, car
           elle ne se termine pas par un caractere de fin de ligne. */
        fflush(stdout);
        rv = scanf("%d", &nb);
        /* -tc- C'est une pratique recommandee de faire le menage dans le tampon
           du flux d'entree standard apres chaque appel a scanf(). */
        fpurge(stdin);
        if (nb > MAX)
        {
            fprintf(stderr, "Erreur: %d cases maximum!\n", MAX);
        }
        /* -tc- On profite de tester que l'utilisateur a bien entre un entier
           et que sa valeur est bien positive et inferieure a la taille du
           tableau */
    }
    while (rv != 1 || nb > MAX || nb < 0);
 
    /* -tc- Cette boucle demande a l'utilisateur de saisir un caractere nb fois.
       Elle s'arrete apres nb execution ou lorsque l'utilisateur appuye sur
       CTRL-Z (Windows) ou CTRL-D (Linux) */
    for (i = 0; end == 0 && i < nb; i++)
    {
        printf("Veuillez saisir le caractère present a la case %d: ", i);
        fflush(stdout);
        /* -tc- N.B. getchar() retourne un entier de type int qui vaut EOF ou
           un entier positif dont la valeur est representable par un
           unsigned char */
        c = getchar();
        if (c != EOF)
        {
            /* -tc- Si le caractere saisi est different de '\n' et de EOF, on
               purge le tampon du flux d'entree standard */
            if (c != '\n')
            {
                fpurge(stdin);
            }
            tab[i] = c;
        }
        else
        {
            /* -tc- Si l'utilisateur entre EOF, on sort de la boucle. La saisie
               est terminee */
            end = 1;
        }
    }
 
    printf("Quel caractère voulez vous rechercher? ");
    fflush(stdout);
    c = getchar();
    if (c != '\n' && c != EOF)
    {
        fpurge(stdin);
    }
 
    /* -tc- Il est possible de se passer de la boucle ci-dessous en utilisant la
       fonction strchr() declaree dans string.h */
    for (i = 0; ok == 0 && tab[i] != 0; i++)
    {
        if (tab[i] == c)
        {
            ok = 1;
        }
    }
 
    /* -tc- On teste si le caractere saisi est dans la chaine */
    if (ok == 1)
    {
        printf("Oui, je suis dedans!\n");
    }
    else
    {
        printf("Non, je ne suis pas dedans!\n");
    }
 
    return 0;
}

Thierry

[carriebradshaw]

Merci au modérateur pour sa réponse

Encore un autre exercice d'entrainement je voudrais savoir si le code est juste ou il y a des erreurs

Matrix:
Ecrire un programme qui crée 2 tableaux de n*n cases.Les tableaux seront alors remplis des valeurs aléatoires comprises entre 0 et 100. Votre programme permettra d'afficher la somme de ces 2 matrices

Voilà le code:

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
 
1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <time.h>
4.
5. int **create_mat(int, int);
6. void print_sum(int **, int **, int, int);
7. void desalloc(int **, int);
8.
9. int main(int argc, char **argv){
10. int **mat1, **mat2;
11.
12. if (argc != 3){
13. printf("Usage : %s n p\n", argv[0]);
14. return -1;
15. }
16.
17. mat1 = create_mat(atoi(argv[1]), atoi(argv[2]));
18. mat2 = create_mat(atoi(argv[1]), atoi(argv[2]));
19.
20. print_sum(mat1, mat2, atoi(argv[1]), atoi(argv[2]));
21.
22. desalloc(mat1, atoi(argv[1]));
23. desalloc(mat2, atoi(argv[1]));
24. return 0;
25. }
26.
27. int **create_mat(int n, int p){
28. int **matrice;
29. int i, j;
30.
31.
32. matrice = (int **) malloc(n * sizeof(int *));
33. for (i=0; i<n; i++)
34. matrice[i] = (int *) malloc(p * sizeof(int));
35.
36. srand(time(NULL));
37. for (i=0; i<n; i++){
38. for (j=0; j<p; j++)
39. matrice[i][j] = rand()%101;
40. }
41.
42. return matrice;
43. }
44.
45. void print_sum(int **mat1, int **mat2, int n, int p){
46. int i,j;
47.
48. for (i=0; i<n; i++){
49. for (j=0; j<p; j++)
50. printf("%d ", mat1[i][j]+mat2[i][j]);
51. printf("\n" );
52. }
53. }
54.
55. void desalloc(int **mat, int n){
56. int i;
57.
58. for (i=0; i<n; i++)
59. free(mat[i]);
60. free(mat);
61. }

[droggo]

Fie,

Puisque tu apprends, apprends également à mettre ton code en forme, quelque chose comme ceci:

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
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
int **create_mat(int, int);
void print_sum(int **, int **, int, int);
void desalloc(int **, int);
 
int main(int argc, char **argv)
{
    int **mat1, **mat2;
 
    if (argc != 3)
    {
        printf("Usage : %s n p\n", argv[0]);
        return -1;
    }
 
    mat1 = create_mat(atoi(argv[1]), atoi(argv[2]));
    mat2 = create_mat(atoi(argv[1]), atoi(argv[2]));
 
    print_sum(mat1, mat2, atoi(argv[1]), atoi(argv[2]));
 
    desalloc(mat1, atoi(argv[1]));
    desalloc(mat2, atoi(argv[1]));
    return 0;
}
 
int **create_mat(int n, int p)
{
    int **matrice;
    int i, j;
 
 
    matrice = (int **) malloc(n * sizeof(int *));
    for (i=0; i<n; i++)
        matrice[i] = (int *) malloc(p * sizeof(int));
 
    srand(time(NULL));
    for (i=0; i<n; i++)
    {
        for (j=0; j<p; j++)
            matrice[i][j] = rand()%101;
    }
 
    return matrice;
}
 
void print_sum(int **mat1, int **mat2, int n, int p)
{
    int i,j;
 
    for (i=0; i<n; i++)
    {
        for (j=0; j<p; j++)
            printf("%d ", mat1[i][j]+mat2[i][j]);
        printf("\n" );
    }
}
 
void desalloc(int **mat, int n)
{
    int i;
 
    for (i=0; i<n; i++)
        free(mat[i]);
    free(mat);
}

qui rend le code nettement plus lisible, et donc maintenable.

Sinon, je n'ai pas pris le temps de lire ton code.

[Thierry Chappuis]

Voici quelques corrections et commentaires:

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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
int **create_mat(int, int);
void print_sum(int **, int **, int, int);
void desalloc(int **, int);
int alea(int n);
 
int main(int argc, char **argv)
{
    /* -tc- C'est sans doute une question de preference personnelle, mais c'est
       selon moi une bonne pratique de ne definir qu'une varaible par ligne et
       d'initialiser les pointeurs a la valeur NULL (signifie que l'adresse est
       invalide). */
    int **mat1 = NULL;
    int **mat2 = NULL;
    /* -tc- J'utilise de preference le type size_t pour representer les
       dimensions d'une matrice. */
    int nligs = 0;
    int ncols = 0;
    char *pend = NULL;
 
    /* -tc- Le generateur de nombres pseudo-aleatoires doit etre initialise une
       seule fois au debut du programme, et non a chaque appel de create_mat().*/
    srand(time(NULL));
 
    if (argc != 3)
    {
        fprintf(stderr, "Usage : %s n p\n", argv[0]);
        /* -tc- main() ne peut retourner de maniere portable que 0, EXIT_SUCCESS
           ou EXIT_FAILURE. En principe, je n'aime pas trop les return sauvages,
           mais bon, les gouts et les couleurs... */
        return EXIT_FAILURE;
    }
 
    /* -tc- Pour la representation en chaine de caractere d'un entier, je
       prefere utiliser la fonction strtol() qui permet une gestion d'erreur
       beaucoup plus fine de atoi() devenue (inofficiellement?) obsolete. */
    nligs = strtol(argv[1], &pend, 10);
    /* -tc- On teste que l'entier passe par l'utilisateur en etait bien un. En
       principe, il faudrait encore traiter les debordements eventuels de
       capacite. */
    if (*pend != 0)
    {
        fprintf(stderr, "Erreur: l'argument n doit etre un nombre!\n");
        fprintf(stderr, "Usage : %s n p\n", argv[0]);
        /* -tc- Meme remarque que plus haut consernant les return sauvages... */
        return EXIT_FAILURE;
    }
 
    ncols = strtol(argv[2], &pend, 10);
    if (*pend != 0)
    {
        fprintf(stderr, "Erreur: l'argument p doit etre un nombre!\n");
        fprintf(stderr, "Usage : %s n p\n", argv[0]);
        /* -tc- Meme remarque que plus haut consernant les return sauvages... */
        return EXIT_FAILURE;
    }
 
    /* -tc- Il faut tester que la creation des matrices n'a pas echoue! */
    mat1 = create_mat(nligs, ncols);
    if (mat1 != NULL)
    {
        mat2 = create_mat(nligs, ncols);
        if (mat2 != NULL)
        {
            print_sum(mat1, mat2, atoi(argv[1]), atoi(argv[2]));
 
            desalloc(mat2, nligs), mat2 = NULL;
        }
        desalloc(mat1, nligs), mat1 = NULL;
    }
 
    return 0;
}
 
int **create_mat(int n, int p)
{
    /* -tc- C'est une bonne pratique d'initialiser les pointeurs a la valeur
       NULL. */
    int **matrice = NULL;
 
    /* -tc- En C, il est deconseille de caster la valeur retournee par malloc(). */
    matrice = malloc(n * sizeof *matrice);
    /* -tc- Par contre, il est fortement conseille de tester la valeur retournee
       par malloc(). */
    if (matrice != NULL)
    {
        int i, j;
        int err = 0;
 
        /* -tc- Je recommande de toujours utiliser les accolades, meme lorsque
           la boucle possede une instruction unique. C'est beaucoup plus lisble! */
        for (i = 0; err == 0 && i < n; i++)
        {
            matrice[i] = malloc(p * sizeof *matrice[i]);
            /* -tc- La aussi, on teste la valeur retournee par malloc(). En cas
               d'echec, on n'oublie pas de faire le menage! */
            if (matrice[i] != NULL)
            {
                for (j = 0; j < p; j++)
                {
                    matrice[i][j] = alea(100);
                }
            }
            else
            {
                /* -tc- Erreur d'allocation: on fait le menage! */
                while (i > 0)
                {
                    i--;
                    free(matrice[i]);
                }
                free(matrice), matrice = NULL;
                err = 1;
            }
        }
    }
 
 
    return matrice;
}
 
void print_sum(int **mat1, int **mat2, int n, int p)
{
    if (mat1 != NULL && mat2 != NULL && n > 0 && p > 0)
    {
        int i, j;
 
        for (i = 0; i < n; i++)
        {
            for (j = 0; j < p; j++)
            {
                printf("%d ", mat1[i][j] + mat2[i][j]);
            }
            printf("\n" );
        }
    }
}
 
void desalloc(int **mat, int n)
{
    /* -tc- On commence par valider les arguments */
    if (mat != NULL && n > 0)
    {
        int i;
 
        for (i = 0; i < n; i++)
        {
            free(mat[i]);
        }
        free(mat);
    }
}
 
/* -tc- Fonction recommandee dans la FAQ C pour generer un nombre aleatoire
   entre 0 et N. Pour plus d'infos:
   - http://c.developpez.com/faq/?page=nombres#NOMBRES_random_bornes
   - http://www.bourguet.org/cpp/random.pdf
*/
int alea(int n)
{
    int partSize   = (n == RAND_MAX) ? 1 : 1 + (RAND_MAX - n)/(n+1);
    int maxUsefull = partSize * n + (partSize-1);
    int draw;
 
    do
    {
        draw = rand();
    }
    while (draw > maxUsefull);
    return draw/partSize;
}

Thierry

[carriebradshaw]

Merci pour la réponse maintenant je comprend beaucoup mieux merci encore