Comment faire pour déterminer le type d'une variable?

je veux trouver le type d'une Variable (la variable est donnée par un paramètre du Modèle, donc je ne sais pas ce que c'est).

#include <iostream>
#include <typeinfo>

int main() 
{
    double test;
    std::cout << typeid(test).name() << std::endl;
}

Mais le Code ne dégage que:
$./test

d

mais j'aurais besoin de la double à la place.

Le point est, je ne sais pas quel type d'attendre, mais je dois l'écrire dans un sous-programme, qui as pour être compilé. Donc, d est une mauvaise idée.

  • Si c'est un paramètre du modèle, n'est-ce pas le paramètre le type lui-même?!
  • Il n'y a pas moyen de faire ce que vous voulez. Le nom de la représentation est définie par l'implémentation, et IIRC la mise en œuvre est permis de ne pas fournir une représentation à tous. Tout ce qui était dans le cas de types polymorphes seulement, bonne chance avec les types polymorphes.
  • Ma conjecture est que vous voulez faire quelque chose que vous n'avez pas expliqué. Pourquoi avez-vous besoin le type de nom? Je suis assez sûr qu'il y est un moyen de résoudre votre problème réel, plutôt que celui que vous avez demandé.
  • Vous devriez vraiment utiliser un exemple qui illustre votre problème. Dans l'exemple il n'y a pas n'importe quel modèle de paramètres, les principaux problèmes que vous voulez résoudre, n'est pas expliqué par l'exemple...
  • Je reçois l'essai par l'intermédiaire de modèle, donc je ne sais pas de quel type il est. Quelque chose comme template<test> ... j'ai utiliser le type de l'information plus tard lors de la compilation d'un opencl programme qui dans ce cas doit être fait au moment de l'exécution.
  • En regardant 5.2.8/3 dans mon projet de C++0x Standard, on dirait que vous êtes censé recevoir un std::type_info objet pour les non-polymorphe aussi des types. Bien sûr, pas tous les compilateurs de mettre en œuvre tous les détails de la Norme encore, et name() renvoie quelque chose de la mise en œuvre définies.
  • Si vous obtenez le type d'un paramètre du modèle que vous avez déjà le type là, n'est-ce pas?

InformationsquelleAutor cl_progger | 2011-11-23
  1. 2

    Dans GNU ABI, il y a un de l'aide pour demangle la name() d'un typeid

    Avertissement Dans le cas où il n'était pas évident, bien sûr GNU ABI prend uniquement en charge les demangling noms de la GNU ABI (et probablement même pas sauvagement les différentes versions). 

    #include <cxxabi.h>
#include <stdlib.h>
#include <string>

template <typename T> std::string nameofType(const T& v)
{
    int     status;
    char   *realname = abi::__cxa_demangle(typeid(v).name(), 0, 0, &status);
    std::string name(realname? realname : "????");
    free(realname);

    return name;
}
    • Là, maintenant, dans nifty wrapper c++ la fonction. Pour ma propre référence, au moins!
    • Ajoutez le fait que ce n'est pas portable à la description.
    • Eh bien, il est portable aussi loin que la GNU ABI est portable (2e et 3e mots, tous les chapeaux; difficile à manquer). Il ne peut pas travailler dans un zillion d'autres compilateurs. Ok, Va ajouter un peu une formulation plus forte ensuite.
    • Cela ressemble à une réponse qui pourrait être rarement collé à l'avenir des questions similaires 🙂 (au fait, avez-vous dire std::free?)
    • weehoo, j'ai eu beaucoup de confusion avec qui (sans doute les anciennes versions de GNU glibc/libstdc++ ne pas faire les choses correctement. Juste vérifié que je peux, aujourd'hui, l'utilisation std::* (cependant, y compris <cstdlib> ne permet de définir : libre sans le demander). De toute façon, fixe l'échantillon dans l'autre sens, pas besoin d'embrouiller les gens avec c++0x qui ne sont pas nécessaires ici 🙂
    InformationsquelleAutor sehe
  2. 3

    Si vous connaissez la liste des types qui doit être pris en charge, vous pouvez écrire votre propre fonction pour ce faire:

    template <typename T>
void printtype()
{
  if (typeid(T) == typeid(double))
    std::cout << "double";
  else if (typeid(T) == typeid(int))
    std::cout << "int";
}

    Avis que, puisque la fonction n'est pas un argument de type T, il doit toujours avoir le type a clairement dit:

    printtype<double>()

    et bien sûr, le type peut être un type de paramètre:

    printtype<U>()
    • De travail, mais je ne connais pas les types. Je sais qu'ils vont être composé de double, int et des chars, mais cela pourrait être un struct.
    InformationsquelleAutor John Gordon
  3. 2

    Vous pouvez essayer de forcer une erreur dans un modèle avec cette expression comme argument, et le message d'erreur compilateur aura le type que vous recherchez.

    Par exemple, à l'aide de GCC:

    #include <map>
#include <string>
template<typename T> void ErrorType(T &t)
{
char x[sizeof(t)==0 ? 1 : -1];
}
template<typename T> void ErrorType(const T &t)
{
char x[sizeof(t)==0 ? 1 : -1];
}
int main()
{
double d = 3;
const double cd = 3;
ErrorType(d);
ErrorType(cd);
ErrorType(3);
std::map<std::string, int> x;
ErrorType(x.begin());
}
$ g++ -c test.cpp
test.cpp: In function ‘void ErrorType(T&) [with T = double]’:
test.cpp:17:20:   instantiated from here
test.cpp:6:14: error: size of array is negative
test.cpp: In function ‘void ErrorType(const T&) [with T = double]’:
test.cpp:18:21:   instantiated from here
test.cpp:10:14: error: size of array is negative
test.cpp: In function ‘void ErrorType(const T&) [with T = int]’:
test.cpp:19:20:   instantiated from here
test.cpp:10:14: error: size of array is negative
test.cpp: In function ‘void ErrorType(const T&) [with T = std::_Rb_tree_iterator<std::pair<const std::basic_string<char>, int> >]’:
test.cpp:22:28:   instantiated from here
test.cpp:10:14: error: size of array is negative

    Donc les types de sous-évaluées sont double, int et std::_Rb_tree_iterator<std::pair<const std::basic_string<char>, int> >.
    La première surcharge est non-const, ce qui signifie que l'expression est un non-const l-valeur.

    L'astuce de sizeof(t)==0 est nécessaire pour rendre l'ensemble de l'expression dépend du paramètre du modèle, et de retarder l'erreur jusqu'à ce que l'instanciation. L'erreur elle-même (la taille du tableau est négatif) est, bien sûr, pas de sens.

    Et si vous êtes à l'aide de C++11, vous pouvez améliorer:

    #include <map>
#include <string>
template<typename T> void ErrorType(T &&t)
{
static_assert(sizeof(t)==0, "Reporting type name");
}
int main()
{
double d = 3;
const double cd = 3;
ErrorType(d);
ErrorType(cd);
ErrorType(3);
std::map<std::string, int> x;
ErrorType(x.begin());
}
$ g++ -c test.cpp  -std=gnu++0x
test.cpp: In function ‘void ErrorType(T&&) [with T = double&]’:
test.cpp:15:20:   instantiated from here
test.cpp:6:9: error: static assertion failed: "Reporting type name"
test.cpp: In function ‘void ErrorType(T&&) [with T = const double&]’:
test.cpp:16:21:   instantiated from here
test.cpp:6:9: error: static assertion failed: "Reporting type name"
test.cpp: In function ‘void ErrorType(T&&) [with T = int]’:
test.cpp:17:20:   instantiated from here
test.cpp:6:9: error: static assertion failed: "Reporting type name"
test.cpp: In function ‘void ErrorType(T&&) [with T = std::_Rb_tree_iterator<std::pair<const std::basic_string<char>, int> >]’:
test.cpp:20:28:   instantiated from here
test.cpp:6:9: error: static assertion failed: "Reporting type name"

    Comme un bonus supplémentaire, qui peut faire une différence entre const l-valeurs et r-valeurs. Le premier est un double l-valeur, la seconde un const double l-valeur et les deux autres sont des valeurs r.

    • bonne idée :-), mais pas pratique dans mon contexte
    InformationsquelleAutor rodrigo
  4. 1

    Remarque: La chaîne de caractères retournée par le nom du membre de type_info dépend de la
    spécifiques de mise en œuvre de votre compilateur et de la bibliothèque. Il n'est pas
    nécessairement une simple chaîne de caractères, avec ses typiques nom de type, comme dans l'
    compilateur utilisé pour produire cette sortie.

    Ce que notre compilateur retourné dans les appels type_info::nom de la ce
    par exemple, notre compilateur a généré des noms qui sont facilement compréhensibles
    par des humains, mais ce n'est pas une exigence: un compilateur peut juste retour
    n'importe quelle chaîne.

    Source: http://www.cplusplus.com/doc/tutorial/typecasting/

    Mon produit par GCC noms déformés. E. g. d pour double, j'ai pour int, c pour char et St6vectorIiSaIiEE pour std::vector<int>

    À partir de GCC typeinfo:

    /** Returns an @e implementation-defined byte string; this is not
*  portable between compilers!  */
const char* name() const
{ return __name[0] == '*' ? __name + 1 : __name; }

    --edit--

    Vous ne pouvez pas "renouvelable" obtenir le nom à travers les compilateurs. Si vous voulez faire exactement ce que vous devez coder en dur un peu comme John Gorden décrit dans son post.

    • Dois-je utiliser un compilateur drapeau de gcc? erreur: ‘__name’ n'a pas été déclarée dans ce champ d'application
    • Dans GGG vous pouvez demangle noms à l'aide d'un compilateur extension.
    • J'ai cité que des trucs de typeinfo-tête à mettre en évidence les phrases "la mise en œuvre définies" et "non portable". __nom est la mise en œuvre de typeinfo. N'essayez pas de l'utiliser.
    • bon à savoir. Mais pas portable, il pourrait être utile pour certains de débogage.
    • Assurez-vous. Je ne pense pas que vous besoin pour faire tout cela pour une bonne programmation, je ne suis pas vraiment sûr de ce que l'OP veut être honnête.
    • Ouais.. il a mentionné quelque chose abt passer cette info à certains opencl ou quelque chose, mais je suppose qu'il a obtenu sa réponse ("pas possible de façon portable"), donc il a quitté le bâtiment.. 🙂 personnellement, je ne vois pas d'autre utilisation que le débogage de votre propre modèle de code.
    • Eh bien, je n'ai pas quitté le bâtiment complètement :-). Malheureusement, OpenCL Code n'est pas compilé par gcc, mais par son propre compilateur. Donc gcc sait que le type double, mais depuis l'opencl code est dans un autre fichier, je ne sais pas comment l'obtenir à travers.

    InformationsquelleAutor Kashyap