class Param
{
public:
    Param();
private:
    doSome();
//...
};

class Wrapper
{
public:
    Wrapper(Param &param);
    Param *operator->();
};

Хочется разрешить доступ к методам объекта класса Param, только через класс-оболочку. Что-то вроде:

Param param();
Wrapper(param);
wrapper->doSome();

Само собой такой вариант не работает
Есть какие-нибудь способы защиты методов класса Param от пользователя?

На ум приходит только такой вариант, но он хлопотный:

class Param
{
public:
    Param();
private:
        friend class Wrapper;
    doSome();
//...
};


class Wrapper
{
public:
    Wrapper(Param &param);
    inline void doSome()
        { param.doSome(); }
};

//
В задаче, Param — это набор данных, доступ к которому может осуществляться из разных потоков. Param содержит мьютекс, хочется разрешить изменение и получение внутренних данных только через классы оболочки SharedAccess и UniqueAccess, которые бы предоставляли нужный доступ.

Здравствуйте, Аноним, Вы писали:

class inner
{
public:
   int _i;
   void do_smth() {}
};

class core_access;

class outer
{
private:
   friend class core_access;

   inner _inner;
public:
   outer(int i)
   {
      _inner._i = i;
   }
};

class core_access
{
private:
   outer *_outer;
public:
   core_access(outer *o): _outer(o) {}

   inner *operator -> ()
   {
      return &_outer->_inner;
   }
};

int _tmain(int argc, _TCHAR* argv[])
{
   outer O(2);
   core_access wrapper(&O);
   int i = wrapper->_i;
   wrapper->do_smth();

    return 0;
}

Здравствуйте, Аноним, Вы писали:

Если тебе нужна гарантия того, что объект залочен, можно попробовать что-то типа вот этого:

class Param;
class param_shared_lock
{
public:
   param_shared_lock(Param& p);
   ~param_shared_lock();

private:
   Param& p_;
};

class Param
{
   friend class param_shared_lock;
public:
   Param() {}

   void doSome(const param_shared_lock&);//пользователь должен сначала залочить объект

private:
   mutex m_;
};

param_shared_lock::param_shared_lock(Param& p) : p_(p)
{
   p_.m_.lock();
}

param_shared_lock::~param_shared_lock()
{
   p_.m_.unlock();
}

//пример использования
int main()
{
   Param p;
   //...
   {
      param_shared_lock lock(p);
      p.doSome (lock);
   }
   return 0;
}

Здравствуйте, swingus

Спасибо большое, то что надо