Получение разных экземпляров для общения

Question

Предположим, у меня есть два экземпляра одного класса. У класса есть указатель на некоторые данные, и я хочу, чтобы экземпляры обменивались указателями как часть алгоритма какой-то частной функции, но без компрометации данных для всех остальных, предоставляя прямой доступ к ним через открытую функцию.

Моей первой идеей было добавить статическую переменную типа bool с именем exchange и два метода: приватный: void requestExchange () и публичный: Data ** response (). requestExchange установит для exchange значение true, и сразу за ним будет следовать response () из выбранного экземпляра, который будет выполнять следующее:

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

Это было тогда, когда я понял, что у меня нет способа симулировать «НЕТ ОП», поскольку данные могут фактически быть ПУСТО (NULL), поэтому, предположительно, все идет как ответ. Есть идеи, что можно сделать?

ОБНОВЛЕНИЕ: Я немного подумал об этом, и поскольку комбо-запрос-ответ будет вызываться только в контексте, в котором значение NULL будет иметь смысл (обмен наверняка верен), я предполагаю, что могу просто вернуть NULL и смоделировать НЕТ OP таким образом. Для постороннего NULL в результате будет бесполезен ... Но меня все равно интересуют предложения. Должен быть более хорошо структурированный способ сделать это.

Answer 1

Объекты одного и того же класса могут напрямую обращаться к личным данным друг друга. Вы часто видите это в конструкторах копирования, например.

Answer 2

Используйте std :: swap () и создайте собственный метод swap вашего класса, тогда вы знаете, что он должен быть безопасным для исключений. А swap () - это стандартная маршрутизация, которую должен реализовать большинство классов, чтобы сделать их эффективными для STL.

Помните, что класс автоматически становится его другом. Таким образом, он может получить доступ к закрытым переменным-членам другого экземпляра того же класса. Смотрите ( Область друзей в C ++ )

#include <algorithm>

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

Answer 3

Я, наверное, упустил суть вашего вопроса. Почему это не делает то, что вы хотите?

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

private:
    void* m_MyPtr;
};

и

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

Answer 4

Лучше всего разделить ваши опасения по поводу возврата данных и их обмена.

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;
}

Надеюсь, это в соответствии с тем, что вы хотите? Вопрос не супер ясен ....

Answer 5

Ваше описание проблемы не очень понятно. Почему вы не можете просто сделать response () закрытой функцией?

Идея со статическим членом класса таит в себе опасность. Что если две пары таких экземпляров хотят общаться одновременно? Что если кто-то установит флаг обмена, а затем умрет до того, как вызовет ответ ()? А как насчет безопасности потоков?

Что касается возврата NO-OP или индикатора ошибки, вы можете либо использовать исключения (для этого они и нужны, но если ваш проект не использует исключения, не рекомендуется вводить их внезапно), или идти по пути повышение :: необязательными.