Manipulation d'une base de donnée très simple ?

Version imprimable

10/09/2006, 17h43
Tymk

Manipulation d'une base de donnée très simple ?

J'ai des difficultés à concevoir un code pour le problème suivant :

J'ai dans un fichier texte une suite de noms chacun en lien avec une propriété

Citation:

nom1=propriété1
nom2=propriété2
.....

Je voudrais créer une fonction qui charge ce fichier en mémoire pour qu'ensuite d'autres fonctions puissent trouver le nom connaissant la propriété et vice versa.
10/09/2006, 18h06
Alp

Hé bien?
Quelles sont tes difficultés? Quels sont les problèmes rencontrés?
10/09/2006, 18h10
Tymk

Effectivement il manquait le principal

Je ne sais pas qu'elle structure utilisé pour faire cela. Surtout comment mettre ma base en mémoire et ensuite l'utiliser en argumant de fonctions.

J'avais pensé a un tableau à 2 dimensions dont une fixé à 2 éléments (les colonnes) et l'autre variante (les lignes). En fait, c'est un avis sur la marche à suivre que je veux.
10/09/2006, 19h32
loufoque

std::map par exemple.

Tu peux créer un std::map, ou un struct, pour chaque entrée et un std::vector pour tes map.

C'est à dire:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 struct Peer { std::string sNom; std::string sProperty; }; std::vector< Peer > vTableau; OU std::vector< std::map< std::string, std::string > > vTableau;
Pour chercher dedans, t'as le choix entre les 2 aussi. La 1ère étant plus artisanale.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 for( std::vector< Peer >::iterator i = vTableau.begin(); i != vTableau.end(); i++ ) { if( i->sNom == searchedName || i->sProperty == searchedProperty ) { return i; } return 0; } OU std::map< std::string, std::string >::iterator i = vTableau.find( searchedTruc ); if( i != vTableau.end() ) { return i; } return NULL;
En espérant que ça t'aide.

Pour ce qui est de lire le fichier texte, d'écrire dedans etc, vois du côté d'o/ifstream

11/09/2006, 16h06
Tymk

La lecture du fichier ne posera pas de problème je pense.

Je vais me pencher sur le struct et le vector.

Merci

Le fichier que je lis est de la forme suivante

Citation:

Nom1=Adresse1
.....

Voici la structure que j'ai déclarée

Code:

1
2
3
4
5
struct contact
{
    std::string sNom;
    std::string sAddresse;
};

et le code que j'ai mis en place :

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
void chargement_fichier()
{
    ifstream fichier("contacts.txt");
    if(fichier != NULL)
    {
        vector<contact> vTableau;
 
        string line;
 
        while(getline(fichier, line))
        {
            contact le_contact; //déclaration de "le_contact" avec la strucutre "contact"
 
            int indice_char = 0;
            string temp = "";
            while(line[indice_char] != '=')
            {
                temp += line[indice_char];
                indice_char++;
            }
            le_contact.sNom = temp; //on affecte le Nom contenu dans temp à "le_contact"
 
            indice_char++; //on saute le égal avant de reprendre
            temp = "";
            while(indice_char < line.size())
            {
                temp += line[indice_char];
                indice_char++;
            }
            le_contact.sAddresse = temp; //on affecte l'Addresse contenu dans temp à "le_contact"
 
            vTableau.push_back(le_contact); //on ajoute le contact à la liste
 
            cout << vTableau[0].sAddresse.c_str() << endl;
            cout << vTableau[0].sNom << endl;
 
        }
    }else{
        cout << "impossible de charger la liste des contacts\n";
    }
}

A la fin de cette fonction j'ai problème :
1) je ne sais pas pourquoi "cout" me renvoie 2 fois chaque ligne
2) je ne sais pas comment utiliser les pointeurs pour pouvoir récupérer vTableau sans faire de return vTableau. C'est à dire faire une sorte de déclaration globale de vTableau

11/09/2006, 19h29
loufoque
Citation:
Envoyé par JulienDuSud

Tu peux créer un std::map, ou un struct, pour chaque entrée et un std::vector pour tes map.

C'est à dire:

Code:

1 2 3 4 5 6 7 8 9 10 11 12 struct Peer { std::string sNom; std::string sProperty; }; std::vector< Peer > vTableau; OU std::vector< std::map< std::string, std::string > > vTableau;
Oulah...
Tu sembles confondre std::map et std::pair.
12/09/2006, 11h51
JulienDuSud
Citation:

Envoyé par Tymk

A la fin de cette fonction j'ai problème :
2) je ne sais pas comment utiliser les pointeurs pour pouvoir récupérer vTableau sans faire de return vTableau. C'est à dire faire une sorte de déclaration globale de vTableau

En général on utilise les globaux de ce style en C :p
Tu pourrais faire une classe et faire de vTableau un membre de ta classe, ça serait plus "propre".
(Soit-il un singleton)

Sinon, pourquoi utiliser un pointeur ?
Code:

1 2 3 4 5 6 7 vector<contact>vTableau; void chargement_fichier() { // ... Tu utilises vTableau comme avant, sauf que là c'est un global que tu peux utiliser partout dans ton fichier. }
Tu peux, à la limite, aussi le mettre dans un *.h et inclure le fichier là où tu as besoin de ton vTableau.

Après relecture de ta question, je répond peut être à côté de la plaque.
Si c'est le cas, je vais répondre comme je l'ai compris now:
Code:

1 2 3 4 5 6 7 8 void chargement_fichier( vector<contact>&vTableau ) { // ... pareil qu'au dessus } vector<contact>vTableau; chargement_fichier( vTableau );
20/09/2006, 18h41
Tymk

En fait je ne sais pas pourquoi je ne déclare pas de variables globales !

C'est juste que, quand j'ai commencé le C++, on m'a dit d'éviter à tout prix de le faire.

Si tu pense que ça peut marcher, je veux bien tenté le coup mais est-ce que ça ne créera pas d'autres problèmes ?
20/09/2006, 19h11
Jean-Marc.Bourguet

Citation:

Envoyé par Tymk

En fait je ne sais pas pourquoi je ne déclare pas de variables globales !

C'est bien de faire ce qu'on conseille, mais il faut encore comprendre pourquoi, parce que sans ça, on se bloque quand c'est la bonne solution.

Un premier problème des variables globales, c'est qu'elles représentent un état qui influence tout le code qui y accède directement ou indirectement, et le rend difficile à spécifier, à valider, à tester. Ce n'est pas un problème à négliger mais quelque chose comme un fichier de configuration me semble une application valide.

Un deuxième problème des variables globales, c'est qu'on les modifie d'un peu partout. On peut mitiger ce problème en limitant l'accès. En C++, il y a trois solutions pour cela:

- faire une variable statique dans une fonction
- faire un membre statique de classe
- faire un variable dans un namespace non nommé (ou une variable statique
dans un fichier)

J'aime bien la troisième possibilité et c'est ce que j'emploierais dans ton cas.

Note, il y a un DP qui est parfois pertinent dans ce contexte: le singleton. En tant que DP, il est surtout utile quand il faut instantier un descendant d'une classe ou un autre. En C++, il est aussi utile pour régler un problème des variables globales: l'ordre d'intialisation n'est pas contrôlable sans faire quelque chose du genre. Mais rien ne t'empèche de fournir une interface fonctionnelle, quitte à utiliser un singleton pour l'implémentation.
20/09/2006, 20h49
Tymk

Citation:

Envoyé par Jean-Marc.Bourguet

- faire un variable dans un namespace non nommé (ou une variable statique
dans un fichier)

J'aime bien la troisième possibilité et c'est ce que j'emploierais dans ton cas.

J'ai déclaré mon vTableau en static dans mon *.h parce que je ne sais pas comment fonctionne cette variable dans un namespace non nommé.

Je ne sais pas si c'est satisfaisant mais ça fonctionne.
20/09/2006, 20h58
Jean-Marc.Bourguet
Citation:

Envoyé par Tymk

J'ai déclaré mon vTableau en static dans mon *.h parce que
Je ne sais pas si c'est satisfaisant mais ça fonctionne.

Bizarre, définir (et pas déclare) une variable static dans un .h ne me semble pas être une solution à ton problème. Tu te rends compte que tu définis ainsi une variable par unité de compilation où le .h est inclus?

Citation:

je ne sais pas comment fonctionne cette variable dans un namespace non nommé.
Code:

1 2 3 namespace { std::map<std::string, std::string> vTableau; }
L'effet est semblable à une variable statique (à part techniquement pour le linkage, mais bon, c'est généralement un détail sans importance et quand il en a une, c'est qu'il fallait utiliser un namespace non nommé), mais la technique est possible pour d'autres choses comme des classes (et là l'effet est qu'on peut mettre ces classes en paramètre template sans risquer de clash avec des classes semblablement nommées dans d'autres unités de compilation).
20/09/2006, 21h01
Tymk

Code:

static std::vector<contact> vTableau;

Je pensais pourtant que la fonction de "static" était d'éviter les déclarations multiples.
20/09/2006, 21h07
Jean-Marc.Bourguet

Citation:

Envoyé par Tymk

Code:

static std::vector<contact> vTableau;

Je pensais pourtant que la fonction de "static" était d'éviter les déclarations multiples.

La fonction de static (utilisé à portée de fichier, pas à portée de fonction ni de classe) est de rendre l'objet propre à l'unité de compilation et d'éviter les conflits avec des objets identiquement nommés dans d'autres unités de compilation. Autrement dit, de permettre les définitions multiples. (Il n'y a rien en C++ qui empèche les déclarations multiples).