Tableau dynamique d'entier

Version imprimable

J'aimerais créer un tableau dont l'utilisateur decidera combien d'entrées il aura et c'est l'utilisateur qui va entrer manuellement les valeurs du tableau.

J'ai un ptit souci mon code compile je pense avoir bien utilisé la fonction malloc mais pourtant meme si je demande 10 entrées dans mon tableau La boucle du tableau s'arrete au bout de 3 entrées :(

voici mon petit code :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 #include <stdio.h> #include <stdlib.h> int main() { size_t size; int *t; int i,max ; printf("Entrer Le nombre de valeurs de votre suite \n"); scanf("%d", &size); t = (int *)malloc(size * sizeof(int)); if(t == NULL){ printf("Memoire insuffisante.\n"); exit(getch());} for(i = 1; i < size; i++){ printf("Donnez le Nombre numero %d de votre suite\n" , i); scanf("%d",t[i]); } for (i = 1; i < size; i++){ printf("la valeur numero %d de la suite est %d\n",i,t[i]); } return 0 ; }
Si quelqu'un pouvais jetter un coup d'oeil ca serai gentil a vous .

Merci par avance car je c'est a quel point les membres de ce forum sont competants Merci a vous tous !!!!! Ce site est incontournable pour un debutant qui souhaite progresser :oops:

01/04/2008, 14h00
PsychoH13

Pour commencer, il ne faut pas faire de cast sur malloc(). Donc le (int *) il faut le virer.
Ensuite, les index dans un tableau de N éléments vont de 0 à N-1, donc avec ta boucle tu perds une position en commençant par 1 et non pas par zéro.
Et pour finir, scanf() demande des adresses comme paramètres pour pouvoir modifier le contenu des variables pointées... Bien que "t" soit un tableau et donc représente son adresse. Lorsqu'on accède à l'une de ses variables via l'opérateur [], on obtient un entier, et non pas une adresse, il faut donc l'adresse de cette case c'est-à-dire : &t[i].

Commence déjà par ça.
01/04/2008, 17h26
Thierry Chappuis

Citation:

Envoyé par PsychoH13

Pour commencer, il ne faut pas faire de cast sur malloc(). Donc le (int *) il faut le virer.

Suite à un débat ayant eu lieu récemment sur ce forum, je dirais que le cast de la valeur de retour de malloc() est inutile en C et qu'il est idiomatique de ne pas convertir explicitement cette valeur. Maintenant, pour le "il faut", je dirais que chacun est libre, sachant que K&R, les créateurs du langages, conseillent dans leur errata de laisser tomber ce cast.

Thierry
01/04/2008, 17h31
PsychoH13

Faire un cast de malloc() peut couvrir d'autres erreurs, donc il est à éviter.

Citation:

Envoyé par PsychoH13

Faire un cast de malloc() peut couvrir d'autres erreurs, donc il est à éviter.

Sur le fond, on est accord. Voir: http://www.developpez.net/forums/sho...ghlight=errata pour d'autres points de vue à ce sujet.

Citation:

Envoyé par PsychoH13

Pour commencer, il ne faut pas faire de cast sur malloc(). Donc le (int *) il faut le virer.
Ensuite, les index dans un tableau de N éléments vont de 0 à N-1, donc avec ta boucle tu perds une position en commençant par 1 et non pas par zéro.
Et pour finir, scanf() demande des adresses comme paramètres pour pouvoir modifier le contenu des variables pointées... Bien que "t" soit un tableau et donc représente son adresse. Lorsqu'on accède à l'une de ses variables via l'opérateur [], on obtient un entier, et non pas une adresse, il faut donc l'adresse de cette case c'est-à-dire : &t[i].

Commence déjà par ça.

A tout ceci, je peux encore ajouter qu'il est risqué de saisie un entier de type size_t avec scanf(). Voici ma proposition de correction:

Code:

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
static void fclean(char *buffer, FILE *fp);
static long get_long(char const *msg, int *err);
static unsigned long get_ulong(char const *msg, int *err);
 
int main(void)
{
    size_t size;
    int *t = NULL;;
    int err;
    int ret = 0;
 
    do
    {
        size = get_ulong("Entrer Le nombre de valeurs de votre suite:", &err);
    }
    while (err != 0);
 
    t = malloc(size * sizeof *t);
    if (t != NULL)
    {
        size_t i;
 
        for (i = 0; i < size; i++)
        {
            do
            {
                printf("Donnez le nombre numero %d de votre suite\n" , i);
                t[i] = get_long(NULL, &err);
            }
            while (err != 0);
        }
 
        for (i = 0; i < size; i++)
        {
            printf("la valeur numero %d de la suite est %d\n", i, t[i]);
        }
    }
    else
    {
        printf("Memoire insuffisante.\n");
        ret = EXIT_FAILURE;
    }
 
    return ret;
}
 
static void
fclean(char *buffer, FILE *fp)
{
    if (buffer != NULL && fp != NULL)
    {
        char *pc = strchr(buffer, '\n');
 
        if (pc != NULL)
        {
            *pc = 0;
        }
        else
        {
            int c;
 
            while ((c = fgetc(fp)) != '\n' && c != EOF)
            {
            }
        }
    }
}
 
static long
get_long(char const *msg, int *err)
{
    long ret = 0;
    char buffer[16] = "";
    char *pend = NULL;
 
    if (err != NULL)
    {
        *err = 0;
    }
 
    if (msg != NULL)
    {
        printf("%s ", msg);
        fflush(stdout);
    }
    fgets(buffer, sizeof buffer, stdin);
    fclean(buffer, stdin);
 
    ret = strtoul(buffer, &pend, 0);
    if (*pend != 0 && err != NULL)
    {
        *err = 1;
    }
 
    return ret;
}
 
static unsigned long
get_ulong(char const *msg, int *err)
{
    unsigned long ret = 0;
    char buffer[16] = "";
    char *pend = NULL;
 
    if (err != NULL)
    {
        *err = 0;
    }
 
    if (msg != NULL)
    {
        printf("%s ", msg);
        fflush(stdout);
    }
    fgets(buffer, sizeof buffer, stdin);
    fclean(buffer, stdin);
 
    ret = strtoul(buffer, &pend, 0);
    if (*pend != 0 && err != NULL)
    {
        *err = 1;
    }
 
    return ret;
}

C'est un peu long, mais dès qu'il y a des saisies utilisateur, il n'y a pas de miracle.

Thierry

01/04/2008, 22h48
ramoucho75020

Merci bcp pour toute ces reponses en si peu de temps !! meme si il est un peu tot pour certains , j'ai eu une dur journée j'etudierai tout ca en particulier la correction de Mr thierry dés demain matin !! merci encore et bonne soirée

Effectivement ton code est efficace et gere bien l'allocation dynamique de la mémoire pour le tableau .

J'ai modifier la fin du main pour ajouter une partie verification de la suite entrer , j'aimerais bien verifier que le dernier terme est toujours superieur à la somme des termes precedent , soit incorporer cela dans la sasit ou comme je viens de le faire mais sans avoir d'erreur de compilation ca marche pas !!! j'ai bien passé deux heures a essayer plusieurs choses ....

Merci a vous si vous pouvez juste jetter un coup d'oeil !

Code:

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
static void fclean(char *buffer, FILE *fp);
static long get_long(char const *msg, int *err);
static unsigned long get_ulong(char const *msg, int *err);
 
int main(void)
{
    size_t size;
    int *t = NULL;;
    int err , j,i , somme ;
    int ret = 0;
 
    do
    {
        size = get_ulong("Entrer Le nombre de valeurs de votre suite:", &err);
    }
    while (err != 0);
 
    t = malloc(size * sizeof *t);
    if (t != NULL)
    {
        size_t i;
 
        for (i = 0; i < size; i++)
        {
            do
            {
                printf("Donnez le nombre numero %d de votre suite\n" , i+1);
                t[i] = get_long(NULL, &err);
            }
            while (err != 0);
        }
 
        for (i = 0; i < size; i++)
        {
            printf("la valeur numero %d de la suite est %d\n", i+1, t[i]);
        }
    }
    else
    {
        printf("Memoire insuffisante.\n");
        ret = EXIT_FAILURE;
    }
 
    for ( i = size ; i > 0 ; i-- )   /*lecture a l'envers du tableau */
    {
        for ( j = i-1 ; j>0 ; j-- ) /* somme de tous les i-1 */
        {
            somme = somme + t[j] ;
        }
        if (t[i] > somme )
 
        {
            printf("ok\n") ;
 
        }
        else
        {
            printf("erreur\n") ;
        }
    }
 
 
 
 
 
 
    return ret ;
}
 
static void
fclean(char *buffer, FILE *fp)
{
    if (buffer != NULL && fp != NULL)
    {
        char *pc = strchr(buffer, '\n');
 
        if (pc != NULL)
        {
            *pc = 0;
        }
        else
        {
            int c;
 
            while ((c = fgetc(fp)) != '\n' && c != EOF)
            {
            }
        }
    }
}
 
static long
get_long(char const *msg, int *err)
{
    long ret = 0;
    char buffer[16] = "";
    char *pend = NULL;
 
    if (err != NULL)
    {
        *err = 0;
    }
 
    if (msg != NULL)
    {
        printf("%s ", msg);
        fflush(stdout);
    }
    fgets(buffer, sizeof buffer, stdin);
    fclean(buffer, stdin);
 
    ret = strtoul(buffer, &pend, 0);
    if (*pend != 0 && err != NULL)
    {
        *err = 1;
    }
 
    return ret;
}
 
static unsigned long
get_ulong(char const *msg, int *err)
{
    unsigned long ret = 0;
    char buffer[16] = "";
    char *pend = NULL;
 
    if (err != NULL)
    {
        *err = 0;
    }
 
    if (msg != NULL)
    {
        printf("%s ", msg);
        fflush(stdout);
    }
    fgets(buffer, sizeof buffer, stdin);
    fclean(buffer, stdin);
 
    ret = strtoul(buffer, &pend, 0);
    if (*pend != 0 && err != NULL)
    {
        *err = 1;
    }
 
    return ret;
 
 
 
}

Wesh ramosssssse, roule un braaaaaaaaaaa ahahah:yaisse2:

essaye de rajouter un truc comme ca pour vérifier qu'il s'agit bien d'une suite supercroissante.
Code:

1 2 3 4 5 6 7 8 for (i = 0; i < size; i++) { int k = 1 + rand () % 4; t[i] = rand () % k + somme + 1; somme += t[i]; }

06/04/2008, 14h40
ramoucho75020

j'ai essayé j 'y arrive pas , j pensais que mon erreur venait peut etre de la reinitilisation de la variable somme .

lorsque je met

somme = 0 ; aprés les printf "ok" et "erreur" pour reinitialiser la somme ca ne marche toujours pas pourtant mon algorithme semble correct !!!!

j'ai besoin d'aiiiiide svp !! ou ne serai ce qu'une piste pour comprendre ce qui se passe.

g reussi :D

je poste le code si ca peut aider quelqu'un !!!

Merci a tous en particulier a thierry

Code:

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
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
static void fclean(char *buffer, FILE *fp);
static long get_long(char const *msg, int *err);
static unsigned long get_ulong(char const *msg, int *err);
 
int main(void)
{
    size_t size;
    int *t = NULL;;
    int err , j,i , somme , cpt;
    int ret = 0;
    char  a;
    do
    {
        size = get_ulong("Entrer Le nombre de valeurs de votre suite:", &err);
    }
    while (err != 0);
 
    t = malloc(size * sizeof *t);
    if (t != NULL)
    {
        size_t i;
 
        for (i = 0; i < size; i++)
        {
            do
            {
                printf("Donnez le nombre numero %d de votre suite\n" , i+1);
                t[i] = get_long(NULL, &err);
            }
            while (err != 0);
        }
 
        for (i = 0; i < size; i++)
        {
            printf("la valeur numero %d de la suite est %d\n", i+1, t[i]);
        }
    }
    else
    {
        printf("Memoire insuffisante.\n");
        ret = EXIT_FAILURE;
    }
    somme = 0 ;
    cpt = 0 ;
    for ( i = size-1 ; i > 0 ; i-- )   /*lecture a l'envers du tableau */
    {
        for ( j = i-1 ; j>0 ; j-- ) /* somme de tous les i-1 */
        {
 
            somme = somme + t[j] ;
        }
        if (t[i] <= somme )
        {
             cpt = cpt  + 1 ;
             printf("%d,%d",i, somme);
        }
 
        somme= 0 ;
    }
 
    if ( cpt > 0 )
    {
         printf("\n\n\n La suite n est pas supercroissante , il y a %d erreur \n" , cpt ) ;
         }
         else
         {
             printf("\n\n\n La suite est bien supercroissante et elle sera utilisee pour le cryptage \n") ;
             }
 
    scanf  ("%c", &a);
 
 
 
 
 
    return ret ;
}
 
static void
fclean(char *buffer, FILE *fp)
{
    if (buffer != NULL && fp != NULL)
    {
        char *pc = strchr(buffer, '\n');
 
        if (pc != NULL)
        {
            *pc = 0;
        }
        else
        {
            int c;
 
            while ((c = fgetc(fp)) != '\n' && c != EOF)
            {
            }
        }
    }
}
 
static long
get_long(char const *msg, int *err)
{
    long ret = 0;
    char buffer[16] = "";
    char *pend = NULL;
 
    if (err != NULL)
    {
        *err = 0;
    }
 
    if (msg != NULL)
    {
        printf("%s ", msg);
        fflush(stdout);
    }
    fgets(buffer, sizeof buffer, stdin);
    fclean(buffer, stdin);
 
    ret = strtoul(buffer, &pend, 0);
    if (*pend != 0 && err != NULL)
    {
        *err = 1;
    }
 
    return ret;
}
 
static unsigned long
get_ulong(char const *msg, int *err)
{
    unsigned long ret = 0;
    char buffer[16] = "";
    char *pend = NULL;
 
    if (err != NULL)
    {
        *err = 0;
    }
 
    if (msg != NULL)
    {
        printf("%s ", msg);
        fflush(stdout);
    }
    fgets(buffer, sizeof buffer, stdin);
    fclean(buffer, stdin);
 
    ret = strtoul(buffer, &pend, 0);
    if (*pend != 0 && err != NULL)
    {
        *err = 1;
    }
 
    return ret;
 
 
 
}

10/04/2008, 20h26
YASIR

Pour le calcul des C, regarde ces posts ils t'aideront

http://www.developpez.net/forums/sho....php?p=3104260
http://www.developpez.net/forums/sho....php?p=3064806

:bug: