C++ Obtenir le nom du type, modèle

Je suis en train d'écrire certaines classes de modèle pour parseing certains fichiers de données texte, et en tant que tel, il est likly la grande majorité des erreurs d'analyse vont être due à des erreurs dans le fichier de données, qui sont pour la plupart écrits par des programmeurs, et donc besoin d'un gentil message sur les raisons de l'application a échoué à charge par exemple quelque chose comme:

Erreur d'analyse example.txt. Valeur ("notaninteger")de [MySectiom]Clé n'est pas valide int

Je peux travailler sur le fichier, l'article et les noms de clés à partir d'arguments passés à la fonction de modèle et membre de vars dans la classe, mais je ne suis pas sûr de la façon d'obtenir le nom du type de la fonction de modèle est d'essayer de convertir de.

Mon code actuel ressemble, avec des spécialités pour de simples chaînes de caractères et tel:

template<typename T> T GetValue(const std::wstring &section, const std::wstring &key)
{
    std::map<std::wstring, std::wstring>::iterator it = map[section].find(key);
    if(it == map[section].end())
        throw ItemDoesNotExist(file, section, key)
    else
    {
        try{return boost::lexical_cast<T>(it->second);}
        //needs to get the name from T somehow
        catch(...)throw ParseError(file, section, key, it->second, TypeName(T));
    }
}

Id plutôt pas des surcharges pour chaque type que les fichiers de données peuvent utiliser, puisqu'il y a des tas d'entre eux...

Aussi j'ai besoin d'une solution qui n'engage pas de gestion d'exécution, sauf si une exception se produit, c'est à dire une compilation complète d'une solution en temps est ce que je veux puisque ce code est appelé tonnes de fois et de temps de chargement sont déjà à faire un peu long.

EDIT: Ok c'est la solution je suis venu avec:

J'ai un types.h contient les éléments suivants

#pragma once
template<typename T> const wchar_t *GetTypeName();

#define DEFINE_TYPE_NAME(type, name) \
    template<>const wchar_t *GetTypeName<type>(){return name;}

Alors je peux utiliser le DEFINE_TYPE_NAME macro au rpc fichiers pour chaque type j'ai besoin de traiter (par exemple, dans le fichier cpp qui ont défini le type de départ).

L'éditeur de liens est alors en mesure de trouver la appropirate modèle de spécialisation, tant qu'il a été défini quelque part, ou de jeter un linker error autrement de sorte que je peux ajouter le type.

pas vraiment pertinentes à votre question, mais vous pourriez vouloir utiliser la carte.trouver(section) lors de l'accès à la section aswell, sauf si vous souhaitez volontairement pour créer une section vide.

InformationsquelleAutor Fire Lancer | 2009-06-28

c++compile-time templates typename

35

Jesse Beder la solution est probablement la meilleure, mais si vous n'aimez pas les noms typeid vous donne (je pense que gcc vous donne les noms déformés par exemple), vous pouvez faire quelque chose comme:
```
template<typename T>
struct TypeParseTraits;

#define REGISTER_PARSE_TYPE(X) template <> struct TypeParseTraits<X> \
    { static const char* name; } ; const char* TypeParseTraits<X>::name = #X


REGISTER_PARSE_TYPE(int);
REGISTER_PARSE_TYPE(double);
REGISTER_PARSE_TYPE(FooClass);
//etc...
```
Et de l'utiliser ensuite comme
```
throw ParseError(TypeParseTraits<T>::name);
```
EDIT:

Vous pouvez également combiner les deux, changement name à une fonction qui, par défaut, les appels typeid(T).name() et ensuite seulement de se spécialiser dans les cas où ce n'est pas acceptable.
- Note: Ce code ne compilera pas si vous oubliez de définir REGISTER_PARSE_TYPE pour un type que vous utilisez. J'ai utilisé une astuce similaire avant (dans le code sans RTTI) et il a très bien fonctionné.
- J'ai dû déplacer le nom en dehors de la structure dans g++ 4.3.0, en raison des "erreur: invalid initialisation dans les classes de donnée membre statique de non-intégré de type 'const char *'"; et, bien sûr, le mot-clé 'struct' est nécessaire entre <>, et TypeParseTraits et la définition doit être terminé par un point-virgule.
- Eh bien, le laissant le point-virgule était volontaire, pour vous forcer à l'utiliser à la fin de la macro invocation, mais merci pour les corrections.
- Je obtenir le lien suivant erreur: error: '#' is not followed by a macro parameter
- c'est parce qu'à la fin de '#x' doit être '#X' (majuscule pour correspondre paramètre de la macro) - je vais corriger la réponse.
InformationsquelleAutor Logan Capaldo
60

La solution est
```
typeid(T).name()
```
qui renvoie std::type_info.
- Gardez à l'esprit qu'il est conforme à retourner à la chaîne pour chaque type (bien que je ne pense pas qu'un compilateur pourrait le faire).
- Ou de retourner une chaîne de caractère pour le même type sur les différentes exécutions... (encore une fois non pas que je pense que toute sane compilateur pourrait le faire).
- Je voudrais juste souligner la laideur donné le nom peut être: typeid(simd::double3x4).name() = "N4simd9double3x4E". typeid(simd::float4).name() = "Dv4_f" C++17, Xcode 10.1.
InformationsquelleAutor Jesse Beder
39

typeid(T).name() la mise en œuvre est définie et ne garantit pas lisible par les humains à la chaîne.

Lecture cppreference.com :

Renvoie une mise en œuvre défini de caractères terminée par null string
contenant le nom du type. Aucune garantie n'est donnée, dans
en particulier, la chaîne retournée peuvent être identiques pour plusieurs types et
le changement entre les appels du même programme.

...

Avec les compilateurs comme gcc et clang, la chaîne retournée peuvent être transmis par le biais de c++filt -t être converti en une forme lisible.

Mais dans certains cas, gcc n'a pas de droit de retour de la chaîne. Par exemple sur ma machine j'ai le gcc avec -std=c++11 et à l'intérieur du modèle de la fonction typeid(T).name() retourne "j" pour "unsigned int". C'est donc appelé déformés nom. Pour prendre un vrai nom de type, l'utilisation
abi::__cxa_demangle() fonction (gcc uniquement):
```
#include <string>
#include <cstdlib>
#include <cxxabi.h>

template<typename T>
std::string type_name()
{
    int status;
    std::string tname = typeid(T).name();
    char *demangled_name = abi::__cxa_demangle(tname.c_str(), NULL, NULL, &status);
    if(status == 0) {
        tname = demangled_name;
        std::free(demangled_name);
    }   
    return tname;
}
```
- Ce fonctionne réellement pour clang ainsi que gcc.
- N'est-il pas de fuite de mémoire pour avoir free dans if?
- Non, parce que le pointeur pointe vers nullptr si le statut n'est pas 0.
- Je tiens à ajouter qu'il est probablement préférable de vérifier pour gcc ou clang existence et si pas de défaut de ne pas faire la demangling comme ici.
InformationsquelleAutor Bunkar
18

Comme mentionné par Bunkar typeid(T).nom de la mise en œuvre est définie.

Pour éviter ce problème, vous pouvez utiliser Coup de pouce.TypeIndex bibliothèque.

Par exemple:
```
boost::typeindex::type_id<T>().pretty_name() //human readable
```
- Ceci est très utile pour trouver des modèles de noms de type lorsque les fonctions sont appelées. Cela a fonctionné assez bien pour moi.
- Notez que pretty_name() ou raw_name() est toujours définie par l'implémentation. Sur MSVC pour une struct Un; vous obtiendrez : "struct" alors que sur gcc/clang : "Une".
- wow. boost de nouveau pour la victoire. incroyable ce boost ne sans prise en charge du compilateur (auto, regex, foreach, threads, static_assert, etc, etc... le support avant de compilateurs/C++-support de la norme).
InformationsquelleAutor Andrey

La réponse de Logan Capaldo est correct, mais peut être légèrement simplifiée, car il est inutile de se spécialiser la classe de tous les temps. On peut écrire:

//in header
template<typename T>
struct TypeParseTraits
{ static const char* name; };

//in c-file
#define REGISTER_PARSE_TYPE(X) \
    template <> const char* TypeParseTraits<X>::name = #X

REGISTER_PARSE_TYPE(int);
REGISTER_PARSE_TYPE(double);
REGISTER_PARSE_TYPE(FooClass);
//etc...

Cela vous permet également de mettre le REGISTER_PARSE_TYPE instructions dans un fichier C++...

InformationsquelleAutor rhomu

Comme la reformulation de Andrey réponse:

La Boost TypeIndex bibliothèque peut être utilisée pour imprimer les noms de types.

À l'intérieur d'un modèle, ce qui pourrait se lire comme suit

#include <boost/type_index.hpp>
#include <iostream>

template<typename T>
void printNameOfType() {
    std::cout << "Type of T: " 
              << boost::typeindex::type_id<T>().pretty_name() 
              << std::endl;
}

InformationsquelleAutor chrisb2244

Je viens de l'y laisser.
Si quelqu'un va en avoir besoin, alors vous pouvez utiliser ceci:

template <class T>
bool isString(T* t) { return false;  } //normal case returns false

template <>
bool isString(char* t) { return true; }  //but for char* or String.c_str() returns true
.
.
.

Cela ne fera que VÉRIFIER le type de ne pas l'OBTENIR et uniquement pour le type 1 ou 2.

InformationsquelleAutor Xar

Si vous souhaitez un pretty_name, Logan Capaldo, la solution ne peut pas traiter avec structure de données complexes: REGISTER_PARSE_TYPE(map<int,int>)
et typeid(map<int,int>).name() me donne un résultat de St3mapIiiSt4lessIiESaISt4pairIKiiEEE

Il y a une autre réponse intéressante à l'aide de unordered_map ou map vient de https://en.cppreference.com/w/cpp/types/type_index.

#include <iostream>
#include <unordered_map>
#include <map>
#include <typeindex>
using namespace std;
unordered_map<type_index,string> types_map_;

int main(){
    types_map_[typeid(int)]="int";
    types_map_[typeid(float)]="float";
    types_map_[typeid(map<int,int>)]="map<int,int>";

    map<int,int> mp;
    cout<<types_map_[typeid(map<int,int>)]<<endl;
    cout<<types_map_[typeid(mp)]<<endl;
    return 0;
}

InformationsquelleAutor Voyager

Vous devez vous connecter pour publier un commentaire.