Bonjour à tout(e)s les zéros !
Après avoir lu le tuto de Mateo sur la surcharge des operateurs, il me reste un problème :
j'aimerai surcharger l'operateur << pour afficher directement mes classes. J'ai vu qu'on a besoin d'utiliser une fonction "surchargant" cout car on a pas accès directement à cette classe :

ostream &operator<<( ostream &out, Maclasse* classe){
    classe->afficher(out);
    return out;
}

Seulement lorsque je veux "utiliser" cette fonction dans un fichier inclu / parent, je ne peux pas la redefinir alors qu'elle n'est pas active...
Je n'ai pas bien compris son fonctionnement (Mateo n'explique pas grand chose dessus...)
Quelque pourrait-il m'éclaircir ce point ?

tu n'aurais pas un exemple parce que la j'ai pas bien compris ton probleme

ps: passes ton instance par reference constante

Le pointeur, c'était plus simple pour moi dans un cas précis et j'ai oublié de le remplacer par une reference dans mon exemple...
Voici un exemple de mon cas :

#include <iostream>

#include "fichier_fils.h"

using namespace std;

/* pour surcharger l'operateur << */
ostream &operator<<( ostream &out, Classe &classe ){
    classe.afficher(out);
    return out;
}

ostream &operator<<( ostream &out, Fils &fils ){
    fils.afficher(out);
    return out;
}

int main(){ 
    
    Classe classe();
    Fils fils();
    
    /* ... */

    cout << fichier << /* ... */ << classe;

    return EXIT_SUCCESS;
}

#ifndef FILS_H
#define FILS_H

#include "classe.h"

class Fils{
    public:
    
    Fils();
    void afficher(std::ostream &out);
    /*...*/

    private:

    Classe classe;    
    /*...*/
};

#endif

#include <iostream>

#include "fichier_fils.h"

using namespace std;

/* j'ai besoin de cette fonction mais le compilateur interdit de la redefinir */
ostream &operator<<( ostream &out, Classe &classe ){
    classe.afficher(out);
    return out;
}

Fils::Fils() : classe(), /*...*/
{
    /*...*/
}

/*...*/

void Fils::afficher(ostream &out){
     out << /*...*/ << classe << /*..*/ << endl;    
}

#ifndef CLASSE_H
#define CLASSE_H

class Classe{
    public :
    
    Classe();    
    void afficher(std::ostream &out);
    /* ... */
    
    private :
    /* ... */    
};

#endif

#include <iostream>
#include "classe.h"

using namespace std;

Classe::Classe() : /* ... */
{
    /* ... */    
}

void Classe::afficher(ostream &out){
    out << /* ... */ << endl;
}

Euh, pourquoi est-ce que déclare ta fonction dans main.cpp ET dans fichier_fils.cpp? L'éditeur de lien rencontre deux fois la même fonction, il est un peu normal qu'il ne sache pas quoi faire avec!

Pas du tout Ice_Keese, une fois il n'y a que le prototype c'est donc correct.

Quelle est ton erreur donnée par le compilateur ?

En tout cas le main ne peut pas compiler avec ce qu'il y a dedans. L'appel au constructeur par défaut se fait sans les "()".

Classe classe();
    Fils fils();

Tu déclare des fonctions,tu ne créer pas d'objet

Edit: merde mal lu, je me suis fait griller par Nanoc.

PS:C'est une référence constante dans operator<<

Désolé pour mes déclarations d'objet érronnée, d'habitude je travaille avec des pointeurs mais pour mon exemple j'ai voulu mettre des objet et je me suis trompé
Alors voici ce que me dit le compilateur ;

21           C:\...\fichier_fils.cpp     no match for 'operator<<' in 'out << classe' 
fichier_fils C:\...\ostream.tcc:63       candidates are: std::basic_ostream<_CharT, _Traits>&
...

multiple definition of `operator<<(std::ostream&, Classe&)'
...

EDIT :
pffff en fait c'etait trop simple mais je me suis compliqué la vie avec cette fonction que je ne comprend pas trop...
Il suffisait de declarer la fonction normalement dans "fichier_fils.cpp", sans mettre le prototype dans le .h (je ne sais pas pourquoi, je constate). Et rappeler le prototype dans "main.cpp".

Tient dont, "multiple definition of `operator<<(std::ostream&, Classe&)'"...

Semblerait qu'il n'y avait pas que le prototype alors...

Je me référais à l'exemple donné.

Normal il y a plusieurs définitions!

On doit déclarer une fonction dans chaque unité de compilation, mais on doit la définir une seule fois par programme !

Alors tu enlève ton code du main.cpp et tu ajoutes la signature dans ton fichier_fils.h. Et ce pour tout les opérateurs libres. As-tu déjà dû te retaper les opérateurs de std::string ou de std::vector dans tes .cpp?

C'est tout !

Oh et en passant... les références vont de simplifier la vie, tu n'as pas idée !