probleme avec Assign

j`ai voulu compiler ce source mais m`apparu : syntax error : missing ')' before type 'char' et voila le code :

Code:

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
 #include<iostream.h>
#include<iomanip.h>
#include<string.h>
 
class Book 
{
public:
 
	  char title[256];
	  char author[64];
	  float price;
	  /*----(2)----*/
	  void show_title() ; 
 
 
      /*--(@)--*/
	  void show_book() ;  
 
 
 
 
	 /*-----(3)----*/     
private:
 
	char publisher[256];
	void show_publisher(char *name) ;
 
};
 
/*------(1)----*/
void Book::show_book ()
{
   show_title();show_publisher(char *name);
} 
 
/*------(2`)----*/
void Book::show_title()
{
	cout<<title<<endl;
}
/*--------(3`)----*/
 
void Book::show_publisher(char *name)
{
	strcpy(publisher,"nouvelle collection");
	cout<<publisher<<endl;
}
/*-----------------*/
 
 
void main()
{
 
Book primer;
 
strcpy(primer.title, "C/C++ primery i zadachi");
 
 
primer.show_book(); 
 
}

et a la fin doit aparaitre a l`ecran :
C/C++ primery i zadachi
nouvelle collection
press any key to continue

Citation:

Envoyé par vitia

j`ai voulu compiler ce source mais m`apparu : syntax error : missing ')' before type 'char'

Euh... es-tu sûr que c'est la seule erreur de syntaxe qui est apparue?

Moi j'aurais plutôt utilisé comme headers:
Code:

1 2 #include<iostream> #include<string.h>
J'aurais rajouté un

Code:

using namespace std;

Et je n'aurais mis aucun argument à la fonction show_publisher() puisqu'elle n'utilise pas celui qu'elle a actuellement. Du coup, l'erreur de syntaxe concernant le char, dans l'appel de la fonction, aurait disparu.

Et ça aurait en effet imprimé
C/C++ primery i zadachi
nouvelle collection

Mais j'aurais aussi utilisé des std::string plutôt que des char*! Et j'aurais rendu tous les champs privés ou tous publics, mais ça c'est peut-être plus subjectif.

Citation:
Envoyé par Biozic
Moi j'aurais plutôt utilisé comme headers:
Code:

1 2 #include<iostream> #include<string.h>
Moi j'aurais même utilisé:
Code:

1 2 #include<iostream> #include<cstring>
Et +1 pour std::string. Mais au moins, si tu fais des chaines C-style de taille fixe, utilise les fonctions C sécurisées, comme strncpy... http://www.cplusplus.com/reference/clibrary/cstring/
Sans compter qu'il n'y a que deux façons de passer une chaine de caractère c-style à une fonction:
- un char* + un size_t pour indiquer la taille du buffer
- un const char*
Jamais un char* seul.

Salut, et bienvenue sur le forum, vita...

Allons, messieurs, s'il vous plait...

Nous sommes sur le forum C++ et il se fait qu'il a été normalisé depuis longtemps et que la norme en vigueur est suffisemment vieille pour que la grosse majorité des compilateurs récents respectent cette norme, du moins, au niveau des conventions de noms de fichiers.

Si l'on pouvait donc vous demander d'au moins essayer de fournir directement les bonnes habitudes aux nouveaux, ce serait franchement simpa :D

Vita:

Il est fortement déconseillé d'utiliser les chaines de caractères "C style" (c'est à dire, des tableaux de caractères terminés par un '\0') en C++.

Il existe, en effet, une classe particulièrement adaptée à la gestion des chaines de caractères: la classe string, disponible dans l'espace de nommage std par inclusion du fichier <string> (remarque l'absence de ".h" ;):D)

Cette classe sécurise très fortement tout ce qui peut se rapporter à la gestion de chaine: ajout, suppression, modification, copie et s'adapte parfaitement à la gestion de flux (que ce soit les flux standard cin/cout, les flux "fichier" ifstream/ofstream ou meme les flux de conversion (i/o)stringstream) et t'évitera les problèmes liés au fait de vouloir mettre 11 caractères dans une chaine qui ne peut en contenir que... 10...

Elle permet en outre de disposer, en cas de besoin, d'une chaine de caractères "C style" via la méthode c_str() ;) (mais, en pratique, les cas dans lesquels il faille réellement passer par une chaine C style sont relativement limités ;))

La définition de ta classe deviendrait alors
Code:

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 /* à l'origine #include<iostream.h> #include<iomanip.h> heuu... quelle utilité ici ??? #include<string.h> */ #include <iostream> #include <string> class Book { public: /* l'origine char title[256]; et si un titre fait plus de 255 caractères ??? char author[64]; et si l'auteur fait plus de 64 caractère ??? */ /* Nota: Il y a de fortes chances pour que le titre et l'auteur * d'un livre donné reste immuable une fois que l'on a créé la * référence concernant ce livre... * * Il serait donc clairement utile de déclarer title et author comme * étant privés, de fournir un constructeur prenant deux chaines * en paramètres (une pour title et l'autre pour author), et de fournir * des fonctions constantes permettant, le cas échéant, de récupérer * le titre et le nom de l'auteur, en en interdisant la modification */ std::string title; std::string author; float price; /*----(2)----*/ void show_title() ; /*--(@)--*/ void show_book() ; /*-----(3)----*/ private: /* à l'origine char publisher[256]; toujours le meme problème void show_publisher(char *name) ; */ std::string publisher; void show_publsher(const std::string& name); };
D'un point de vue purement syntaxique...
Quand tu en arrive à écrire un code du genre de
Code:

1 2 3 4 void Book::show_book () { /*...*/ }
tu en est à la définition (implémentation) de la méthode (ici show_book) pour ce qui concerne ta classe (ici Book)...

La seule chose que tu puisse faire, c'est appeler éventuellement d'autres fonctions, or, quand on voit ton code
Code:

1 2 3 4 5 6 7 8 void Book::show_book () { /* j'ai mis la deuxième à la ligne, par simple habitude et pour la lisibilité*/ show_title();/* OK, tu appelle bien une fonction */ show_publisher(char *name);/* NOK: tu fournis un prototype pour une * fonction... */ }
Comme l'indique les commentaires, tu fournis un prototype (quelque chose qui pourrait s'approcher d'une tentative de déclaration) pour la fonction show_publisher...

Or, comme indiqué plus haut, tout ce que tu peux faire, c'est appeler une fonction, et, surement pas te contenter de fournir un prototype :P

Dés lors, il faudra disposer d'une variable du type correspondant au paramètre attendu par cette fonction (un char* si tu n'a pas modifié ta classe, *idéalement* une std::string si tu a eu la clairvoyance de modifier ta classe comme je l'ai indiqué :D)

Tu auras trois solutions:
Soit, tu dis que la fonction show_book doit, elle aussi, prendre ce paramètre, et il faut alors veiller à l'appeler en fournissant une chaine de caractères utilisable comme paramètre pour show_publisher,

Cela donnerait un code proche de
Code:

1 2 3 4 5 6 7 /* Attention, il faudra modifier dans la classe le prototype de * show_book en void show_book(const std::string& name) */ void Book::show_book(const std::string& name) { show_titre(); show_publisher(name); }
Soit tu demande la chaine à passer en parametre au sein de la fonction, ce qui donne le code
Code:

1 2 3 4 5 6 7 8 9 /* ici, pas besoin de modifier le prototype de show_book */ void Book::show_book() { show_titre(); std::string topass; std::cout<<"introduisez le nom de l'editeur :"; cin>>topass; show_publisher(topass); }
Soit, enfin, et c'est la meilleur solution, tu estimes que l'éditeur sera, lui aussi constant pour chaque livre, et tu le fournis directement dans le constructeur de ta classe, en ne fournissant que des méthodes constantes pour y accéder...

Cette dernière solution est la plus correcte, mais elle nécessite alors de revoir entièrement la définition de ta classe en quelque chose proche de
Code:

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 class Book { public: Book(const std::string&, const std::string&, const std::string&, float); ~Book();/*meme s'il ne fait rien, j'ai pris l'habitude de systématiquement * définir le destructeur :D */ void show_book() const; /* affiche toutes les informations */ void show_title() const; /* affiche uniquement le titre */ void show_author() const; /* affiche uniquement l'auteur */ void show_publisher() const; /* affiche uniquement l'éditeur */ void show_price() const; /*affiche uniquement le prix */ void modify_price(float);/* le prix peut évoluer au fil du temps... * il semble donc de bon ton de pouvoir le modifier :D */ /* on préférera souvent les méthodes * const std::string& GetTitle() const; qui renvoie le titre * (non modifiable) * const std::string& GetAuthor() const; qui renvoie l'auteur * (non modifiable) * const std::string& GetPublisher() const; qui renvoie l'éditeur * (non modifiable) *float GetPrice() const; qui renvoie le prix */ private: std::string title; std::string author; std::string publisher; float price; };
et l'on aurait alors les implémentations sous la forme de
Code:

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 /* penses à utiliser les listes d'initialisation dans le constructeur (comme fait * ici :D) */ Book::Book(const std::string& title, const std::string& author, std::string& publisher, float price):title(title),author(author),publisher(publisher), price(price { } /* comme indiqué, le destructeur ne fait rien... mais j'aime autant * l'implémenter quand meme :D */ Book::~Book() { } void Book::show_book() const { std::cout<<"Titre :"<<titre<<std::endl <<"Auteur :"<<auteur<<std::endl <<"Editeur : "<<publisher<<std::endl <<"Prix :"<<price<<std::endl; } void Book::show_title() const { std::cout<<"Titre :"<<title<<std::endl; } void Book::show_author() const { std::cout<<"Auteur :"<<author<<std::endl; } void Book::show_publisher() const { std::cout<<"Editeur:"<<publisher<<std::endl; } void Book::show_price() const { std::cout<<"Prix :"<<price<<std::endl; } void Book::modify_price(float price) { price=newprice; }
L'utilisation de cette classe se ferait sous la forme de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 int main() { Book monlivre("le titre du livre", "l'auteur du livre", "l'editeur du livre",29.95); std::cout<<"affichage des informations completes "<<std::endl; monlivre.show_book(); std::cout<<"affichage du titre "<<std::endl; monlivre.show_title(); std::cout<<"affichage de l'auteur"<<std::endl; monlivre.show_author(); std::cout<<"affichage de l'editeur"<<std::endl; monlivre.show_publisher(); std::cout<<"affichage du prix"<<std::endl; monlivre.show_price(); /* avec les méthodes "Get..." cela prendrait la forme de std::cout<<"Titre :"<<monlivre.GetTitle()<<std::endl <<"Auteur :"<<monlivre.GetAuthor()<<std::endl <<"Editeur : "<<monlivre.GetPublisher()<<std::endl <<"Prix :"<<monlivre.GetPrice()<<std::endl; */ return 0; }
Voilà... tu pourras te vanter de m'avoir une fois de plus poussé à écrire un roman... Mais je te rassure, cela arrive régulièrement :D

Citation:

Envoyé par koala01

Si l'on pouvait donc vous demander d'au moins essayer de fournir directement les bonnes habitudes aux nouveaux, ce serait franchement simpa :D

Holala, on passe nos journées à répeter "utilise std::string", moi je disais juste que tant qu'à utiliser la mauvaise solution, autant le faire correctement :triste:.

Ah oui, mais on l'a dit tellement moins bien que le chef! Respect! ;)

A vrai dire, j'ai pris l'habitude de regarder le nombre de messages de la personne qui pose la question, surtout quand il apparait que la question traite de quelque chose que l'on peut considérer comme "aussi basique" que le fait de préférer la std::string au tableaux de caractères.

Ici, vitia est visiblement la personne qui

débarque sur le forum
commence à peine à approcher le C++

(@Vitia==> Ce n'est absolument pas un grief, ce n'est qu'une constatation qu'il ne faut aucunement prendre mal: on est tous passés par la (même si certains on tendance à l'oublier) :D )

Dans de telles circonstances, et même si on a l'impression de jouer les perroquets, le mieux est toujours de répéter une fois de plus :D

Apres tout: faire et défaire, c'est toujours travailler :D