Можем ли мы повысить возможность повторного использования этого ориентированного на ключ шаблона защиты доступа?
Можем ли мы увеличить возможность повторного использования для этого ориентированного на ключ шаблона защиты доступа:
class SomeKey {
friend class Foo;
// more friends... ?
SomeKey() {}
// possibly non-copyable too
};
class Bar {
public:
void protectedMethod(SomeKey); // only friends of SomeKey have access
};
Во избежание недопонимания эта схема отличается от идиомы " адвокат-клиент":
- Он может быть более кратким, чем Attorney-Client (так как он не предполагает прокси через третий класс)
- Это может позволить делегирование прав доступа
- ... но это также более навязчиво для исходного класса (один фиктивный параметр на метод)
(В этом вопросе возникла дополнительная дискуссия, поэтому я открываю этот вопрос.)
3 ответа
Мне нравится эта идиома, и она может стать намного чище и выразительнее.
В стандарте C++03, я думаю, следующий способ является самым простым и наиболее общим. (Хотя не так уж и много улучшений. В основном экономит на повторении.) Поскольку параметры шаблона не могут быть друзьями, мы должны использовать макрос для определения ключа доступа:
// define passkey groups
#define EXPAND(pX) pX
#define PASSKEY_1(pKeyname, pFriend1) \
class EXPAND(pKeyname) \
{ \
private: \
friend EXPAND(pFriend1); \
EXPAND(pKeyname)() {} \
\
EXPAND(pKeyname)(const EXPAND(pKeyname)&); \
EXPAND(pKeyname)& operator=(const EXPAND(pKeyname)&); \
}
#define PASSKEY_2(pKeyname, pFriend1, pFriend2) \
class EXPAND(pKeyname) \
{ \
private: \
friend EXPAND(pFriend1); \
friend EXPAND(pFriend2); \
EXPAND(pKeyname)() {} \
\
EXPAND(pKeyname)(const EXPAND(pKeyname)&); \
EXPAND(pKeyname)& operator=(const EXPAND(pKeyname)&); \
}
// and so on to some N
//////////////////////////////////////////////////////////
// test!
//////////////////////////////////////////////////////////
struct bar;
struct baz;
struct qux;
void quux(int, double);
struct foo
{
PASSKEY_1(restricted1_key, struct bar);
PASSKEY_2(restricted2_key, struct bar, struct baz);
PASSKEY_1(restricted3_key, void quux(int, double));
void restricted1(restricted1_key) {}
void restricted2(restricted2_key) {}
void restricted3(restricted3_key) {}
} f;
struct bar
{
void run(void)
{
// passkey works
f.restricted1(foo::restricted1_key());
f.restricted2(foo::restricted2_key());
}
};
struct baz
{
void run(void)
{
// cannot create passkey
/* f.restricted1(foo::restricted1_key()); */
// passkey works
f.restricted2(foo::restricted2_key());
}
};
struct qux
{
void run(void)
{
// cannot create any required passkeys
/* f.restricted1(foo::restricted1_key()); */
/* f.restricted2(foo::restricted2_key()); */
}
};
void quux(int, double)
{
// passkey words
f.restricted3(foo::restricted3_key());
}
void corge(void)
{
// cannot use quux's passkey
/* f.restricted3(foo::restricted3_key()); */
}
int main(){}
У этого метода есть два недостатка: 1) вызывающий должен знать конкретный пароль, который ему нужно создать. Пока простая схема именования (function_key) в основном устраняет это, это все еще может быть один очиститель абстракции (и проще). 2) Хотя использовать макрос не очень сложно, он может показаться немного уродливым, требующим блок определений паролей. Тем не менее, улучшения в этих недостатках не могут быть сделаны в C++03.
В C++0x идиома может достичь своей самой простой и выразительной формы. Это связано как с переменными шаблонами, так и с тем, что параметры шаблона могут быть друзьями. (Обратите внимание, что до 2010 года MSVC допускает использование спецификаторов друзей шаблона в качестве расширения; поэтому можно смоделировать это решение):
// each class has its own unique key only it can create
// (it will try to get friendship by "showing" its passkey)
template <typename T>
class passkey
{
private:
friend T; // C++0x, MSVC allows as extension
passkey() {}
// noncopyable
passkey(const passkey&) = delete;
passkey& operator=(const passkey&) = delete;
};
// functions still require a macro. this
// is because a friend function requires
// the entire declaration, which is not
// just a type, but a name as well. we do
// this by creating a tag and specializing
// the passkey for it, friending the function
#define EXPAND(pX) pX
// we use variadic macro parameters to allow
// functions with commas, it all gets pasted
// back together again when we friend it
#define PASSKEY_FUNCTION(pTag, pFunc, ...) \
struct EXPAND(pTag); \
\
template <> \
class passkey<EXPAND(pTag)> \
{ \
private: \
friend pFunc __VA_ARGS__; \
passkey() {} \
\
passkey(const passkey&) = delete; \
passkey& operator=(const passkey&) = delete; \
}
// meta function determines if a type
// is contained in a parameter pack
template<typename T, typename... List>
struct is_contained : std::false_type {};
template<typename T, typename... List>
struct is_contained<T, T, List...> : std::true_type {};
template<typename T, typename Head, typename... List>
struct is_contained<T, Head, List...> : is_contained<T, List...> {};
// this class can only be created with allowed passkeys
template <typename... Keys>
class allow
{
public:
// check if passkey is allowed
template <typename Key>
allow(const passkey<Key>&)
{
static_assert(is_contained<Key, Keys>::value,
"Passkey is not allowed.");
}
private:
// noncopyable
allow(const allow&) = delete;
allow& operator=(const allow&) = delete;
};
//////////////////////////////////////////////////////////
// test!
//////////////////////////////////////////////////////////
struct bar;
struct baz;
struct qux;
void quux(int, double);
// make a passkey for quux function
PASSKEY_FUNCTION(quux_tag, void quux(int, double));
struct foo
{
void restricted1(allow<bar>) {}
void restricted2(allow<bar, baz>) {}
void restricted3(allow<quux_tag>) {}
} f;
struct bar
{
void run(void)
{
// passkey works
f.restricted1(passkey<bar>());
f.restricted2(passkey<bar>());
}
};
struct baz
{
void run(void)
{
// passkey does not work
/* f.restricted1(passkey<baz>()); */
// passkey works
f.restricted2(passkey<baz>());
}
};
struct qux
{
void run(void)
{
// own passkey does not work,
// cannot create any required passkeys
/* f.restricted1(passkey<qux>()); */
/* f.restricted2(passkey<qux>()); */
/* f.restricted1(passkey<bar>()); */
/* f.restricted2(passkey<baz>()); */
}
};
void quux(int, double)
{
// passkey words
f.restricted3(passkey<quux_tag>());
}
void corge(void)
{
// cannot use quux's passkey
/* f.restricted3(passkey<quux_tag>()); */
}
int main(){}
Обратите внимание, что только с помощью стандартного кода, в большинстве случаев (все нефункциональные случаи!) Больше ничего не нужно специально определять. Этот код обобщенно и просто реализует идиому для любой комбинации классов и функций.
Вызывающему не нужно пытаться создать или запомнить ключ доступа, специфичный для функции. Скорее, у каждого класса теперь есть свой уникальный пароль, и функция просто выбирает, какой пароль он разрешит в параметрах шаблона параметра passkey (никаких дополнительных определений не требуется); это устраняет оба недостатка. Вызывающий просто создает свой собственный пароль и звонит с этим, и ему не нужно больше ни о чем беспокоиться.
Я прочитал много комментариев о невозможности копирования. Многие думали, что это не должно быть недоступно для копирования, потому что тогда мы не можем передать его в качестве аргумента функции, которой нужен ключ. И некоторые даже удивились, что это сработало. Что ж, это действительно не должно и, по-видимому, связано с некоторыми компиляторами Visual C++, так как раньше у меня была та же странность, но больше не было с Visual C++12 (Studio 2013).
Но в том-то и дело, что мы можем повысить безопасность с помощью "базового" отсутствия копирования. Boost-версия слишком большая, так как она полностью предотвращает использование конструктора копирования и, следовательно, слишком много для того, что нам нужно. На самом деле нам нужно сделать конструктор копирования закрытым, но не без реализации. Конечно, реализация будет пустой, но она должна существовать. Я недавно спросил, кто в этом случае вызывает copy-ctor (в этом случае кто вызывает конструктор копирования SomeKey при звонке ProtectedMethod). Ответ состоял в том, что, очевидно, стандарт гарантирует, что вызывающий метод вызывает -ctor что честно выглядит вполне логично. Таким образом, делая copy-ctor частное мы позволяем функции друзей (protectedBar и grantedFoo) называть его, тем самым позволяя Foo позвонить ProtectedMethod потому что он использует передачу аргументов значения, но он также предотвращает кого-либо из FooСфера.
Делая это, даже если другой разработчик попытается поработать с кодом, ему на самом деле придется сделать Foo делать работу, другой класс не сможет получить ключ, и есть вероятность, что он поймет свои ошибки почти 100% времени таким образом (надеюсь, в противном случае он слишком много новичок, чтобы использовать этот шаблон, или он должен прекратить развитие:P).
Отличный ответ от @GManNickG. Многому научился. Пытаясь заставить его работать, нашел пару опечаток. Полный пример повторен для наглядности. Мой пример заимствует функцию "содержит ключи в ключах..." из проверки, содержит ли пакет параметров C++0x тип, опубликованный @snk_kid.
#include<type_traits>
#include<iostream>
// identify if type is in a parameter pack or not
template < typename Tp, typename... List >
struct contains : std::false_type {};
template < typename Tp, typename Head, typename... Rest >
struct contains<Tp, Head, Rest...> :
std::conditional< std::is_same<Tp, Head>::value,
std::true_type,
contains<Tp, Rest...>
>::type{};
template < typename Tp >
struct contains<Tp> : std::false_type{};
// everything is private!
template <typename T>
class passkey {
private:
friend T;
passkey() {}
// noncopyable
passkey(const passkey&) = delete;
passkey& operator=(const passkey&) = delete;
};
// what keys are allowed
template <typename... Keys>
class allow {
public:
template <typename Key>
allow(const passkey<Key>&) {
static_assert(contains<Key, Keys...>::value, "Pass key is not allowed");
}
private:
// noncopyable
allow(const allow&) = delete;
allow& operator=(const allow&) = delete;
};
struct for1;
struct for2;
struct foo {
void restrict1(allow<for1>) {}
void restrict2(allow<for1, for2>){}
} foo1;
struct for1 {
void myFnc() {
foo1.restrict1(passkey<for1>());
}
};
struct for2 {
void myFnc() {
foo1.restrict2(passkey<for2>());
// foo1.restrict1(passkey<for2>()); // no passkey
}
};
void main() {
std::cout << contains<int, int>::value << std::endl;
std::cout << contains<int>::value << std::endl;
std::cout << contains<int, double, bool, unsigned int>::value << std::endl;
std::cout << contains<int, double>::value << std::endl;
}