Discussion :

[acryline]

Bonjour,
j'aimerais utiliser un tableau pour récupérer des chaînes de caractères de taille inférieure à 50 caractères. Donc seul le nombre de chaînes varie.

En fait on a un tableau défini ainsi :

Code :

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

char chaine[N][50];

Comment faire ?
Merci pour votre aide.

[femtosa]

FAQ, recherche et quand même, oui oui, un peu de réflexion ...

[Garulfo]

Bonjour,
j'aimerais utiliser un tableau pour récupérer des chaînes de caractères de taille inférieure à 50 caractères. Donc seul le nombre de chaînes varie.

En fait on a un tableau défini ainsi :

Code :

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

char chaine[N][50];

Comment faire ?
Merci pour votre aide.

Comment faire pour faire quoi ?
Pour lire les chaînes de caractères ?

Si tu n'en avais qu'une seule tu ferais probablement ça.

Code :

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

1
2
char chaine[50];
scanf("%s", chaine);

N'est ce pas ?

Donc tu fais pareil mais au lieu de mettre une variable chaine, tu mets une « cellule » de ton tableau qui pointe sur une chaîne... vois-tu ?

[Franck.H]

La valeur de N varie au cours de l'exécution du programme ? Car sinon il faut passer par un tableau dynamique donc par allocation ce qui change sensiblement ton tableau et sa création

[Thierry Chappuis]

Comment faire pour faire quoi ?
Pour lire les chaînes de caractères ?

Si tu n'en avais qu'une seule tu ferais probablement ça.

Code :

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

1
2
char chaine[50];
scanf("%s", chaine);

N'est ce pas ?

Donc tu fais pareil mais au lieu de mettre une variable chaine, tu mets une « cellule » de ton tableau qui pointe sur une chaîne... vois-tu ?

Si j'en avais qu'une seule je ferais:

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
void fclean(char *s_buff, FILE *fp);
 
int main(void)
{
    char s_buff[50] = {0};
 
    printf("Entrz une chaine: ");
    fflush(stdout);
 
    if (fgets(s_buff, sizeof s_buff, stdin) != NULL)
    {
        fclean(s_buff, stdin);
        /* Suite du code */
    }
    else
    {
        fprintf(stderr, "Input error!\n");
    }
 
    return EXIT_SUCCESS;
}
 
void fclean(char *s_buff, FILE *fp)
{
    char *pc = strchr(s_buff, '\n');
 
    if (pc != NULL)
    {
        *pc = 0;
    }
    else
    {
        int c;
        while ((c = fgetc(fp)) != '\n' && c != EOF)
        {
            continue;
        }
    }
}

voir, si vraiment il faut utiliser scanf():

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>
#include <stdlib.h>
#include <string.h>
 
int main(void)
{
    char s_buff[50] = {0};
    int c;
 
    printf("Entrz une chaine: ");
    fflush(stdout);
 
    if (scanf("%49[^\n]", s_buff) == 1)
    {
        if ((c = getchar()) != '\n')
        {
            /* saisie trop longue: on vide le tampon */
            scanf("%*[^\n]");
            getchar();
        }
 
        printf("%s\n", s_buff);
    }
 
    return EXIT_SUCCESS;
}

mais:

Code :

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

1
2
char chaine[50];
scanf("%s", chaine);

n'est pas une idée très inspirée.

Sinon, voici une exemple avec tableau dynamique:

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
void fclean(char *s_buff, FILE *fp)
{
    char *pc = strchr(s_buff, '\n');
 
    if (pc != NULL)
    {
        *pc = 0;
    }
    else
    {
        int c;
        while ((c = fgetc(fp)) != '\n' && c != EOF)
        {
            continue;
        }
    }
}
 
int main(void)
{
    int err = EXIT_SUCCESS;
    int N = 3;
    int end = 0;
    char (*p_tab)[50] = NULL;
 
    p_tab = malloc(N * sizeof *p_tab);
    if (p_tab != NULL)
    {
        int i;
 
        /* Initialisation du tableau */
        memset(p_tab, 0, N * sizeof *p_tab);
 
        /* Saisie des chaines de caractère */
        for (i = 0; i < N && end == 0; ++i)
        {
            printf("Entrez une chaine: ");
            fflush(stdout);
 
            if (fgets(p_tab[i], sizeof p_tab[i], stdin) != NULL)
            {
                fclean(p_tab[i], stdin);
                if (strcmp(p_tab[i], "quit") == 0)
                {
                    *p_tab[i] = 0;
                    end = 1;
                }
            }
        }
 
        /* Affichage des chaines saisies */
        for (i = 0; i < N && *p_tab[i] != 0; ++i)
        {
            puts(p_tab[i]);
        }
 
        free(p_tab), p_tab = NULL;
    }
    else
    {
        fprintf(stderr, "Erreur d'allocation mémoire!\n");
        err = EXIT_FAILURE;
    }
    return err;
}

Thierry

[acryline]

Jde l'avais mis en titre alors j'ai fait l'erreur de penser que ça suffisait.
Je voulais savoir comment utiliser l'allocation dynamique avec un tableau de chaîne sachant que le nombre de chaînes peut changer.

Pour un tableau normal on fait comme ça :

Code :

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

1
2
3
4
 
//Tableau char chaine[N]
char *chaine;
chaine = malloc(N*sizeof(char));

Pour un tableau de chaînes ça donne ?

Code :

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

1
2
3
4
 
//Tabeau char chaine [N][50];
char  ????????; 
chaine =???????;

C'était tout ce que je voualais savoir Récupérer je sais faire...

Merci !
Edité : je crois que j'ai trouvé à la fin du code de mujigka, ceci :

Code :

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

1
2
3
 
   char (*p_tab)[50] = NULL;
    p_tab = malloc(N * sizeof *p_tab);

J'avais fait un peu ça mais ça ne focntionnait pas, j'ai dû faire une petite erreur... je m'y remets . Merci

[Médinoc]

Tu peux jouer avec realloc() (attention, pièges) ou créer une liste chaînée à la place (quitte à la reconvertir en tableau une fois la taille connue).

[Garulfo]

[...]
Thierry

Te rends tu compte que la question posée montre que la personne n'en est pas rendu là ?

On commence doucement... et on mène à la bonne réponse.

D'où ma réponse à sa question.

[v4np13]

Je ferai 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
char ** lignes = NULL;
int i;
 
//Allocation de la mémoire
lignes = (char **)malloc(NB_LIGNES*sizeof(char *));  
if (lignes == NULL) {
  perror("Erreur d'allocation de mémoire");
  return -1;
}
for (i= 0; i<NB_LIGNES; i ++){
  lignes[i] = NULL;
  lignes[i] = (char *)malloc(50*sizeof(char)); //50 lettres/ligne
  if (lignes[i] == NULL) {
    perror("Erreur d'allocation de mémoire");
    return -1;
  }
}
 
/*
 * Operations
 */
 
//Libération de la mémoire
for (i = 0; i<NB_LIGNES; i ++){
  free(lignes[i]);
}
free(lignes);

[Garulfo]

Jde l'avais mis en titre alors j'ai fait l'erreur de penser que ça suffisait. [...]Merci

Excuses moi... c'est moi qui ai mal lu le titre.
Tout était là. Et je me suis trompé sur ton niveau... La remarque de Mujigka était donc pleinement justifiée -_-

Donc ce que tu te demandes c'est comment allouer correctement la mémoire pour un tableau à deux dimensions en fait ?

La réponse de Mujigka fonctionne mais n'est pas le meilleur choix.
Cependant dans un premier temps ça te sera probablement bien suffisant.
Quand tu voudras aller plus loin, tu as ça
http://rperrot.developpez.com/articl...ationC/#L1.1.1
Tu as une bonne explication des malloc, calloc et realloc.

Mais cependant en faisant l'allocation telle que proposée par Mujigka tu alloues des espaces mémoires qui peuvent être disparates dans leurs localisations dans l'espace mémoire. De plus un tableau statique est alloué sur la pile d'appel (callstack) ce qui peut être génant (notamment si tu utilises beaucoup de fonctions récursives dans ton programme).
Il vaut mieux allouer un bloc et le découper en morceaux.
Je laisse tomber les vérifications sur les pointeurs:

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
 
    int nb_lignes = 3;
    int nb_colonnes = 5; 
    int **matrice;          // Le pointeur sur la matrice
    int *_bloc_memoire; // Le bloc mémoire complet de la matrice
    int ligne;                 // indice pour le parcours des lignes
 
    // déclaration de l'espace nécessaire pour toute la matrice
    _bloc_memoire = malloc(nb_lignes * nb_colonnes * sizeof(int));
 
    // déclaration des pointeurs sur chaque ligne
    matrice = malloc(nb_lignes * sizeof(*int));
 
    // découpage du bloc de mémoire en nb_lignes
    for (ligne=0; ligne<nb_lignes; ligne++)
    {
        matrice[ligne] = _bloc_memoire + (nb_cols * ligne)
    }

Mais bon, encore une fois, si c'est une très bonne manière de procéder, il vaut mieux commencer simplement.

[Thierry Chappuis]

Te rends tu compte que la question posée montre que la personne n'en est pas rendu là ?

On commence doucement... et on mène à la bonne réponse.

D'où ma réponse à sa question.

Je n'ai fait que montrer comment faire correctement une saisie de chaîne de caractères, suite à ton intervention qui mentionnait une solution à base de

Code :

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

scanf("%s", tampon)

A éviter comme la peste, comme gets() d'ailleurs. Les entrées utilisateur, c'est quelque chose de relaivement complexe en C. Je suis d'accord pour commencer en douceur, mais ce n'est pas une raison pour conseiller n'

Le reste n'est qu'exemple...

Thierry

[Garulfo]

Code :

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

1
2
3
[...]
  lignes[i] = (char *)malloc(50*sizeof(char)); //50 lettres/ligne
[...]

Un commentaire :
Il n'est pas nécessaire en C de procéder à une conversion explicite du pointeur obtenu par malloc en pointeur de caractère.
Cependant, c'est une très bonne habitude car le C++ lui l'exige.
J'aurais du aussi l'ajouter.

[Garulfo]

Je n'ai fait que montrer comment faire correctement une saisie de chaîne de caractères, suite à ton intervention qui mentionnait une solution à base de

Code :

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

scanf("%s", tampon)

[...]

Thierry

Mais non ce n'est pas à éviter comme la peste.
Mais je suis d'accord que ce n'est pas une bonne manière de faire...

Tu as lu mon message disant que j'avais tort de ma remarque ??

[crocodilex]

Code :

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

    matrice = malloc(nb_lignes * sizeof(*int));

Ce n'est pas du C ça...

[Thierry Chappuis]

Mais cependant en faisant l'allocation telle que proposée par Mujigka tu alloues des espaces mémoires qui peuvent être disparates dans leurs localisations dans l'espace mémoire. De plus un tableau statique est alloué sur la pile d'appel (callstack) ce qui peut être génant (notamment si tu utilises beaucoup de fonctions récursives dans ton programme).
Il vaut mieux allouer un bloc et le découper en morceaux.
Je laisse tomber les vérifications sur les pointeurs:

En quoi ma solution alloue des espaces mémoires qui peuvent être disparates dans leurs localisations dans l'espace mémoire? J'ai un espace contigü de Nx50, non? Par ailleurs, je n'alloue pas ground chose sur la pile...

[Edit] Je pense que ma solution est adaptée dans la mesure où seule la première dimension du tableau varie, comme l'a mentionné le PO.

Thierry

[Thierry Chappuis]

Mais non ce n'est pas à éviter comme la peste.
Mais je suis d'accord que ce n'est pas une bonne manière de faire...

Oui, c'est à éviter si tu désires avoir des entrées utilisateur sécurisées... Tu peut éventuellement faire:

Code :

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

1
2
char s_tampon[50] = {0};
scanf("%49s", s_tampon);

Si tu es certain que la chaine entrée par l'utilisateur ne contiendra pas d'espace, et que tu prend garde à nettoyer le tampon après ton passage...

Thierry

[Thierry Chappuis]

Un commentaire :
Il n'est pas nécessaire en C de procéder à une conversion explicite du pointeur obtenu par malloc en pointeur de caractère.
Cependant, c'est une très bonne habitude car le C++ lui l'exige.
J'aurais du aussi l'ajouter.

Je dirais plutôt que ce n'est pas un bonne habitude à prendre. En effet, le cast de malloc() est non seulement inutile en C, il est également déconseillé, car il empêche un possibilité de diagnostic par le compilateur en cas d'oubli d'inclusion de <stdlib.h> (voir la FAQ à ce sujet).

Du code C, cela se compile avec un compilateur C. Il est évidemment possible de lier le fichier objet ainsi généré à un projet écrit en C++. Mais la question du cast de malloc n'a pas de sens en C++, parce qu'il est conseillé d'utiliser les opérateurs new et delete pour l'allocation dynamique de mémoire (lire http://emmanuel-delahaye.developpez....tes.htm#malloc à ce sujet).

Thierry

[Garulfo]

Ce n'est pas du C ça...

Pourquoi donc ?
J'ai fait une erreur que je ne vois pas ?

[Garulfo]

Je dirais plutôt que ce n'est pas un bonne habitude à prendre. [...]
Thierry

Humm. pas sûr d'être complètement d'accord avec toi.
Mais je reconnais que tu marques des points.
Le problème est entre portabilité et risque potentiel...

[Garulfo]

En quoi ma solution alloue des espaces mémoires qui peuvent être disparates dans leurs localisations dans l'espace mémoire? J'ai un espace contigü de Nx50, non? Par ailleurs, je n'alloue pas ground chose sur la pile...

[Edit] Je pense que ma solution est adaptée dans la mesure où seule la première dimension du tableau varie, comme l'a mentionné le PO.

Thierry

Dans ton cas tu n'alloues pas des pointeurs de manières disparates.. c'est vrai. Car tu utilises un tableau de pointeurs. Effectivement dans ton cas tout est continue... désolé j'étais pas réveillé ce matin.

Par contre ton tableau de pointeurs s'alloue sur la pile d'appel.
Une déclaration statique int x[10] remplie la pile d'appel et non la mémoire.

C'est pourquoi

Code :

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

1
2
3
4
5
6
7
8
#include <stdio.h>
 
int main()
{
    char tab[10000000];
 
    return 0;
}

provoque possiblement un segmentation fault à l'exécution, alors que

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
#include <stdio.h>
#include <stdlib.h>
 
int main()
{
    char *tab;
    tab = malloc(10000000* sizeof(char));
 
    return 0;
}

ne le fait pas. Si ainsi on peut allouer trop de mémoire (la deuxième approche), on ne remplit pas la pile.

La pile est souvent limité à 8Mo. Ça se remplit vite.

Donc oui tu alloues sur la pile.