Obtention d'instances différentes pour communiquer

Question

Supposons que j'ai deux instances de la même classe. La classe a un pointeur sur certaines données, et je veux que les instances échangent les pointeurs dans le cadre de l'algorithme d'une fonction privée, mais sans compromettre les données pour tout le monde en lui donnant un accès direct via une fonction publique. Ma première idée était d'ajouter une variable statique de type bool appelée exchange, et deux méthodes: une privée: void requestExchange() et une publique: Data ** respond(). requestExchange fixerait échange true, et sera immédiatement suivi avec répondiez() de l'instance de choix, qui fera les suivantes:

if(exchange==true){ 
    exchange=false; 
    return data; 
} 
else{return...?! 

Ce fut quand je compris que je n'ai aucun moyen de simuler « NO OP "puisque les données peuvent en fait être NULL, donc tout se passe comme une réponse. Des idées sur ce qui peut être fait? MISE À JOUR: J'ai réfléchi un peu à ce sujet, et puisque le combo request-response ne sera appelé que dans le contexte où NULL aura un sens (l'échange est certainement vrai), je suppose que je peux simplement retourner NULL et simuler un NO OP de cette façon. Pour un outsider NULL à la suite sera inutile ... Mais je suis toujours intéressé par des suggestions. Il doit y avoir une façon plus structurée de le faire.

Answer 1

Les objets de la même classe peuvent accéder directement aux données privées des autres. Vous voyez souvent ceci dans les constructeurs de copie, par exemple.

Answer 2

Votre description du problème n'est pas très claire. Pourquoi ne pouvez-vous pas simplement rendre respond() une fonction privée?

L'idée avec un membre de classe statique est lourde de dangers. Et si deux paires de telles instances veulent communiquer simultanément? Que se passe-t-il si l'on place le drapeau d'échange et qu'il meurt avant d'appeler respond()? Et la sécurité des threads? Pour retourner un NO-OP ou un indicateur d'erreur, vous pouvez soit utiliser des exceptions (c'est pour cela qu'elles sont, mais si votre projet n'utilise pas d'exceptions, ce n'est pas une bonne idée de les introduire soudainement) de boost :: facultatif.

Answer 3

Il serait peut-être préférable de séparer vos préoccupations concernant le retour des données et leur échange.

class Foo 
{ 
public: 
    Bar* data() 
    { 
     return pData; 
    } 
private: 
    void exchangeData(Foo& Rhs) 
    { 
     if (this != &Rhs) 
     { 
     Bar* pTmp = pData; 
     pData = Rhs.pData; 
     Rhs.pData = pTmp; 
     } 
    } 
    Bar* pData; 
} 

Espérons que c'est dans le sens de ce que vous voulez? La question n'est pas super claire ....

Answer 4

J'ai probablement raté le point de votre question. Pourquoi cela ne fait-il pas ce que vous voulez?

class CMyClass 
{ 
public: 
    void ExchangePointerWith(CMyClass& rhs); 

private: 
    void* m_MyPtr; 
}; 

et:

void CMyClass::ExchangePointerWith(CMyClass &rhs) 
{ 
    void* tmp= m_MyPtr; 
    m_MyPtr= rhs.m_MyPtr; 
    rhs.m_MyPtr= tmp; 
} 

Answer 5

Utilisez std :: swap() et construire propre méthode d'échange de votre classe alors vous savez qu'il devrait être exception en toute sécurité. Et swap() est un routage standard que la plupart des classes devraient implémenter pour les rendre efficaces pour la STL. Rappelez-vous qu'une classe est automatiquement une amie de lui-même. Il peut donc accéder aux variables membres privées d'une autre instance de la même classe. Voir (Friend scope in C++)

#include <algorithm> 

class myX 
{ 
    public: 
     void swap(myX& rhs) throw() 
     { 
      std::swap(data,rhs.data); 
     } 
    private: 
     void* data; 
};