Форум на Исходниках.RU

Друзья класса

Flex_Ferrum — Wed, 18 Feb 2004 16:31:00 +0000

Flex_Ferrum:

Цитата

Sazabis, 18.02.04, 19:27
но это уже не решение, а изменение

Вот вот. А изначально задача ставилась как "открыть доступ к заданным членам заданному классу".

Друзья класса

Sazabis — Wed, 18 Feb 2004 16:27:10 +0000

Sazabis: самое простое !? в TO иметь pC2 зафрендить ему T2. А T1 унаследовать от T0.

Или вообще T2 унаследовать от T0, раз это общая часть ? ( но это уже не решение, а изменение )

Друзья класса

Flex_Ferrum — Wed, 18 Feb 2004 15:02:32 +0000

Flex_Ferrum:

Цитата

Flip, 18.02.04, 18:00
А если будет написанно так?

Против лома нет приема. Обмануть и обойти все можно. Точно также в твоем случае можно залезть в заголовок и подправить список дружественных методов.
Предложенный способ достаточно прост в использовании. Но рассчитан на честность программиста.

Друзья класса

Flip — Wed, 18 Feb 2004 15:00:05 +0000

Flip: Flex_Ferrum
А если будет написанно так?

void C3::Foo(C1* ptr)

{

ptr->GetAccess((C2*)NULL).GetC1();

ptr->GetAccess((C2*)NULL).GetC2();

}

Друзья класса

Flex_Ferrum — Wed, 18 Feb 2004 14:27:48 +0000

Flex_Ferrum:

Цитата

Budda, 18.02.04, 17:24
Эх нужно тестить, абстрактно догнать не могу....

Попробуй.

Друзья класса

Budda — Wed, 18 Feb 2004 14:24:34 +0000

Budda: Эх нужно тестить, абстрактно догнать не могу.... :(

Друзья класса

Flex_Ferrum — Wed, 18 Feb 2004 13:53:54 +0000

Flex_Ferrum: В С++ существует такая вещь - специализация шаблонов. Используется тогда, когда для конкретного типа шаблон должен вести себя особым образом. В приведенном примере у нас получается следующее. Общая специализация:

Цитата

Budda, 18.02.04, 16:46
template class Accessor_t
{
Accessor_t(C1* parent) {;};
};

Не содержит никаких методов доступа. Таким образом, когда мы будем инстанцировать этот шаблон - ни к какому методу мы обратиться не сможем (по причине их отсутствия).
Теперь делаем взмах руками над клавиатурой и...

Цитата

Budda, 18.02.04, 16:46
template<> class Accessor_t : public BaseAccessor
{
public:
Accessor_t(C1* parent) : BaseAccessor(parent) {;}
};

Получаем, что если мы будем инстанцировать шаблон Accessor_t для типа C2*, то получим доступ к методам, объявленным в классе BaseAccessors. Т. е. объекты
Accessor_t c2_accessor();
и
Accessor_t c3_accessor();
будут вести себя по-разному и будут содержать разные методы.
Теперь мы еще немножко напрягаем компилятор, и делаем так, что он сам выбирает для нас нужную специализацию:

// Метод, возвращающий объект, через который будем получать доступ.

template<class T> Accessor_t<T*> GetAccess(T* obj)

{

return Accessor_t<T*>(this);

}

используя факт того, что шаблонные методы могут инстанцироваться неявно. В итоге мы можем использовать все это описанным мною способом:

void C2::Foo(C1* ptr)

{

ptr->GetAccess(this).GetC1();

ptr->GetAccess(this).GetC2();

}

При этом доступом управляет сам класс C1, и на этапе компиляции мы получаем жесткий контроль - классы, которым "не положено" доступа не получат.

Друзья класса

Budda — Wed, 18 Feb 2004 13:46:39 +0000

Budda: :( сильно намучено, помимо прочего, не могу понять назначение вот этого:

// Объявлеяем общий шаблон. Он будет использован для "остальных" классов

template<class T> class Accessor_t

{

Accessor_t(C1* parent) {;};

};

// Объявляем специализацию, которая открывает доступ конкретному классу

template<> class Accessor_t<C2*> : public BaseAccessor

{

public:

Accessor_t(C1* parent) : BaseAccessor(parent) {;}

};

Друзья класса

Flex_Ferrum — Wed, 18 Feb 2004 13:29:34 +0000

Flex_Ferrum: Этот вариант легко модифицируется к варианту со статическими методами. А используя приватное наследование и using можно легко регулировать доступ для разных классов.

Друзья класса

Flex_Ferrum — Wed, 18 Feb 2004 12:27:28 +0000

Flex_Ferrum: Можно замутить еще такой вариант. Предполагаем, что регулированием доступа занимается класс C1:

class C1

{

public:

C1() {;}

private:

// Объявляем класс, предоставляющий доступ

class BaseAccessor

{

public:

BaseAccessor(C1* parent) : m_Parent(parent) {;}

int GetC1() {return m_Parent->m_C1;}

int GetC2() {return m_Parent->m_C2;}

private:

C1* m_Parent;

};

// Объявлеяем общий шаблон. Он будет использован для "остальных" классов

template<class T> class Accessor_t

{

Accessor_t(C1* parent) {;};

};

// Объявляем специализацию, которая открывает доступ конкретному классу

template<> class Accessor_t<C2*> : public BaseAccessor

{

public:

Accessor_t(C1* parent) : BaseAccessor(parent) {;}

};

friend class C1::BaseAccessor;

int m_C1;

int m_C2;

public:

// Метод, возвращающий объект, через который будем получать доступ.

template<class T> Accessor_t<T*> GetAccess(T* obj)

{

return Accessor_t<T*>(this);

}

};

class C2

{

public:

void Foo(C1* ptr);

};

void C2::Foo(C1* ptr)

{

ptr->GetAccess(this).GetC1();

ptr->GetAccess(this).GetC2();

}

class C3

{

public:

void Foo(C1* ptr);

};

void C3::Foo(C1* ptr)

{

//ptr->GetAccess(this).GetC1();

//ptr->GetAccess(this).GetC2();

}

Под студией, если раскомментарить последние две строчки - будет ошибка компиляции.

Друзья класса

trainer — Wed, 18 Feb 2004 11:54:07 +0000

trainer:

Цитата

Budda, 18.02.04, 11:26
Нужно чё-нить простое, но крутое!

Друзья класса

reporter — Wed, 18 Feb 2004 11:42:50 +0000

reporter:

Тopic moved here from Visual C++ / MFC / WTL / WinAPI

Друзья класса

Flip — Wed, 18 Feb 2004 11:35:38 +0000

Flip: Можно конечно придумать ещё несколько извратов на данную тему, по разному наследовать промежуточный класс в том числе и от T2 есть варианты, отработать использование protected, скрыть дополнительные функции с помощью define или template. Но сделать, как мне кажется, это красиво ну никак не выйдет.

Друзья класса

Budda — Wed, 18 Feb 2004 11:21:59 +0000

Budda: 2Flip - извращенец (в хорошем смысле)

Друзья класса

Flip — Wed, 18 Feb 2004 11:18:28 +0000

Flip:

class T1 {

private:

friend class FARSH;

class C2 *pC2;

class C1 *pC1;

};

class FARSH {

private:

friend class T2;

static C2 * GetpC2(T1& t1) { return t1.pC2; }

};

class T2 {

T1 t;

public:

T2() { C2 *pC2=FARSH::GetpC2(t); }

};

class T2 {

public:

T2(class T1& t) { class C2 *pC2=GetpC2(t); }

class C2 * GetpC2(T1& t1);

};

class T1 {

private:

friend C2* T2::GetpC2(T1&);

class C2 *pC2;

class C1 *pC1;

};

C2 * T2::GetpC2(T1& t1) {

return t1.pC2; // Но тут при желании можно обратиться к pC1!

}

Друзья класса

Budda — Wed, 18 Feb 2004 10:37:00 +0000

Budda: Да это решение... намученное правда...

в этом случае действительно комменитировать нечего, поскольку код правилен и ясен.

Спасибо. А ещё идеи есть? Например без использования дополнительного класса?

З.Ы. 2Lucifer, видишь? Здесь есть более находчивые люди.

Друзья класса

Flip — Wed, 18 Feb 2004 09:35:26 +0000

Flip: Да такой пример действительно работать не будет. Забыл я его проверить.
Придётся так:

class T0 {

private:

friend class T1;

class C1 *pC1;

};

class T1: public T0 {

private:

friend class T2;

class C2 *pC2;

};

Коментировать тут нечего доступ к pC1 имеет только T1, а разрешение на доступ к pC2 для T2 на pC1 не распространяется.

Друзья класса

Budda — Wed, 18 Feb 2004 09:31:38 +0000

Budda: Не понимаю, что это даёт?

pC1 станет protected для T1, а поскольку класс T2 станет другом для Т1, то и к рС1 он тоже будет иметь доступ.

Или я не прав?

Прошу приводить код с коммантариями

Добавлено в 18.02.04, 09:33:
Да нет, не склероз. Просто раздел "Билдер" многие КЛАССНЫЕ программеры из раздела "Visual C" порсто не посещают. Вот потому я спрашиваю здесь

Друзья класса

Flip — Wed, 18 Feb 2004 09:27:06 +0000

Flip:

class T0 {

protected:

C1 *pC1;

};

class T1: private T0 {

private:

friend class T2;

C2 *pC2;

};

Друзья класса

Budda — Wed, 18 Feb 2004 08:50:50 +0000

Budda: class T1{
private:
C1 *pC1;
C2 *pC2;
};
class T2{
private
C3 *pC3;
};

Есть объекты
T1 m1;
T2 m2;

Как из объекта m2 получить доступ к полю pC2 объекта m1?
1. При этом любой другой класс не должен иметь доступа к полю pC2!
2. При этом класс C2 должен иметь доступ только к pC2, поле pC1 должно оставаться для него недоступным.

Хочу сделать что-то типа друга класса. Возожно ли это?
Но вариант
class T1{
private:
friend T2;
C1 *pC1;
C2 *pC2;
};

не проходит, ибо не выполняется условие 2.

Как выполнить поставленную задачу?