Função variádica sem o primeiro parâmetro especificado?
-
08-07-2019 - |
Pergunta
Por curiosidade, pensei em tentar escrever uma classe C ++ básica que imite o padrão de delegado múltiplo de C#. O código abaixo faz principalmente o trabalho, com o sacrifício desagradável de perder quase todo o tipo de segurança, mas ter que usar o parâmetro dummy inicial para configurar a lista VA_List realmente parece um pouco fora. Existe uma maneira de usar o va_list sem isso? Sei que existem maneiras de fazer isso com (por exemplo) Boost, mas eu estava buscando algo simples que usava apenas a biblioteca padrão.
#include <vector>
#include <iostream>
#include <string>
#include <stdarg.h>
#include <algorithm>
using namespace std;
class CDelegate
{
public:
virtual bool operator()(va_list params) = 0;
};
class CMultipleDelegateCaller
{
public:
typedef vector<CDelegate*> CDelegateVector;
CMultipleDelegateCaller& operator+=(CDelegate &rDelegate)
{
m_apDelegates.push_back(&rDelegate);
return (*this);
}
CMultipleDelegateCaller& operator-=(CDelegate &rDelegate)
{
CDelegateVector::iterator iter =
find(m_apDelegates.begin(), m_apDelegates.end(), &rDelegate);
if (m_apDelegates.end() != iter) m_apDelegates.erase(iter);
return (*this);
}
bool Call(int iDummy, ...)
{
va_list params;
CDelegate* pDelegate;
CDelegateVector::iterator iter;
for (iter = m_apDelegates.begin(); iter != m_apDelegates.end(); ++iter)
{
pDelegate = *iter;
va_start(params, iDummy);
if (!(*pDelegate)(params)) return false;
va_end(params);
}
return true;
}
private:
CDelegateVector m_apDelegates;
};
class CTestDelegate:
public CDelegate
{
public:
CTestDelegate():m_iId(++s_iCount) {}
virtual bool operator()(va_list params)
{
int iIntParam = va_arg(params, int);
char* szCharPtrParam = va_arg(params, char*);
string* psStringParam = va_arg(params, string*);
cout<<m_iId<<"{"
<<iIntParam<<", "
<<szCharPtrParam<<", "
<<*psStringParam<<"}"<<endl;
return true;
}
int m_iId;
static int s_iCount;
};
int CTestDelegate::s_iCount = 0;
int main(int argc, char* argv[])
{
CMultipleDelegateCaller cDelegateCaller;
CTestDelegate cTestDelegate1;
CTestDelegate cTestDelegate2;
cout<<"--------------------"<<endl;
cDelegateCaller += cTestDelegate1;
cDelegateCaller += cTestDelegate2;
string sString("World");
cDelegateCaller.Call(1, 2, "Hello", &sString);
cout<<"--------------------"<<endl;
cDelegateCaller -= cTestDelegate1;
cDelegateCaller.Call(1, 2, "Hello", &sString);
cout<<"--------------------"<<endl;
cDelegateCaller -= cTestDelegate2;
cDelegateCaller.Call(1, 2, "Hello", &sString);
cout<<"--------------------"<<endl;
cin>>sString;
return 0;
}
Solução
Funções com elipsis em C ++ são apenas para compatibilidade com C. usando C ++ eu retornaria o objeto Helper temporário em Call
função e adicione modelo operator%
passar o número variável de argumentos. Para usá -lo da seguinte maneira:
cDelegateCaller.Call() % 2 % "Hello" % sString; // dummy argument isn't required
Quanto à sua pergunta, o padrão exige invocar va_start
antes de qualquer acesso aos argumentos sem nome. E va_start
requer o segundo argumento, que é o identificador do parâmetro mais à direita na lista de parâmetros da variável na definição da função.
Outras dicas
Fora de Resposta de Kirill Você pode concluir que é possível criar um delegado seguro, usando uma função de combinação de argumentos de modelo. Esta função também Precisa de um ponto de partida fictício, mas tem o benefício da segurança do tipo.
A biblioteca FastFormat usa isso, Boost usa isso, e eu uma vez forneci outro exemplo em um responda para outra pergunta.