Em c # eu posso escrever algo assim:

    class AnyThing<T>
    {
        static public T Default = default(T);
    }

    static void Main ()
    {
        int i = AnyThing<int>.Default;
        Console.WriteLine (i==0);
        string s = AnyThing<string>.Default;
        Console.WriteLine (s == null);

    }

Eu pretendo escrever um dicionário como classe de modelo em C ++, eu gostaria que o dict retornasse o valor padrão (zero out) do tipo TVal genérico se a chave dada não fosse encontrada. Em C # a construção padrão (T) vem para resgatar, enquanto em C ++ não tenho certeza qual é a maneira apropriada de fazer a mesma coisa.

eu tenteiT obj = {} eT* obj = {} com gcc4.7, funciona bem. Eu não estou tão certo se é a sintaxe definida pela especificação da linguagem, se esse tipo de código for compiladores e plataformas cruzadas portáveis. Por favor me ajude com meu doudt! Desde já, obrigado!

PS:

~~~~~~~~~~

Para garantir que o template obtenha o valor padrão (zero out) de QUALQUER tipo, mesmo daqueles que não possuem o padrão de callable, usei o seguinte mecanismo (inspirado na resposta do avakar):

template<class T>
struct AnyThing
{
    static const T& Default ;
private:
    static const char temp[sizeof(T)];
};

template<class T> const char AnyThing<T>::temp[] = {};
template<class T> const T& AnyThing<T>::Default =  *(T*)temp;

struct st
{
    double data;
    st()=delete;
};

int main()
{
    cout << (int)AnyThing<char*>::Default<<endl;    //0
    cout << AnyThing<int>::Default<<endl;       //0
    cout <<AnyThing<st>::Default.data<<endl;        //0
}

Parece feio, mas não deve causar nenhum problema, afinal um objeto zerado é apenas um pedaço de memória em branco. Estou errado?