Discussion :

[deubelte]

Bonjour
je voudrais récupérer dans un fichier .txt des données qui sont de ce format:

12/12/2008 3443.34
12/11/2008 3485.43
12/10/2008 2323.54

C'est a dire une date, puis un nombre.
Je voudrais donc créer une boucle qui met dans un tableau la date, puis
dans un autre tableau le nombre, et ceci à chaque ligne.
J'ai essayé:

Code :

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

1
2
3
4
5
6
7
8
 
       std::ofstream oufile("text.txt");
       double *tab=new double[MaxPoint+1];
	for(long i=0;i<MaxPoint;i++)
	   {
 	 	infile1>>tab[i]; 
	   }
 return 0;

mais ca ne récupère que le premier nombre
j'ai aussi essayé avec: char *tab=new tab[MaxPoint+1]
mais ca récupère que la date.

Alors comment modifier mon code,
je pense que le mieux, c'est de récupérer la ligne sous forme de char, puis scanner le char pour récupérer d'abord la date, puis le nombre.
(C'est bourrain, mais bon)
merci

[Garulfo]

As-tu pensé au fait que 12/12/2008 n'est pas un nombre et donc, a fortiori, pas un double ?

Ainsi quand tu lis, tu vas avoir un problème.

[koala01]

Salut,

Déjà, l'idéal serait quand même d'utiliser les conteneurs standards pour maintenir tes données en mémoire...

La gestion dynamique de la mémoire doit en effet être limitée à... quand elle est indispensable, et ce n'est pas le cas ici

Ensuite, il faut bien te dire que, si tu as deux données qui sont groupées (comme ici une date et... le réel que tu cherche à récupérer), il faut effectuer... deux lectures par donnée à récupérer, et tu n'en fais qu'une dans le code que tu présente.

Au final, le code pourrait donc prendre une forme proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
std::vector<double> tab;          // le tableau de doubles
std::ifstream ifs("fichier.txt"); // le fichier à lire
std::string temp;                 // la première information à lire, que l'on
                                  // décide "simplement" d'ignorer
while(ifs>>temp) // tant que l'on arrive à lire quelque chose
{
    double d;         // on va récupérer un double
    ifs>>d;           // dans le fichier
    tab.push_back(d); // que l'on insere dans le tableau
}

Evidemment, il s'agit ici d'une implémentation "naïve", qui considère que le fichier existera d'office et qu'il sera d'office correct...

Il serait sans doute utile de s'assurer que le fichier existe bien avant d'effectuer la lecture, et il pourrait être pas mal de s'assurer au minimum que les différentes lectures soient cohérentes avec ce que l'on attend du fichier

[deubelte]

La gestion dynamique de la mémoire doit en effet être limitée à... quand elle est indispensable, et ce n'est pas le cas ici

La gestion dyminamique, c'est bien les codes du style:

double *tableau=new double[10000];

c'est ce que je fais tout le temps. je n'utilise jamais la STL avec les vector et set.
C'est une erreur d'apres ce que je lis?

Qu'apporte l'utilisation de la STL? plus de rapidité?

[Goten]

Plus de rapidité mais surtout plus de sécurité et plus de flexibilité. Tu n'as plus à gérer toi même l'allocation de la mémoire (sauf si tu stocks des pointeurs bien sur). Donc plus de risque de fuite mémoire et autres joyeuseté. De plus les conteneurs standards sont multiple et chacun sont spécialisé afin d'être optimisé pour une certaine utilisation.
Donc oui il faut utilisé les conteneurs de la STL sauf en cas de nécessité absolu comme la expliqué koala01.

Je te laisse regarder la FAQ il y'a tout plein d'exemple qui montre l'intérêt de ces conteneurs.

[koala01]

Effectivement, la gestion dynamique de la mémoire, c'est tout ce qui touche de près ou de loin à new, new[], delete ou delete[].

Comme je l'ai dit, il y a des cas dans lesquels il est indispensable de jouer avec ses oiseaux de mauvaise augure.

L'exemple classique (bien qu'il soit possible d'en trouver d'autres) d'un cas où nous somme obligés d'y recourir, c'est s'il est question de gérer une collection d'objets polymorphes, et donc, nous utiliserions le conteneur de la STL adapté à notre situation, et il maintiendrait en mémoire des... pointeurs sur le type d'objet de base, pour lesquels l'allocation dynamique appellerait l'opérateur new sur... le type réel de l'objet.

Par exemple:

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
class Base
{
    /*...*/
};
class Derivee1 : public Base
{
    /*...*/
};
class Derive2 : public Base
{
    /*...*/
};
class Conteneur
{
    public:
        /* ... */
        void addD1(/*...*/)
        {
            collection.push_back(new Derivee1);
        }
        void addD2(/*...*/) 
        {
            collection.push_back(new Derivee2);
        }
    private:
        std::vector<Base*> collection;
    }
};

Tu te rend tout de suite compte que tu n'a pas d'autre solution pour faire cohabiter des objets de type "Derivee1" avec des objets de type "Derivee2", mais, à coté de cela, tu remarque que, si tu te contente du destructeur par défaut pour l'objet de type Conteneur, tu va courir dans le mur, à cause d'une magistrale fuite mémoire

Par contre, lorsqu'il s'agit de "simplement" manipuler une collection d'objet, le fait de ne plus avoir à t'inquiéter de la gestion de la mémoire au niveau du conteneur est réellement de nature à:

• t'éviter de recopier un code souvent identique à la base (hé... les informaticiens sont paresseux de nature )
• t'éviter les fuite mémoires dues à des "oubli" dans la gestion de la mémoire allouée dynamiquement (et dieu sait que cela arrive très (trop) facilement)
• te fournir des comportements type, adaptés et sécurisants pour la gestion de la collection d'objet
• te fournir des comportements souvent sensiblement optimisés par rapport à ce que tu ferais toi même

Au final, tu arrive donc à créer plus rapidement des applications plus sécurisantes pour lesquelles tu aura pu te concentrer sur les problèmes réels, sans subir d'interférences à des problèmes du genre de "comment dois-je gérer la mémoire dans tel cas "