Wie finden Sie heraus, den Typ einer Variablen?

ich möchte, um herauszufinden, den Typ einer Variable (die variable ist gegeben durch eine Template-parameter, also ich weiß nicht, was es ist).

#include <iostream>
#include <typeinfo>

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

Aber der Code, der nur strahlt:
$./test

aber ich bräuchte Doppel statt.

Der Punkt ist, ich weiß nicht, welcher Typ zu erwarten ist, aber ich Schreibe es in ein Unterprogramm, das hast kompiliert werden. Also d ist eine schlechte Idee.

Wenn es ein template-parameter ist nicht, dass die parameter der Typ selbst?!
Es gibt keine standard-Weg, um zu tun, was Sie wollen. Der name der Vertretung, ist von der Implementierung definiert, und IIRC die Umsetzung darf nicht auf eine Vertretung in allen. All das war im Fall von polymorphen Typen nur, Glück mit nicht-polymorphe Typen.
Meine Vermutung ist, dass Sie etwas tun wollen, die Sie noch nicht erklärt. Warum müssen Sie den Namen eingeben? Ich bin mir ziemlich sicher, dass es einen Weg zur Lösung Ihres eigentlichen Problems, sondern als die, die Sie gestellt haben.
Sie sollten sich wirklich ein Beispiel, das zeigt Ihr problem. Im aktuellen Beispiel gibt es keine template-Parameter, also die wichtigsten Probleme, die Sie lösen wollen, wird nicht erläutert durch das Beispiel...
Ich bekomme test über die Vorlage, also ich weiß nicht, welche Art es ist. So etwas wie Vorlage<test> ... ich habe mit der Art Informationen, die später bei der Erstellung eines opencl-Programm, das in diesem Fall getan werden muss, zur Laufzeit.
Betrachten 5.2.8/3 in meinem Entwurf des C++0x-Standard, es sieht aus wie Sie sollen, um eine std::type_info Objekt für nicht-polymorphe Typen auch. Natürlich, nicht alle Compiler implementieren, die jedes detail der Standard noch, und name() etwas zurückgibt, Implementierung-definiert.
Wenn Sie den Typ als template-parameter haben Sie bereits die Art genau dort, haben Sie nicht?

InformationsquelleAutor cl_progger | 2011-11-23

c++types

2

In GNU ABI, es ist ein Helfer demangle die name() einer typeid

Haftungsausschluss In Fall war es nicht offensichtlich, natürlich der GNU-ABI unterstützt nur demangling Namen aus der GNU-ABI (und vermutlich auch nicht sehr unterschiedlichen Versionen).
```
#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;
}
```
- Da, jetzt in nifty c++ - wrapper-Funktion. Für meine eigene Referenz, mindestens!
- Fügen Sie die Tatsache, dass es nicht tragbar zu Beschreibung.
- Gut, es ist tragbar, so weit wie das GNU-ABI ist portable (2nd-und 3rd-Wörter, Großbuchstaben; schwer zu verfehlen). Es will einfach nicht funktionieren unter einer Unmenge anderer Compiler. Ok, ein bisschen stärkere Formulierung dann.
- Das sieht aus wie eine Antwort sein könnte selten eingefügt in Zukunft ähnliche Fragen 🙂 (By the way, meinst du std::free?)
- weehoo, habe ich sehr viel Verwirrung mit sich, dass (vermutlich ältere Versionen von GNU glibc/libstdc++ nicht, die Dinge richtig. Gerade überprüft, dass ich heutzutage verwenden std::* (jedoch einschließlich <cstdlib> konnte definieren ::frei ohne Aufforderung). Wie auch immer, fest der Probe den anderen Weg herum, keine Notwendigkeit, verwirrend Menschen mit "c++0x" das ist nicht nötig 🙂
InformationsquelleAutor sehe
3

Wenn Sie wissen, die Liste der Arten, die unterstützt werden muss, Sie können schreiben Sie Ihre eigene Funktion, um dies zu tun:
```
template <typename T>
void printtype()
{
  if (typeid(T) == typeid(double))
    std::cout << "double";
  else if (typeid(T) == typeid(int))
    std::cout << "int";
}
```
Bemerken, dass, da die Funktion nicht, haben Sie ein argument vom Typ T, es muss immer der Typ explizit angegeben:
```
printtype<double>()
```
und natürlich, der Typ könnte ein parameter Typ:
```
printtype<U>()
```
- Arbeiten, aber ich weiß nicht, den Typen. Ich weiß, dass Sie aus Doppel -, int-und float, aber es könnte einer struct.
InformationsquelleAutor John Gordon

Können Sie versuchen zu zwingen, einen Fehler in einer Vorlage mit, dass dieser Ausdruck als ein argument, und die compiler-Fehlermeldung über die Art, die Sie suchen.

Z.B. mit 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

Also die Typen, die weggeworfen werden double, int und std::_Rb_tree_iterator<std::pair<const std::basic_string<char>, int> >.
Die erste überladung ist non-const, was bedeutet, dass der Ausdruck eine nicht-const l-value.

Den trick sizeof(t)==0 ist nötig, um den gesamten Ausdruck abhängig von dem template-parameter, und verzögern den Fehler bis Instanziierung. Der Fehler selbst (Größe des Arrays ist negativ) ist natürlich sinnlos.

Und wenn Sie mit C++11, die Sie verbessern können:

#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"

Als extra-bonus kann machen den Unterschied zwischen const l-Werte und r-Werte. Die erste ist eine double l-Wert, der zweite ein const double l-Wert und die anderen beiden sind r-Werte.

gute Idee :-), aber unpraktisch in meinen Kontext

InformationsquelleAutor rodrigo

1

Hinweis: Die zurückgegebene Zeichenfolge den Namen der type_info hängt von der
konkrete Umsetzung Ihrer compiler und Bibliothek. Es ist nicht
unbedingt eine einfache Zeichenfolge mit seiner typischen Art Namen, wie in der
compiler verwendet, um zu produzieren diese Ausgabe.

Was unseren compiler wieder in die Anrufe type_info::name in dieser
Beispiel, unseren compiler generierten Namen, der leicht verständlich
von den Menschen, aber dies ist nicht eine Voraussetzung: ein compiler kann nur zurückgeben
eine beliebige Zeichenfolge.

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

Mein GCC erzeugt entstellte. E. g. d für double ich für int c für char und St6vectorIiSaIiEE für std::vector<int>

Vom 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--

Kann man nicht "wiederholbar" Holen Sie sich die Namen über Compiler. Wenn Sie wollen, um genau das zu tun, müssen Sie hartcodieren ein bisschen wie John Gordon beschreibt in seinem Beitrag.
- Benötige ich einen speziellen compiler-Flags in gcc? Fehler: '__name' wurde nicht deklariert, in diesem Umfang
- In der GGG können Sie demangle Namen mit einer compiler-Erweiterung.
- Ich zitierte das Zeug aus Typinformation-header zu markieren, Sätze "implementation-defined" und "nicht tragbar". __- name ist, ist die Implementierung von Typinformation. Versuchen Sie nicht, es zu benutzen.
- gut zu wissen. Obwohl nicht tragbar, es könnte nützlich sein, für einige debugging.
- Sicher. Ich glaube nicht, dass du müssen zu tun, einer dieser für die ordnungsgemäße Programmierung; ich bin mir nicht wirklich sicher, was der OP will, um ehrlich zu sein.
- Ja.. er hat so etwas erwähnen abt Weitergabe dieser info auf einige opencl oder sowas, aber ich denke mal er hat seine Antwort bekommen ("nicht möglich portabel"), so dass er das Gebäude verlassen hat.. 🙂 ich persönlich sehe keine andere Verwendung als debugging-eigenen template-code.
- Glaube ich auch nicht, verließ das Gebäude komplett :-). Leider OpenCL-Code wird nicht kompiliert mit gcc, nun aber durch den eigenen compiler. Also gcc weiß, dass der Typ ist doppelt, aber da der opencl-code in einer anderen Datei, ich weiß nicht, wie man es über.
InformationsquelleAutor Kashyap

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.