Stocker des types différents dans un tableau

**Zouti** · 28/12/2012, 16h16

Salut a tous,

Voila je code un programme qui devrais permettre de stocker différent type de données dans un tableau dynamique.

Mais le problème, je commence à bloquer lorsque il s'agit de demande à l'utilisateur de saisir le type qu'il souhaite, et de saisir la valeur qu'il souhaite stocker.

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
/*énumération des différents types*/
enum
{
    TYPE_INT, TYPE_DOUBLE, TYPE_STRING
};
 
struct Var{
    union
    {
        /*valeur entière*/
        int i;
        /*valeur flottante*/
        double d;
        /*chaîne d'un maximum de 99 caractères + le caractère final*/
        char str[100];
    }val;
    /*le type en cours d'utilisation*/
    int type;
};
typedef struct Var Var_t;
 
struct Colonne{
    int nbcol, nbLigne;
    char nomcol[255];
};
typedef struct Colonne Col_t;
 
 
void TypeGenerique()
{
    Col_t *Col;
    int i;
    Col = (Col_t *) malloc(sizeof(Col_t));
 
    printf("Saisir nombre de colonne: ");
    scanf("%d", &Col->nbcol);
 
    for(i=0; i<Col->nbcol; i++)
    {
        printf("Saisir nom des colonne: ");
        scanf("%s", Col->nomcol);
    }
 
    printf("Saisir les valeur du tableau:\n");
 
    for(j=0; j<Col->nbLigne; j++)
    {
        printf("%s: ", Col->nomcol);
        scanf("%", );
    }
 
}

Je ne sais pas si pour les type je dois crée des fonctions spéciale des différente type ou bien s'il y a une autre méthode de faire plus aisément.

Au final je souhaiterai pourvoir afficher une chose similaire a cela par exemple:

+-------------|-------------|-------------|-------------+
|   nomCol    |   nomCol    |   nomCol    |   nomCol    |
+-------------|-------------|-------------|-------------+
|     Type    |    Type     |    Type     |    Type     |
+-------------|-------------|-------------|-------------+
|    Valeur   |    Valeur   |    Valeur   |    Valeur   |
|    Valeur   |    Valeur   |    Valeur   |    Valeur   |
|    Valeur   |    Valeur   |    Valeur   |    Valeur   |
|    Valeur   |    Valeur   |    Valeur   |    Valeur   |
|    Valeur   |    Valeur   |    Valeur   |    Valeur   |
|    Valeur   |    Valeur   |    Valeur   |    Valeur   |
|    Valeur   |    Valeur   |    Valeur   |    Valeur   |
+-------------|-------------|-------------|-------------+

Je cherche en vain a reproduire un programme qui pourrais me permettre de reproduire une chose similaire.

Merci encore de votre aide!!!!!

**Neckara** · 28/12/2012, 16h24

Bonjour,

As-tu essayé d'utiliser des pointeurs void avec un discriminant ?

Code :

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

1
2
3
4
5
6
7
8
9
10
typedef enum{BOOL, INT, FLOAT} Type;
 
typedef struct
{
          Type m_type;
          void * m_data;
          int m_nbElement;
}Colonne;
 
Colonne tableau[50];

Après réflexion, je pense qu'il te faudrait aussi un tableau pour les taille de tes types

Code :

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

1
2
3
4
5
6
7
8
9
int taille[] = { sizeof(char), sizeof(int), sizeof(float)};
 
void addValue(void * v, Tableau t, int numColonne)
{
            t[numColonne]->m_nbElement; //nombre d'éléments
            int m_taille = taille[t[numColonne]->m_type];
            // realloc de m_taille octet en plus.
            //memcpy
}

**Zouti** · 28/12/2012, 16h29

Envoyé par Neckara

Bonjour,

As-tu essayé d'utiliser des pointeurs void avec un discriminant ?

Code :

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

1
2
3
4
5
6
7
8
9
typedef enum{BOOL, INT, FLOAT} Type;
 
typedef struct
{
          Type m_type;
          void * m_data;
}Colonne;
 
Colonne tableau[50];

Merci de votre réponse rapide !!!

J'ai pas compris comment sa avec un discrimant explique toi ?

**Neckara** · 28/12/2012, 16h33

Le discriminant, c'est ce que tu as déjà utilisé ici :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
struct Var{
    union
    {
        /*valeur entière*/
        int i;
        /*valeur flottante*/
        double d;
        /*chaîne d'un maximum de 99 caractères + le caractère final*/
        char str[100];
    }val;
    /*le type en cours d'utilisation*/
    int type;
};

Il permet de connaître le type stocké.

**Zouti** · 28/12/2012, 16h53

Ah ok désoler je pensé que tu me parlé du discriminant de l'équation du second degré

Mais du coup je ne sais pas si avec cet structur je dois faire des fonction spéciale car je suis encore dans le flou total.

Je vois pas trop comment m'y prendre!!!

Car au niveau du scanf ou l'utilisateur demande de saisir la valeur l'idée serais qu'il puisse saisir n'importe quel type du coup c'est pour cela que j'ai pensé qu'il fallait peut être créer différent fonction pour les types différents ???

Mais du coup cet méthode devrais pouvoir demande a l'utilisateur de choisir quel type il veut saisir ???

**Neckara** · 28/12/2012, 17h33

Au lieu de faire un fscanf tu peux faire un fgets.

Ensuite, c'est à toi de voir comment tu différencies les différents types, selon quelles conditions/quels critères.

Après pour le stockage, la seule chose qui importe vraiment c'est la taille des objets stocké et une indication pour que l'utilisateur sache quel type est stocké.

Après, déterminer le type des objets à stocker ou récupérer le bon type d'après l'indication qu'on donne... c'est à l'utilisateur de ton tableau de se débrouiller.

**Zouti** · 28/12/2012, 19h16

J'ai essayer de tenté de faire avec plusieur fonction de type differente mais sa me semble pas correcte ton idée me parait mieux je ne parviens pas a la réalisé avec les structur aurait tu une idée de comment je pourrais m'y prendre pour la coder merci

Voila ce que j'avais commencé pour les fonction:

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 <stdio.h>
#include <stdlib.h>
#include <string.h>
 
 
static void purger(void)
{
    int c;
 
    while ((c = getchar()) != '\n' && c != EOF)
    {}
}
 
static void clean (char *chaine)
{
    char *p = strchr(chaine, '\n');
 
    if (p)
    {
        *p = 0;
    }
 
    else
    {
        purger();
    }
}
 
void ChoixInt()
{
    int i;
    printf("Int: ");
    scanf("%d", &i);
}
 
void ChoixChar()
{
    char chaine[255];
    printf("Char: \n");
    //scanf("%s", s);
    fgets(chaine, sizeof chaine, stdin);
    //clean(chaine);
}
 
void ChoixFloat()
{
    float f;
    printf("Float: ");
    scanf("%f", &f);
}
 
void ChoixType()
{
    int choix;
    printf("Saisir choix du type [1.int - 2.char - 3.float]: ");
    fflush(stdout);
    scanf("%d", &choix);
 
    switch(choix)
    {
        case 1:
        ChoixInt();
        break;
 
        case 2:
        ChoixChar();
        break;
 
        case 3:
        ChoixFloat();
        break;
 
        default:
            printf("Choix non reconnu!\n");
        break;
    }
 
}
 
 
int main (void)
{
    ChoixType();
 
    return 0;
}

**fred1599** · 28/12/2012, 21h28

Voici une solution que tu peux tester

test.c

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "test.h"
 
int main(void)
{
 
    int i;
    Values *(tab[3]);
 
    tab[0] = create_int(15);
    tab[1] = create_double(5.5);
    tab[2] = create_str("Bonjour");
 
    for (i=0; i<3; i++)
        afficher(tab[i]);
        free(tab[i]);
 
    return 0;
}
 
Values *create_int(int n)
{
    Values *v = malloc(sizeof(Values));
    v->number = n;
    return v;
}
 
Values *create_double(double n)
{
    Values *v = malloc(sizeof(Values));
    v->flottant = n;
    return v;
}
 
Values *create_str(const char *ch)
{
    Values *v = malloc(sizeof(Values));
    strcpy(v->str, ch);
    return v;
}
 
void afficher(Values *v)
{
    if(v->number)
        printf("%d\n", v->number);
    else if(v->flottant)
        printf("%f\n", v->flottant);
    else
        printf("%s\n", v->str);
}

test.h

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
#ifndef TEST_H_INCLUDED
#define TEST_H_INCLUDED
 
typedef struct
{
    char str[100];
    int number;
    double flottant;
} Values;
 
Values *create_int(int n);
Values *create_double(double n);
Values *create_str(const char *ch);
void afficher(Values *v);
 
#endif

Voilà complètement fonctionnel

Edit : Rajout des free dans le code

**Zouti** · 28/12/2012, 21h39

Salut merci de ton aide sincèrement, j'ai regarder est testé ton code mais cela ne répond pas a ce que je souhaite réalisé a savoir un programme de ce type:

Au final je souhaiterai pourvoir afficher une chose similaire a cela par exemple:

+-----------|-----------|-----------|-----------+
|   nomCol  |   nomCol  |   nomCol  |   nomCol  |
+-----------|-----------|-----------|-----------+
|   Type    |    Type   |    Type   |   Type    |
+-----------|-----------|-----------|-----------+
|  Valeur   |   Valeur  |   Valeur  |   Valeur  |
|  Valeur   |   Valeur  |   Valeur  |   Valeur  |
|  Valeur   |   Valeur  |   Valeur  |   Valeur  |
|  Valeur   |   Valeur  |   Valeur  |   Valeur  |
|  Valeur   |   Valeur  |   Valeur  |   Valeur  |
|  Valeur   |   Valeur  |   Valeur  |   Valeur  |
|  Valeur   |   Valeur  |   Valeur  |   Valeur  |
+-----------|-----------|-----------|-----------+

Merci encore de votre aide, mais la ou je bloque c'est de pouvoir gérer au niveau de la saisit que la personne puissent saisir n'importe quel type ainsi que sa valeur et que cela s'enregistre dans un tableau dynamique. C'est encore flou dans ma tête a vrais dire cet idée

J'avais déjà entamé un début de code mais c'est pas vraiment sa, car je ne vois pas comment je pourrais utilisé les structure que j'avais déjà déclaré auparavant

**fred1599** · 28/12/2012, 21h48

Donc comme ça a été déjà dis, tu récupères une chaîne et tu fais des tests dessus, du genre le transformer en entier, flottant, et si ça ne fonctionne pas, tu le gardes en chaîne de caractères.

Je vois pas autrement...

**diogene** · 29/12/2012, 11h15

Donc comme ça a été déjà dis, tu récupères une chaîne et tu fais des tests dessus, du genre le transformer en entier, flottant, et si ça ne fonctionne pas, tu le gardes en chaîne de caractères.

C'est quand même plus compliqué que ça : dans ce cas, tu ne pourrais pas entrer 123 comme chaine de caractères mais uniquement comme entier.

**Zouti** · 29/12/2012, 13h59

Et c'est bien la le probleme car je ne vois pas comment faire un teste sur une chaine de charactere alors que a l'interieur il y aurais des chiffre et des mots

**Zouti** · 03/01/2013, 19h29

Je viens de crée 2 fonction qui me permettront d'afficher des enregistrement mais lorsque je saisit les enregistrement je n'ai pas tous les enregistrement qui s'affiche je n'ai qu'une parti qui s'affiche.

C'est comme si en mémoire il prends pas en compte le reste ?

**plxpy** · 04/01/2013, 12h06

simple traduction du pouce rouge/en bas mis par un précédent membre

Crois-tu vraiment que les "renseignements" que tu as fournis au post précédent puissent nous être d'une quelconque utilité ? Un simple "Ca marche toujours pas" aurait fourni autant d'indices ...

Du coup, on ne peut que ... compatir.

**Zouti** · 04/01/2013, 12h56

Je suis désoler j'ai pas du faire gaffe hier quand j'ai posté lorsque j'ai éditer sa a pas pris en compte le code je pense.

Ps. la balise code ne semble pas fonctionné lorsque j’intègre mon 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
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
/***************************************************************/
void creation_Enregistrement()
/***************************************************************/
{
    printf("\n\n\n");
    char nomTable[TAILLE_NOM];
    table_t *nTable;
    int i , j;
 
    printf("Saisir le nom de la table a rechercher: ");
    scanf("%s", nomTable);
 
    nTable = recherche_Table(nomTable);
 
    if(nTable == NULL)
    {
        printf("La table [%s] non trouver!\n");
    }
 
    else
    {
        printf("La table [%s] existe!!\n\n", nTable->nomTable);
 
        printf("Nombre d' Enregistrement a saisir:");
        scanf("%d", &nTable->nbEnreg);/*************/
 
        //nTable->champs=(champ_t*) malloc(nTable->nbEnreg * sizeof(champ_t));/************/
 
        for(i=0; i<nTable->nbEnreg; i++)/*************/
        {
            for(j=0; j<nTable->nbChamp; j++)
            {
                printf("%s_%s: ", nTable->champs[j].nom, nTable->champs[j].TypeChmp);
                scanf("%s", nTable->champs[i].val_enreg);
            }
        }
        nTable->champs->suiv = NULL;
        nTable->champs->prec = NULL;
        insertion_Enregistrement(nTable);
    }
}
 
 
/***************************************************************/
void insertion_Enregistrement(table_t *nouvel_Enregistrement)
/***************************************************************/
{
    int code, i, j;
    table_t *pt_debut, *prem_element;
    //hamp_t *pt_debut, *prem_element;
 
    code = hachage(nouvel_Enregistrement->champs->nom);
    printf("\n\n");
 
    for(i=0;i<nouvel_Enregistrement->nbChamp;i++)
    {
        printf("%s_s  ", nouvel_Enregistrement->champs[i].nom, nouvel_Enregistrement->champs[i].TypeChmp);
    }
 
    printf("\n");
 
    for(i=0;i<nouvel_Enregistrement->nbChamp;i++)
    {
        printf("------------");
    }
 
    printf("\n");
 
        for(j=0; j<nouvel_Enregistrement->nbEnreg; j++)
        {
            printf("%s  ", nouvel_Enregistrement->champs[j].val_enreg);
        }
 
    pt_debut = table_hachage_Champ[ code];
    if(pt_debut == NULL)
    {
        table_hachage_Champ[ code] = nouvel_Enregistrement;
    }
 
    else
    {
        prem_element = table_hachage_Champ[ code];
        table_hachage_Champ[ code] = nouvel_Enregistrement;
        nouvel_Enregistrement->champs->suiv = prem_element;
        prem_element->champs->prec = nouvel_Enregistrement;
    }
}
//---------------------------------------------------------------

**fregolo52** · 04/01/2013, 13h42

Envoyé par Zouti

Ah thanks sa aide beaucoup mieux du coup, et du coup mon code bloque quelque part est ce qu'une personne saurait d’où sa vient

.

Merci encore

avec tous les printf, tu pourrais nous dire au moins ce qui s'affiche, ca peut aider pour savoir où ça bloque.

**Zouti** · 04/01/2013, 14h18

Lorsque j'arrive a la ligne ou l'on demande:

Etape1:
Saisir le nom de la table a rechercher: nomTable
La table [nomTable] existe!!!!

Etape2:
Nombre enregistrement a saisir: Nombre voulue
nomChamp_1: 1_enregistrement //ex: 1
nomChamp_2: 1_enregistrement //ex: julien
nomChamp_1: 2_enregistrement //ex: 2
nomChamp_2: 2_enregistrement //ex: Marc

Etape3:
L'affichage ce gere comme cela:

nomChamp nomChamp
-------------------------------
julien marc

Résultat voulue:

nomChamp nomChamp
-------------------------------
1 julien
2 marc
Le problème sa m'affiche pas 1 et 2 je pense que sa dois venir d'un malloc qui prend pas en compte en mémoire le reste de ce que je saisit ????

**Zouti** · 18/01/2013, 00h47

Alors aucune personne aurait une idée??

Stocker des types différents dans un tableau

C

Discussions similaires

Partager

Partager