MatchEventStackInMemberFunction

O C++ Build Insights SDK é compatível com o Visual Studio 2017 e posterior. Para ver a documentação destas versões, defina o controlo seletor de versão do Visual Studio para este artigo para Visual Studio 2017 ou posterior. Encontra-se na parte superior do índice desta página.

A MatchEventStackInMemberFunction função é usada para corresponder uma pilha de eventos a uma hierarquia de eventos específica, descrita pela lista de parâmetros de uma função membro. As hierarquias correspondentes são encaminhadas para a função membro para processamento posterior. Para saber mais sobre eventos, pilhas de eventos e hierarquias, consulte Tabela de eventos.

Sintaxe

template <
    typename     TInterface,
    typename     TReturn,
    typename     T1,
    typename...  TExtraParams,
    typename...  TExtraArgs>
bool MatchEventStackInMemberFunction(
    const EventStack&         eventStack,
    TInterface*               objectPtr,
    TReturn (TInterface::*    memberFunc)(T1, TExtraParams...),
    TExtraArgs&&...           extraArgs);

template <
    typename     TInterface,
    typename     TReturn,
    typename     T1,
    typename     T2,
    typename...  TExtraParams,
    typename...  TExtraArgs>
bool MatchEventStackInMemberFunction(
    const EventStack&         eventStack,
    TInterface*               objectPtr,
    TReturn (TInterface::*    memberFunc)(T1, T2, TExtraParams...),
    TExtraArgs&&...           extraArgs);

// Etc...

template <
    typename     TInterface,
    typename     TReturn,
    typename     T1,
    typename     T2,
    typename     T3,
    typename     T4,
    typename     T5,
    typename     T6,
    typename     T7,
    typename     T8,
    typename     T9,
    typename     T10,
    typename...  TExtraParams,
    typename...  TExtraArgs>
bool MatchEventStackInMemberFunction(
    const EventStack&         eventStack,
    TInterface*               objectPtr,
    TReturn (TInterface::*    memberFunc)(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TExtraParams...),
    TExtraArgs&&...           extraArgs);

Parâmetros

TInterface
O tipo que contém a função de membro.

Turno
O tipo de retorno da função de membro.

T1, ..., T10
Os tipos que definem a hierarquia de eventos que correspondem.

TExtraParams
Os tipos de parâmetros extras aceitos pela função membro e os tipos de hierarquia de eventos.

TExtraArgs
Os tipos de argumentos extras que foram passados para MatchEventStackInMemberFunction.

eventStack
A pilha de eventos para corresponder à hierarquia de tipo de evento descrita por T1 a T10.

objectPtr
Um ponteiro para um objeto no qual memberFunc é chamado.

membroFunc
A função membro que descreve a hierarquia de tipos de eventos a corresponder.

extraArgs
Os argumentos que são perfeitamente encaminhados para memberFunc, juntamente com os parâmetros da hierarquia de tipos de eventos.

Valor de retorno

Um bool valor que é true caso a correspondência tenha sido bem-sucedida ou false caso contrário.

Observações

O último evento em eventStack é sempre comparado com a última entrada na hierarquia de tipo de evento. Todos os outros tipos na hierarquia de tipo de evento podem corresponder a qualquer posição no eventStack , exceto a última, desde que estejam na mesma ordem.

Os tipos de evento a serem usados para os parâmetros T1 a T10 são selecionados em uma lista de classes de captura. Para obter uma lista de eventos e as classes de captura que você pode usar para correspondê-los, consulte a tabela de eventos.

Exemplo

void MyClass::Foo1(Compiler cl, BackEndPass bep, C2DLL c2,
    CodeGeneration cg, Thread t, Function f) { }

void MyClass::Foo2(Compiler cl, Function f) { }

void MyClass::Foo3(Thread t, Compiler cl, Function f) { }

void MyClass::Foo4(Compiler cl) { }

void MyClass::OnStartActivity(const EventStack& eventStack)
{
    // Let's assume eventStack contains:
    // [Compiler, BackEndPass, C2DLL, CodeGeneration, Thread, Function]

    bool b1 = MatchEventStackInMemberFunction(
        eventStack, this, &MyClass::Foo1);

    bool b2 = MatchEventStackInMemberFunction(
        eventStack, this, &MyClass::Foo2);

    bool b3 = MatchEventStackInMemberFunction(
        eventStack, this, &MyClass::Foo3);

    bool b4 = MatchEventStackInMemberFunction(
        eventStack, this, &MyClass::Foo4);

    // b1: true because the parameter types of Foo1 match the eventStack
    //     exactly.
    // b2: true because Function is the last entry in both the member
    //     function parameter list and 'eventStack', and also because
    //     Compiler comes before Function in 'eventStack' and in the
    //     parameter type list.
    // b3: false because, even though both Thread and Compiler come
    //     before Function in 'eventStack', the member function parameter
    //     list doesn't list them in the right order.
    // b4: false because the last entry in the member function parameter
    //     list is Compiler, which doesn't match the last entry in 'eventStack'
    //     (Function).
}