Discussion :

[stracoma]

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

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
#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

[imperio]

Erreur du compilateur ?

[ternel]

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 :

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

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 :

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
#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.

[stracoma]

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

Code :

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

monP.montrer().afficher();

ça marche.
Une autre fois merci

[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

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

[koala01]

Salut,

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

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

[ternel]

On est d'accord