[Débutant]Surcharge opérateur +

Bonjour tout le monde !

Je n'arrive pas à surcharger mon opérateur +...
En faite, il faudrait que j'applique l'opérateur + à un objet de Message et à une chaine de caractère...

J'ai donc ma classe message :

class message{
   private:
      enum { n = 10 };
      static int cpt_id_message; // compteur nombr id déjà utilisé
      int num_id_message; // num id du message
      char *adresse_expediteur;
      char *adresse_destinataire;
      bool urgent;
      bool mess_lu;
      char *sujet;
      char *texte;

   public:
      message (void); // constructeur par défaut
      message (const message & mess); // constructeur de copie
      message (int num, char *ad_exp, char *ad_dest, bool urg, bool msg_lu, char *sjt, char *txt);
      ~message (void) // Destructeur class message {
         delete []adresse_expediteur;
         delete []adresse_destinataire;
         delete []sujet;
         delete []texte;   }
      
      message operator+ (const char *ad_dest) const; // surcharge de l'opérateur +
      
      void affMessage (void); // afficher le message
      void encMessage (void); // entrer le message
      void checkFormatMsg (char *tmpEnc); // vérifie la présence d'un " @ "
      void setExpediteur (char *tmpEnc) {
         adresse_expediteur = new char[strlen(tmpEnc)+1];
         strcpy(adresse_expediteur,tmpEnc); }

      void setDestinataire (char *tmpEnc) {
         adresse_destinataire = new char[strlen(tmpEnc)+1];
         strcpy(adresse_destinataire,tmpEnc); }

      char *getDestinataire (void) {
         return adresse_destinataire; }
};

Est-ce que çà c'est juste çà, déjà ? :
message operator+ (const char *ad_dest) const; // surcharge de l'opérateur +

Ma fonction de surcharge est la suivante (est-ce bon ?) :
message message::operator +(const char* ad_dest) const {
   message msg;
   msg.adresse_destinataire = adresse_destinataire + ad_dest;
   return msg; }

En faite, je dois mettre plusieurs adresses email dans "adresse_destinataire" et je fais çà comme çà dans mon main() (=> qui doit être surment pas bon mais partout, les exemples pour la surcharge de l'opérateur + se fait avec des chiffres et non des chars  ) :
strcpy(tmpEnc,tmpEnc + getDestinataire()); setDestinataire(tmpEnc); // surcharge de l'opérateur

Voilà, je n'arrive vraiment pas à faire ces choses on ne peut plus basic .

Merci d'avance.

On concatène avec strcat( ... )

if(!Meilleur("Joky")) return ERREUR;<

Je dois surcharger l'opérateur + et pas faire un simple strcat .

Ou alors tu voulais dire remplacer le strcpy par strcat dans mon main() ? (parce que çà ne va pas ).

message operator+ (const char *ad_dest) const;

Oui, ca m'a l'air d'être bon. L'implémentation se fait avec strcat. Sinon ca récursive

Et dans mon main(), je dois faire quoi pour ajouter deux chaines de caractères l'une à l'autre ?

tmpEnc = adresse_destinataire + tmpEnc; // tmpEnc étant un tableau de char contenant qlq chose dedans.

C'est juste çà ? Parce que comme erreur j'ai :
Error C2110: '+' : cannot add two pointers

Merci...

Geolem

char Buff[512];
char *Mess = "Salut ";
strcpy(Buff, Mess);
strcat(Buff, "c'est moi la concaténation !");

MessageBox(0, Buff, 0, 0x40);

if(!Meilleur("Joky")) return ERREUR;<

Bah... ou est le + qui sert de surcharge ?

Geolem

Dans le main, on utilise l'opérateur +, c'est le but de la surcharge.
message m = ...;
m = m + "chaine";

Tu dois savoir qu'en général, on écrit d'abord l'opérateur +=, et on l'utilise dans operator+

Comme dit Joky, il faut bien utiliser strcat à un moment donné.

message message::operator +(const char* ad_dest) const
{
  message msg = *this;
  strcat(msg.adresse_destinataire, ad_dest);
  return msg;
}

Pourquoi ne pas utiliser std::string, qui fait tout ca un peu mieux que strcat?