Discussion :

[Tymk]

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é

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.

[Alp]

Hé bien?
Quelles sont tes difficultés? Quels sont les problèmes rencontrés?

[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.

[loufoque]

std::map par exemple.

[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 :

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

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 :

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
 
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

[Tymk]

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

Je vais me pencher sur le struct et le vector.

Merci

[Tymk]

Le fichier que je lis est de la forme suivante

Nom1=Adresse1
.....

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

Code :

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

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

et le code que j'ai mis en place :

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
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

[loufoque]

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 :

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

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.

[JulienDuSud]

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 :

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

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 :

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

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

[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 ?

[Jean-Marc.Bourguet]

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.

[Tymk]

- 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.

[Jean-Marc.Bourguet]

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?

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

Code :

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

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).

[Tymk]

Code :

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

static std::vector<contact> vTableau;

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

[Jean-Marc.Bourguet]

Code :

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

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).