Esse padrão de proteção de access orientado por chave é um idioma conhecido?

Matthieu M. criou um padrão para proteção de access nessa resposta que eu já tinha visto antes, mas nunca considerei conscientemente um padrão:

class SomeKey { friend class Foo; SomeKey() {} // possibly make it non-copyable too }; class Bar { public: void protectedMethod(SomeKey); }; 

Aqui apenas um friend da class chave tem access a protectedMethod() :

 class Foo { void do_stuff(Bar& b) { b.protectedMethod(SomeKey()); // fine, Foo is friend of SomeKey } }; class Baz { void do_stuff(Bar& b) { b.protectedMethod(SomeKey()); // error, SomeKey::SomeKey() is private } }; 

Ele permite um controle de access mais granular do que tornar Foo um friend do Bar e evitar padrões de proxy mais complexos.

Alguém sabe se esta abordagem já tem um nome, ou seja, é um padrão conhecido?

Graças à sua outra pergunta , parece que esse padrão agora é conhecido como padrão “passkey”.

Em C ++ 11, fica ainda mais limpo, porque em vez de chamar

 b.protectedMethod(SomeKey()); 

você pode simplesmente ligar:

 b.protectedMethod({}); 

Parece que esta expressão como uma mencionada em outra pergunta SO aqui . É chamado de expressão cliente-cliente e descrito em mais detalhes lá .

algum homem chato como eu faria o código fowllow:

 int FraudKey=0; b.protectedMethod(reinterpret_cast(FraudKey)); 

É bem perto disso:

http://minorfs.wordpress.com/2013/01/18/raiicap-pattern-injected-singleton-alternative-for-c/

Basicamente, se você considerar uma referência a um object de class bem projetada para fornecer o controle de access, você precisa implementar qualquer política de controle de access que realmente faça sentido, aplicar esse padrão a algo diferente do construtor não parece fazer muito sentido.

Assim como o artigo afirma, se você usar essa chave em conjunto com esses construtores para o controle de access pode fazer sentido, objects que representam partes significativas de resources de sustos, que em C ++ geralmente seriam implementados como objects RAII, que o nome RAIICap ou RAII -Capacidade, de fato, faz sentido.

http://www.eros-os.org/essays/capintro.html

Alternativamente, você pode se referir a ele com um nome mais geral, como autoridade de construção.

A implementação no artigo é um pouco centralizada, isto é, a principal necessidade de criar todas as chaves de autoridade. Você pode estendê-lo e torná-lo mais flexível adicionando um construtor público adicional para a chave em si:

 template  class construct_authority { public: construct_authority(construct_authority const&) friend int main(int,char **); private: construct_authority(){} }; 

Dessa forma, o principal poderia delegar a criação de chaves para outras partes do programa.

Pessoalmente, acho que o nome RAIICap é bastante apropriado para a parte útil deste padrão.

Há um tempo, propus que esse modelo simples acima pudesse ser adicionado à biblioteca padrão.

https://groups.google.com/a/isocpp.org/forum/#!topic/std-proposals/p_v-aYIvO1E

Infelizmente, existem problemas com a ideia de que pode haver uma impressão digital principal que constitui uma raiz computacional, então algo como isto aparentemente não pode ter um lugar na biblioteca padrão. Dito isto, pelo menos para o uso com o construtor de classs RAII, este padrão parece ser bastante útil.