Discussion :

[SebastianPx]

Bonsoir,

Voici-mon problème. Le but de mon exercice est de découper une phrase rentrée en ligne de commande (découpage à chaque espace).
Ce découpage se fait dans main.cpp
J'aimerai ensuite qu'une méthode dans Analyse.cpp prenne en paramètre ce tableau dynamique, et y effectue différents tests. C'est la que j'ai un problème.

Mon main.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
 
#include <sstream>
#include <string>
#include <iostream>
#include <vector>
#include "analyse.h"
 
using namespace std;
 
int main()
{
string entree = "";
string::size_type pos = 0;
int start;
vector<string> tableau; // tableau permettant de recuperer chaque mot
 
cout << "Bonjour, quelle operation voulez vous effectuer ?" << endl;
std::getline(std::cin, entree); // Récupération de la ligne complete ( pas de coupure aux espaces )
cout << "Analyse de la chaine ..." << entree << endl;
 
while (pos != string::npos) {
	start = pos;
	pos = entree.find(" ", start + 1);
	if (start == 0) // Quand c'est le premier mot, pas de suppresion d'espace avant
		tableau.push_back(entree.substr(start, pos - start ));
	else 
		tableau.push_back(entree.substr(start + 1, pos - start));
	cout << tableau.back() << endl; // Affichage de chaque mot recupéré
	}
 
Analyse analiseur;
analiseur.Analyser(tableau);
 
system ("pause > null");
}

Mon Analyse.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
#include "Analyse.h"
#include <iostream>
#include <vector>
#include <string>
 
 
 
 
using namespace std;
 
Analyse::Analyse(void)
{
}
 
 
void Analyse::Analyser(vector<string> tableau) const
{
	cout << "Debut de l'analyse ..." << endl;
}
 
 
Analyse::~Analyse(void)
{
	//ne rien faire
}

Mon Analyse.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
#ifndef _ANALYSE_
#define _ANALYSE
 
#include <vector>
#include <string>
 
 
class Analyse
{
private:
 
 
public:
	//constructeur
	Analyse(void);
 
	//destructeur 
	~Analyse(void);
 
	void Analyser(vector<string> tableau) const;
};
 
#endif

Comme vous pouvez le constater, actuellement mon analyse ne fait rien. Pourtant, sur Visual Studio (c'est pas de ma faute, c'est imposé pour un projet ) j'ai différents messages d'erreurs :

------ Début de la génération*: Projet*: Projet, Configuration*: Debug Win32 ------
Compilation en cours...
Analyse.cpp
y:\documents\projgeo\analyse.h(20) : error C2061: erreur de syntaxe*: identificateur 'vector'
y:\documents\projgeo\analyse.cpp(17) : error C2511: 'void Analyse::Analyser(std::vector<_Ty>) const'*: impossible de trouver la fonction membre surchargée dans 'Analyse'
with
[
_Ty=std::string
]
y:\documents\projgeo\analyse.h(9)*: voir la déclaration de 'Analyse'
main.cpp
y:\documents\projgeo\analyse.h(20) : error C2061: erreur de syntaxe*: identificateur 'vector'
y:\documents\projgeo\main.cpp(31) : error C2660: 'Analyse::Analyser'*: la fonction ne prend pas 1 arguments

Si quelqu'un a une idée, je suis preneur.

Merci d'avance !

Sebastian

[Arzar]

Dans analyse.h :

Code :

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

void Analyser(std::vector<std::string> tableau) const;

[koala01]

Salut, et bienvenue sur le forum.

Pour commencer, je vais me permettre quelques remarques d'ordre général:

• Lorsque tu ne souhaite pas déclarer d'argument à fournir à une fonction, tu peux simplement laisser les parenthèses vide, sans indiquer le type void
• Lorsque tu désire passer un classe en argument (comme c'est le cas pour la méthode Analyse::Analyser), il est souvent préférable de la passer sous la forme d'une référence, éventuellement constante (si la méthode en question n'est pas susceptible de la modifier)
• plutôt que de "t'amuser" à jouer avec la méthode substr, il serait peut être intéressant d'utiliser un flux de conversion
• L'inclusion du fichier d'en-tête <vector> dans main.cpp n'est pas indispensable, étant donné qu'il est déjà inclus dans "Analyse.h" et que ce dernier est inclus dans main.cpp (je fameux jeu de "l'inclusion indirecte" )
• il faut faire attention au fait que system("PAUSE") n'est pas portable... Reporte toi à cette entrée de la FAQ pour savoir comment contourner ce problème

Pour ce qui est des erreurs de compilation que tu nous montre, tu peux te dire que la première erreur indiquée est la première qui doit être gérée, car certaines en découlent sans doute.

La première erreur qui apparait est:

\documents\projgeo\analyse.h(20) : error C2061: erreur de syntaxe*: identificateur 'vector'

Et c'est normal...

La classe vector (et la classe string itou, d'ailleurs) est définie... dans l'espace de noms std.

Comme il n'y a pas de directive using namespace std; avant la déclaration de la méthode Analyser, et qu'il en par ailleurs largement déconseillé de l'utiliser dans un fichier d'en-tête, tu te trouve face à l'obligation... d'écrire la portée complète des classes définies dans l'espace de noms std

Cela signifie que, pour que le compilateur ne se plaigne plus, la déclaration de la méthode Analyser devrait devenir, en prenant en compte la quatrième remarque ci-dessus:

Code :

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

void Analyser(std::vector<std::string> const & tableau) const

Pour prendre en compte la troisième remarque ci-dessus, je te conseillerais en outre de remplacer la partie du code

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
cout << "Bonjour, quelle operation voulez vous effectuer ?" << endl;
std::getline(std::cin, entree); // Récupération de la ligne complete ( pas de coupure aux espaces )
cout << "Analyse de la chaine ..." << entree << endl;
 
while (pos != string::npos) {
	start = pos;
	pos = entree.find(" ", start + 1);
	if (start == 0) // Quand c'est le premier mot, pas de suppresion d'espace avant
		tableau.push_back(entree.substr(start, pos - start ));
	else 
		tableau.push_back(entree.substr(start + 1, pos - start));
	cout << tableau.back() << endl; // Affichage de chaque mot recupéré
	}

par

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
cout << "Bonjour, quelle operation voulez vous effectuer ?" << endl;
std::getline(std::cin, entree); // Récupération de la ligne complete 
                                // ( pas de coupure aux espaces )
cout << "Analyse de la chaine ..." << entree << endl;
 /* création d'un flux pour séparer chaque mot */
std::stringstream ss;
/* remplissons le flux avec la chaine récupérée */
ss<<entree;
/* déclarons une chaine temporaire pour récupérer les mots
 * (nous aurions pu utiliser entree... mais autant la garder 
 * intacte :D)
 */
std::string temp;
/* tant que nous récupérons une chaine de caractères au départ du flux 
 */
while (ss>>temp) {
    /* nous l'insérons dans notre tableau */
    tableau.push_back(temp);
    /*(et si cela peut te rassurer, nous l'affichons
     */
    std::cout<<tableau.back()<<std::endl;
}

Tu avouera que le code est largement plus simple, malgré tous les commentaires rajoutés

[befalimpertinent]

L'inclusion du fichier d'en-tête <vector> dans main.cpp n'est pas indispensable, étant donné qu'il est déjà inclus dans "Analyse.h" et que ce dernier est inclus dans main.cpp (je fameux jeu de "l'inclusion indirecte"

Cette phrase est discutable. Amha, Un fichier .cpp ne devrait pas dépendre de l'ordre d'inclusion des headers dont il a besoin mais au contraire les inclure tous (les #define en en-tête de fichier se chargeant de résoudre les redondances).
Cela permet de résoudre automatiquement certaines erreurs de compilation parfois ardues lorsque telle ou telle classe n'est pas encore définie par exemple.
Donc personnellement je laisserais le #include <vector> dans le main.cpp.

Entièrement d'accord avec le reste de la réponse en revanche.

[koala01]

Cette phrase est discutable. Amha, Un fichier .cpp ne devrait pas dépendre de l'ordre d'inclusion des headers dont il a besoin mais au contraire les inclure tous (les #define en en-tête de fichier se chargeant de résoudre les redondances).

Attention, le fait de dépendre de l'ordre d'inclusion est - pour ma part - plus proche du problème qu'un fichier doit être inclus avant un autre sous peine de voir des erreurs survenir.

Le conseil généralement donné étant de commencer par inclure les fichiers "personnels" puis de rajouter les fichiers externes qui sont nécessaires en plus

Cela permet de résoudre automatiquement certaines erreurs de compilation parfois ardues lorsque telle ou telle classe n'est pas encore définie par exemple.

Mais, comme tu as de toutes manières besoin de la définition de la classe Analyse (dans cet exemple), afin de connaitre les méthodes qui existent... tu es - pour ainsi dire - obligé de l'avoir définie avant de t'intéresser à la fonction main

Donc personnellement je laisserais le #include <vector> dans le main.cpp.

A vrai dire, il ne faudrait pour ainsi dire même pas devoir recourir au std::vector dans la fonction principale...

Si la responsabilité de la classe Analyse est d'analyser... une collection de chaines de caractères, il semblerait presque normal que la classe... dispose directement de cette collection et qu'elle soit en mesure de la gérer

Cela impliquerait de rajouter un membre du type adéquat à la classe, ainsi que les méthodes "qui vont bien" (ajouter, supprimer, vider, taille, ...) et de modifier un peu la logique, mais cela permettrait de respecter la responsabilité de la classe, et d'éviter d'avoir à inclure <vector>

La classe Analyse pourrait - avantageusement - être modifiée en:

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
#ifndef ANALYSE_HPP
#define ANALYSE_HPP
#include <string>
#include <vector>
class Analyse
{
    public:
        Analyse();
        void Analyser() const;
        void Ajouter(std::string const &);
        size_t NbMots() const;
        void Supprimer(size_t);
        void Vider();
    private:
        std::vector<std::string> tableau;
}:
#endif // ANALYSE_HPP

Avec des implémentations proches de

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
#include "analyse.hpp"
/* ici, nous aurons besoin de la classe stringstream :P */
#include <sstream>
Analyse::Analyse()
{
}
void Analyse::Ajouter(std::string const & chaine)
{
    /* assurons nous que cela fonctionne s'il y a plusieurs mots
     * dans la chaine
     */
    std::stringstream ss;
    ss<<chaine;
    std::string temp;
    while(ss>>temp)
        tableau.push_back(temp);
}
size_t Analyse::NbMots() const
{
    return tableau.size();
}
void Analyse::Supprimer(size_t index)
{
    if(index< tableau.size())
        tableau.erase(tableau.begin()+index);
}
void Analyse::Vider()
{
    tableau.clear();
}

et une utilisation sous la forme de

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
#include "analyse.hpp"
/* pour disposer de cin, getline, ... */
#include <iostream>
/* l'inclusion suivante n'est pas nécessaire */
#include <string>
int main()
{
    std::string entree; // pour récupérer l'introduction clavier
    Analyse an; // une instance de la classe Analyse
    std::cout << "Bonjour, quelle operation voulez vous effectuer ?" 
              << endl;
    std::getline(std::cin, entree);
    an.Ajouter(entree);
    std::cout<<"Analyse des données"<<std::endl;
    an.Analyser();
    std::cout<<"Fin de l'analyse des données" <<std::endl;
    return 0;
}

[SebastianPx]

Merci beaucoup pour votre aide !
Je vais lire tout ça en détail. Merci encore