Можем ли мы увеличить возможность повторного использования этого шаблона защиты доступа, ориентированного на ключи?

Мне нравится эта идиома, и она может стать намного чище и выразительнее.

В стандартном 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 идиома может достигать своей простейшей и наиболее выразительной формы. Это связано как с вариативными шаблонами, так и с тем, что параметры шаблона могут быть друзьями. (Обратите внимание, что MSVC до 2010 допускает указатели друзей шаблона в качестве расширения; поэтому можно смоделировать это решение):

// 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(){}

Обратите внимание, что в большинстве случаев (все нефункциональные случаи!) Ничего больше не требуется специально определять. Этот код в общем и просто реализует идиому для любой комбинации классов и функций.

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

Я прочитал много комментариев о невозможности копирования. Многие думали, что его нельзя не копировать, потому что тогда мы не сможем передать его в качестве аргумента функции, которой нужен ключ. А некоторые даже удивились, что это сработало. На самом деле этого не должно быть, и, по-видимому, это связано с некоторыми компиляторами Visual C ++, поскольку у меня была такая же странность раньше, но больше не с Visual C ++ 12 (Studio 2013).

Но вот в чем дело: мы можем повысить безопасность с помощью «базовой» защиты от копирования. Версия Boost слишком велика, так как полностью исключает использование конструктора копирования и, следовательно, слишком много для того, что нам нужно. Что нам нужно, так это сделать конструктор копирования закрытым, но не без реализации. Конечно, реализация будет пустой, но она должна существовать. Я недавно спросил, кто в таком случае вызывает copy-ctor (в данном случае кто вызывает конструктор копирования SomeKey при вызове ProtectedMethod). Ответ заключался в том, что, по-видимому, стандарт гарантирует, что именно вызывающий метод вызывает -ctor, что, честно говоря, выглядит вполне логично. Таким образом, делая copy-ctor закрытым, мы позволяем функции друзей (protected Bar и granted Foo) вызывать его, тем самым позволяя 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;
}