appliquer une fonction à une fonction

Version imprimable

Bonjour à vous tous. Je débute en poo C++ et j'ai un soucis.

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
#include <iostream>
 
using namespace std;
struct Point
{
    double x;
    double y;
};
class Point2D
{
private:
    Point p;
public:
    Point2D(Point j)
    {
        p.x=j.x;
        p.y=j.y;
    }
    void donner(double a, double b)
    {
        p.x=a;p.y=b;
    }
    Point2D montrer()
    {
        return p;
    }
    void afficher()
    {
        cout<<p.x<<" =========== "<<p.y<<endl;
    }
};
int main()
{
    Point Mastruct;
    Mastruct.x=25;
    Mastruct.y=50;
    Point2D monP(Mastruct);
    monP.afficher();  // aucun probème
    monP.donner(100,200);
    monP.afficher();  // aucun probème
    cout<<(monP.montrer()).afficher()<<endl; /*cette ligne ne marche pas. Pourtant
                                                                      (monP.montrer()) retourne bien un objet monP*/
    return 0;
}
J'espère que me suis bien exprimé.
Merci à vous

20/03/2015, 10h01
imperio

Erreur du compilateur ?

C'est presque ca.
L'erreur de compilateur ca doit être "can't find overload for operator<< with arguments type pourri de cout, void"

Montrer retourne un objet, certes, mais afficher() retourne void, donc n'est pas utilisable en argument de l'operator<< (avec cout).
ton main s'écrirait non pas cout<<(monP.montrer()).afficher()<<endl, mais:

Code:

monP.montrer().afficher();

Comme tu as voulu le faire, tu veux pouvoir choisir où afficher monP.montrer() et surtout dans quel flux.
Pour faire cela, on définit habituellement l'opérator<<.

Par ailleurs, il manque des qualifications constantes.
Les fonctions qui ne modifie pas un objet devrait être marquées comme const.

Enfin, prends l'habitude de ne pas mettre de using avant une déclaration de classe. (ca t'évitera de le mettre dans un en-tête si tu décides d'en créer)
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 #include <iostream> struct Point { double x; double y; }; //grace à cette fonction, je pourrais mettre un Point. inline std::ostream& operator << (std::ostream& stream, Point const& p) { return stream<<p.x<<" =========== "<<p.y; } class Point2D { private: Point p; public: //il faut toujours privilégier la liste d'initialisation au corps du constructeur. Avantage annexe, tu peux ainsi utiliser le même nom pour la variable et le champ. Point2D(Point const& p) : p(p) {} //j'ai pris la liberter de donner un nom explicite à la fonction void aller_en(double a, double b) {p.x=a; p.y=b;} //ta fonction originale ne fait pas ce que tu crois: elle appelle le constructeur Point2D(Point) pour créer un Point2D basé sur p. // Point2D montrer() {return p;} Point2D clone() const {return p;}//pour faire une copie, on utilise souvent le nom clone() Point const& montrer() {return p;} void afficher() {std::cout<<p<<std::endl;} }; using namespace std; int main() { Point Mastruct = {25, 50}; Point2D monP(Mastruct); monP.afficher(); // aucun probème monP.aller_en(100,200); monP.afficher(); // aucun probème cout<<monP.montrer()<<endl; return 0; }
Comme je l'ai indiqué, il faut toujours privilégier la liste d'initialisation au corps du constructeur.
En effet, certaines variables sont lourdes, très lourdes, tandis que certaines interdisent carrément l'affectation.
Par exemple, tu ne peux pas initialiser une variable constante ou une référence dans le corps du constructeur.

20/03/2015, 15h41
stracoma

Merci à vous.
Effectivement cout<<(monP.montrer()).afficher()<<endl; n'a pas de sens ( == afficher une méthode!).
avec

Code:

monP.montrer().afficher();

ça marche.
Une autre fois merci
20/03/2015, 15h50
ternel

Non, ca n'est même pas afficher une méthode.
Ca, ce serait plutot: cout << (monP.montrer().afficher) << endl (sans parenthèses d'appel après afficher). Mais ca ne compile pas non plus :aie:

Si ta fonction avait retourné quoique ce soit, ca aurait compilé.
20/03/2015, 16h26
koala01

Salut,

Citation:

Envoyé par leternel

Non, ca n'est même pas afficher une méthode.
Ca, ce serait plutot: cout << (monP.montrer().afficher) << endl (sans parenthèses d'appel après afficher). Mais ca ne compile pas non plus :aie:

Si ta fonction avait retourné quoique ce soit, ca aurait compilé.

Et encore...

Cela aurait compilé, oui (quoi que,pas si n'importe quoi que cela... est-ce que cela aurait par exemple compilé avec un std::ostream& comme type de retour ???), mais, à l'exécution, ca aurait surement provoqué un résultat assez... surprenant, pour rester politiquement correct ;)
20/03/2015, 16h35
ternel

On est d'accord :mrgreen: