Fornecedores de Serviços C ++

Question

Fui aprendendo C ++, vindo de C #, onde eu me acostumei a usar prestadores de serviços: basicamente um Dictionary . Infelizmente, eu não consigo descobrir como fazer isso em C ++. Assim, as perguntas são basicamente:

1. Como eu faria um dicionário em C ++.

2. Como eu usaria 'Tipo' com ele, tanto quanto eu sei que não há 'Tipo' em C ++.

3. Mesmo que acima, mas com 'objeto'.

Obrigado!

Answer 1

Eu estou assumindo que você está tentando mapear um tipo a uma única instância do objeto. Você poderia tentar algo ao longo destas linhas:

#include <typeinfo>
#include <map>
#include <string>
using namespace std;

class SomeClass
{
public:
    virtual ~SomeClass() {} // virtual function to get a v-table
};

struct type_info_less
{
    bool operator() (const std::type_info* lhs, const std::type_info* rhs) const
    {
        return lhs->before(*rhs) != 0;
    }
};

class TypeMap
{
    typedef map <type_info *, void *, type_info_less> TypenameToObject;
    TypenameToObject ObjectMap;

public:
    template <typename T> 
    T *Get () const
    {
        TypenameToObject::const_iterator iType = ObjectMap.find(&typeid(T));
        if (iType == ObjectMap.end())
            return NULL;
        return reinterpret_cast<T *>(iType->second);
    }
    template <typename T> 
    void Set(T *value) 
    {
        ObjectMap[&typeid(T)] = reinterpret_cast<void *>(value);
    }
};

int main()
{
    TypeMap Services;
    Services.Set<SomeClass>(new SomeClass());
    SomeClass *x = Services.Get<SomeClass>();
}

tipos em C ++ não são de primeira classe objetos em seu próprio direito, mas pelo menos o nome do tipo vai ser original, assim você pode digitar por isso.

Edit:. Os nomes não são realmente garantido para ser original, assim que segurar a type_info ponteiros e usar o método antes de compará-los

Answer 2

Você provavelmente vai querer olhar para o STL modelo de mapa . C ++ certamente tem tipos (difícil ter herança sem ele), apenas nenhum específico definido "Tipo" de classe.

Answer 3

O STL tem dois recipientes associativas: std::map<K,V> andstd :: multimap. Há também std::set<V> que deve ser um adaptador de std::map<V,void>, mas como tal, não é um recipiente associativo. O multimap é semelhante ao mapa, só que permite que várias chaves idênticas dentro do mesmo recipiente. Ambos mapa e elementos de retenção MultiMap do tipo std::pair<K,V>. Em outras palavras, std::map<K,V>::value_type == std::pair<K,V>, mas std::map<K,V>::key_type == K e std::map<K,V>::mapped_type == V.

Quanto a "Tipo", eu não sou inteiramente certo o que você quer dizer. Se você quer dizer as classes parametrizadas em seguida, C ++ chama isso de "Programação de modelo", ou "programação genérica". No exemplo acima, é parametrizada std::map<K,V> sobre K e V para tipo e os valores as chaves tipo. C ++ também suporta funções de modelo:

template<typename T>
void f(T o);

irá declarar uma função que recebe como parâmetro qualquer tipo em tudo, incluindo tipos primitivos. C ++ não apoiar a resolução de tipo genérico, de modo que o mosto tipo T de certa hierarquia. Por enquanto, tudo o que você pode fazer é apenas supor o tipo passado é de fato da hierarquia correto, eo compilador vai reclamar se você tentar chamar uma função não-declarada sobre um objeto desse tipo.

template<typename T>
void f(T o) {
    o.do_it();
}

O trabalho vontade acima enquanto T define a do_it() método.

Answer 4

A sons dicionário como um mapa STL para mim: std::map<K, T>. Ter um olhar para o Standard Template Library - é brilhante. Tem sido parte de ANSI C ++ por um tempo. Microsoft tem uma boa implementação da PJ Plauger, se bem me lembro.