Salut a tous !
Alors voila je débute en C++ et je voulais faire un petit prog que je fais a chaque fois quand je commence l’apprentissage d’un langage a objet : une gestion d’eleves toute simple.
J’ai donc fait un Eleve.h comme ceci :
class Eleve
{
string strNom, strPrenom;
public :
Eleve(string,string);
string getNom();
string getPrenom();
};
puis un Eleve.c comme cela :
#include "Eleve.h"
using namespace std;
Eleve::Eleve (string leNom,string lePrenom)
{
strNom = leNom;
strPrenom = lePrenom;
}
string Eleve::getNom()
{
return strNom;
}
string Eleve::getPrenom()
{
return strPrenom;
}
Et lorsque j’essaye d’utiliser la classe, ca me met des erreurs pour les string, mais je ne sais pas ou mettre le #include <string> (si tant est que ce soit la solution).
Je pense que c’est un probleme facile pour vous, donc j’attend votre aide merci d’avance 
Vu qu’apparamment tu les veux privés :
#include <string>
#include <iostream>
using namespace std;
class Eleve
{
public :
Eleve(string,string);
string getNom();
string getPrenom();
private:
string strNom, strPrenom;
};
string Eleve::getNom()
{
return strNom;
}
string Eleve::getPrenom()
{
return strPrenom;
}
Eleve::Eleve(string leNom,string lePrenom):strNom(leNom),strPrenom(lePrenom)
{ }
int main(void)
{
Eleve cEleve("Karl","Kox");
cout << cEleve.getNom() << " " << cEleve.getPrenom() << endl;
}
salut merci pour cette réponse, mais si je veux découper en plusieurs fichiers source, comment ca se passe ?
Entête :
#pragma once
using namespace std;
class Eleve
{
public :
Eleve(string,string);
string getNom();
string getPrenom();
private:
string strNom, strPrenom;
};
Implémentation :
#include <string>
#include <iostream>
#include "Test2.hpp"
string Eleve::getNom()
{
return strNom;
}
string Eleve::getPrenom()
{
return strPrenom;
}
Eleve::Eleve(string leNom,string lePrenom):strNom(leNom),strPrenom(lePrenom)
{ }
int main(void)
{
Eleve cEleve("Karl","Kox");
cout << cEleve.getNom() << " " << cEleve.getPrenom() << endl;
return 0;
}
j’imagine donc que c’est le #pragma once qui change tout mais ca fait quoi exactement (ouais je suis chiant mais j’aime comprendre )
Il ne change rien, ça évite juste les collisions et de n’inclure l’entête qu’une seule fois.
bon je vais etre chiant une derniere fois et apres promis j’arrete
je voudrais avoir 3 fichiers : 1 pour l’entete, un autre pour la déclaration de la classe et un dernier pour le programme. Comment faire ?
Il faut que tu sépares le code de l’implémentation de ta classe Eleve de celui du main. Donc tu mets ta fonction main dans main.cpp (d’une originalité fulgurante 
) et tu inclus eleves.h au début.
Et le #pragma once c’est pas très standard même si très souvent implémenté dans les compilateurs. Autant protéger au cas où avec un #ifndef , #define , #endif
ok donc on peut avoir la définition d’une classe et la description de ses fonctions dans le meme fichier .h ?
Si tu entend description comme documentation, ie: que le prototype, oui.
Sinon c’est à éviter sauf si la fonction/méthode est inline, ou liée à un template.
mais je ne vois pas trop l’interet de définir puis de documenter, en java il n’y a pas de définitions alors ca sert a quoi en C++ ?
C’est obligatoire.
En java, le compilateur fait plusieurs passes : une première pour faire un arbre syntaxique, une seconde pour résoudre les noms, etc. (je suis pas spécialiste ceci étant).
En C++, c’est une seule passe pour tout cela. Moralité : s’il tombe sur une fonction f() utilisée, il va supposer qu’elle éxiste avec tel ou tel paramètre (bref: il est capable de déterminer le prototype). Mais il n’aura pas le code, et ne pourra rien en faire, voir te dira “non je refuse de compiler”.
D’où la définition de la fonction dans un fichier H.
Pour qu’il sache comment on l’appelle.
C’est une obligation, surtout qu’en C/C++ tu n’as pas les fichiers .class de Java, mais des fichiers objets (du code relogeable) qui ne permettent pas de faire de la rétrospection dessus/etc. (d’autant que le C++ est une illusion : derrière, c’est que du C.)
Tout n’est qu’illusion …
mais en Java, tu as les notions de classes d’interface qui reprend le même concept: la classe d’interface ne contient que les définition, et la ou les classes d’implémentations contiennent le code, mais on ne les connait pas forcément.
Dites moi si je me trompe, mais en Langage C et C++,au moment du “link” on peut se permettre de “choisir” le module correspondant à l’implémentation du .h (par exemple choisir du optimisé pour 64 bits ou pour MMX etc.) ce qui reprend en partie le même concept.
Donc il est logique de ne fournir que la définition contenue dans .h puisque ça permet de compiler un module .c indépendammment des autres.
De même qu’en Java, si on veut compiler une classe sans fournir au compilateur l’implémentation de ce qu’elle utilise on utilise uniquement des interfaces. Exemple concret: tu compile un prog qui utilise une interface jdbc, et tu ne fourni le driver jdbc correspondant à oracle ou mysql qu’au moment de l’exécution, il est normal que ton compilateur n’en aie pas besoin.
Donc pour moi c’est autant un problème technique que conceptuel.
edit HS : je sais c’est lourdingue 
, mais le problème de String dans la classe, pour un débutant, si ce n’était pas le forum de programmation, je me poserais des questions. :whistle:
Eh bien merci pour toutes vos explications, ca me servira beaucoup
A bientot :super: