Discussion :

[noctua]

salut,
j'ai créé une classe pour écrire et lire dans un fichier perso...
je compte utiliser une autre classe pour traiter les données qui héritera de celle-ci

j'aimerais votre avis pour savoir si je mis prend bien niveau algorithme

Fichier_tcce.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
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
#ifndef FICHIER_TCCE_H_INCLUDED
#define FICHIER_TCCE_H_INCLUDED
 
#define INFO_MAQUETTE 8
#define PROG "p"
#define AUTO "a"
#define ENTREE "e"
#define SORTIE "s"
 
#include "Qt/qstring.h"
#include "Qt/qvariant.h"
#include "Qt/qlist.h"
 
 
/* Cette classe permet de lire et écrire dans un fichier *.tcce
Voir dans Doc algo, contenu fichier tcce
*/
 
class Fichier_tcce
	{
	protected:
 
	QString m_chemin_fichier;
	QList<QString> m_lignes_fichier_general;
	QList<QList<QString> > m_lignes_fichier_tests;
 
	public:
 
	Fichier_tcce(QString chemin_fichier);
	Fichier_tcce(QString chemin_fichier, QList<QString> lignes_fichier_general, QList<QList<QString> > lignes_fichier_tests);
 
	void creer_ecrire(bool &succes);
	void lire(bool &succes);
	void effacer(bool &succes);
 
	void changer_chemin(QString &chemin_fichier);
 
 
	};
 
 
#endif

Fichier_tcce.cpp

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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
#include "Fichier_tcce.h"
#include "Qt/qstring.h"
#include "Qt/qfile.h"
#include "Qt/qdatastream.h"
#include "Qt/qvariant.h"
#include "Qt/qlist.h"
 
 
 
Fichier_tcce::Fichier_tcce(QString chemin_fichier):m_chemin_fichier(chemin_fichier)
{
 
}
 
 
Fichier_tcce::Fichier_tcce(QString chemin_fichier, QList<QString> lignes_fichier_general, QList<QList<QString> > lignes_fichier_tests)
:m_chemin_fichier(chemin_fichier), m_lignes_fichier_general(lignes_fichier_general), m_lignes_fichier_tests(lignes_fichier_tests)
{
 
}
 
 
void Fichier_tcce::creer_ecrire(bool &succes)
{
QFile fichier(m_chemin_fichier);
QString nb_test=m_lignes_fichier_general.at(6);
int nb_test_dec=nb_test.toInt(&succes);
succes=fichier.open(QIODevice::WriteOnly);
 
if (succes && m_lignes_fichier_general.size()== INFO_MAQUETTE && m_lignes_fichier_tests.size()==nb_test_dec)
    {
	QDataStream out(&fichier);
 
	for(int position=0; position<INFO_MAQUETTE; position++)
		{
		out<<m_lignes_fichier_general.at(position);
		}
    QList<QString> lignes_test;
 
    for(int position=0; position<nb_test_dec; position++)
        {
        lignes_test=m_lignes_fichier_tests.at(position);
 
 
        for(int position=0; position<lignes_test.size(); position++)
            {
            out<<lignes_test.at(position);
            }
        }
	fichier.close();
	}
else
	{
	succes=false;
	}
}
 
 
void Fichier_tcce::lire(bool &succes)
{
QFile fichier(m_chemin_fichier);
succes=fichier.open(QIODevice::ReadOnly);
 
if (succes)
	{
	QDataStream in(&fichier);
	m_lignes_fichier_general.clear();
	m_lignes_fichier_tests.clear();
    QString ligne_fichier;
 
	for(int position=0; position<INFO_MAQUETTE; position++)
		{
		in>>ligne_fichier;
		m_lignes_fichier_general.append(ligne_fichier);
		}
    ligne_fichier=m_lignes_fichier_general.at(6);
    int nb_test_dec=ligne_fichier.toInt(&succes);
 
    if(succes)
        {
        QList<QString> lignes_test;
 
        for(int position=0; position<nb_test_dec; position++)
            {
            in>>ligne_fichier;
            lignes_test.append(ligne_fichier);
            in>>ligne_fichier;
            lignes_test.append(ligne_fichier);
            in>>ligne_fichier;
            lignes_test.append(ligne_fichier);
 
            if(ligne_fichier==AUTO)
                {
                }
            else if(ligne_fichier==PROG || ligne_fichier==ENTREE)
                {
                for(int position=3; position<6; position++)
                    {
                    in>>ligne_fichier;
                    lignes_test.append(ligne_fichier);
                    }
                }
            else if(ligne_fichier==SORTIE)
                {
                for(int position=3; position<5; position++)
                    {
                    in>>ligne_fichier;
                    lignes_test.append(ligne_fichier);
                    }
                }
            m_lignes_fichier_tests.append(lignes_test);
            }
        }
	fichier.close();
	}
}
 
 
void Fichier_tcce::effacer(bool &succes)
{
QFile fichier(m_chemin_fichier);
succes=fichier.remove();
 
}
 
 
void Fichier_tcce::changer_chemin(QString &chemin_fichier)
{
m_chemin_fichier=chemin_fichier;
}

[oodini]

Tu aurais sans doute plus de réponses en te débarrassant de Qt, et en utilisant le C++ standard.

[Astraya]

Bonjour,

De toute façon on ne peut juger un algorithme que en connaissant le problème parfaitement. Ce n'est le cas de personne
Si tu le trouve bien et qu'il fonctionne c'est déjà ça, ensuite une seconde et troisième passe d'optimisation etc... Mais pas juger trop vite la qualité du code avant de savoir ce qu'il donne vraiment sur les tests

[gbdivers]

Bonjour

Idem Astraya : on ne peut juger de l'algorithme juste avec le code.

Pour ce qui est de la syntaxe :

Code :

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

1
2
3
4
5
#define INFO_MAQUETTE 8
#define PROG "p"
#define AUTO "a"
#define ENTREE "e"
#define SORTIE "s"

Utilise plutôt des constantes (vérification des types) que des macros (le compilateur optimise ça sans problème) :

Code :

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

1
2
3
const unsigned int INFO_MAQUETTE = 8;
const char *const PROG = "p";
//etc.

Code :

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

1
2
3
#include "Qt/qstring.h"
#include "Qt/qvariant.h"
#include "Qt/qlist.h"

Utilise l'écriture suivante :

Code :

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

1
2
3
#include <QString>
#include <QVariant>
#include <QList>

Code :

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

QList<QString>

Il existe une classe QStringList.

Code :

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

QList<QList<QString> >

Les conteneurs de conteneurs, c'est en général bof bof. Le problème sera réglé en utilisant QList<QStringList> mais si ça n'avait pas été le cas, il aurait fallut encapsuler un niveau dans une classe.

Code :

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

1
2
3
void creer_ecrire(bool &succes);
void lire(bool &succes);
void effacer(bool &succes);

Pourquoi utiliser une référence non constante pour un retour d'erreur ? Utilise une variable de retour :

Code :

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

1
2
3
bool creer_ecrire();
bool lire();
bool effacer();

En général, je préfère les nom en anglais, pour l'homogénéité (les fonctions étant en anglais dans le C++ et Qt : QFile::read, QFile::write, etc.) Mais c'est qu'une question de goût.

Code :

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

1
2
3
4
5
Fichier_tcce::Fichier_tcce(QString chemin_fichier, QList<QString> lignes_fichier_general, QList<QList<QString> > lignes_fichier_tests)
:m_chemin_fichier(chemin_fichier), m_lignes_fichier_general(lignes_fichier_general), m_lignes_fichier_tests(lignes_fichier_tests)
{
 
}

Des retours à la ligne pour la lisibilité ?

Code :

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

int nb_test_dec=nb_test.toInt(&succes);

Où définies tu la variable succes ? (et des espaces avant et après le =, c'est plus lisible)

Tu aurais sans doute plus de réponses en te débarrassant de Qt, et en utilisant le C++ standard.

Pas sur que ça soit utile ce genre de remarque

[3DArchi]

Pas sur que ça soit utile ce genre de remarque

Ca risque de recréer un débat mais j'aurais tendance à préférer aussi à préconiser la STL. On est typiquement dans un cas de 'contamination' d'un framework sur un élément logiciel qui n'en n'a peut être pas besoin. Et qui gagnerait en réutilisabilité s'il n'a pas de lien de dépendance avec Qt.

Sinon, pour tout le reste, je partage ton avis. Je rajoute juste :

est nécessaire d'inclure QVariant ?
pourquoi ne pas passer les paramètres des constructeurs par référence constante ?
il me semble que les fonctions peuvent être constantes.