derzeit:

string getID() { return T::ID; }

besser wäre sowas wie:

string getID() { return trypeID(T).name(); }

problem: ich schreibe damit dateien raus, die ich auf diversen systemen einlesen muss. und aus irgendeinem grund ist z.B. unter Linux das ergebnis der klasse "Test" = "ATest" und unter windows (vc) ="Test"
--> nicht das gewünschte ergebnis

soweit ich weiß, sind diese Typinformationen selbst nicht standardisiert => Jeder Compiler darf machen, was er will.
Aber immerhin kannst Du es auch selbst machen ... dann hast Du natürlich ein "compiler- und plattformübergreifendes System".

Gruß,

Simon2.

derzeit muss ich meine Klassen immer um folgende elemente erweitern, damit ich das creator template nutzen kann:

class A{
public:
const static std::string objectTypeID;
static A* create() { return new A(); }
virtual std::string getObjectTypeID() { return A::objectTypeID; }

};

und eigentlich finde ich es etwas lästig. da wäre mir so eine "automatische" typerkennung recht lieb.

was genau meinst du mit selber machen?...

Genau das, was Du da tust.
"Lästig" aber IIRC die einzige portable/zuverlässige Möglichkeit.
Vielleicht wird das mit einem neuen Standard ja anders ....

Gruß,

Simon2.

oh man. ja, da kommt mal wohl nicht drum rum...

Ist halt eine Folge davon, dass in C++ eigentlich gar keine technischen Formate spezifiziert sind...
Vielleicht ist man da mit der "Optimierungsmöglichkeit für Plattformen" ein wenig zu weit gegangen ... oder man hätte sich einen "ABI-" und einen "native-Modus" ausdenken können. Letztlich haben sie halt eine Programmiersprache spezifiziert und kein Programmierprodukt... aber ein wenig "Kompatibilität" hätte wohl gut getan (und wenn man nur fordert, dass typeid() auf allen Plattformen vergleichbare Ergebnisse liefert)....

Gruß,

Simon2.

Ich denke auch, das niemand typeid benutzt, außer für Debug-Ausgaben oder um einen what-Exception-String etwas informativer zu gestalten. Funktional ist das Ding nutzlos.

wieso? wenn man einen pointer auf die basisklasse hat und wissen will, wissen auf wen der wirklich zeigt, ist 'typeid' doch gut zu gebrauchen.

wieso? wenn man einen pointer auf die basisklasse hat und wissen will, wissen auf wen der wirklich zeigt, ist 'typeid' doch gut zu gebrauchen.

Ich gebe da Artchi Recht! Was net ( ) sagt deutet auf ein Design Fehler hin. Mach mir mal ein Beispiel mit typeId und ich mache daraus eins ohne

Mach mir mal ein Beispiel mit typeId und ich mache daraus eins ohne

#include <iostream>
#include <typeinfo>
#include <vector>
using namespace std;

class B {public:virtual ~B(){}};
class X : public B {};
class Y : public B {};

vector<B*> vec;

int main()
{
    int s;
    for (s=0; s<10; s++)
    {
        switch (rand()%3)
        {
            case 0:
            vec.push_back (new B);
            break;

            case 1:
            vec.push_back (new X);
            break;

            case 2:
            vec.push_back (new Y);
            break;    
        }
    }

    for (s=0; s<10; s++)
        cout << typeid(*vec[s]).name() << " -->\t" 
             << (typeid(*vec[s])==typeid(B)) << '\t' 
             << (typeid(*vec[s])==typeid(X)) << '\t'
             << (typeid(*vec[s])==typeid(Y)) 
             << endl;
}

Ich gebe da Artchi Recht! Was net ( ) sagt deutet auf ein Design Fehler hin. Mach mir mal ein Beispiel mit typeId und ich mache daraus eins ohne

#include <typeinfo>
#include <iostream>
#include <limits>
#include <string>
using namespace std;

template< class T >
void bombensicher( T &a )
{
	string str = "Bitte geben Sie ";

	if ( typeid( a ) == typeid( double ) )
	{
		str += "eine Zahl ein: ";
	}

	if ( typeid( a ) == typeid ( char) )
	{
		str += "ein Zeichen ein: ";
	}

	if ( typeid( a ) == typeid ( string ) )
	{
		str += "eine Zeichenkette ein: ";
	}

	cout << str;

	while( !( cin >> a ) )
	{
		cin.clear();
		cin.ignore(numeric_limits<streamsize>::max(),'\n'); 
	    cout << endl << "Fehlerhafte eingabe! " << endl << str;
	}

	cin.ignore(numeric_limits<streamsize>::max(),'\n');
}

int main()
{    
	double	d = 0;
	char	c = 0;
	string  s ;

	bombensicher( d );
	cout << d << endl;

	bombensicher( c );
	cout << c << endl;

	bombensicher( s );
	cout << s << endl;

	return 0;
}

proggingmania schrieb:

#include <typeinfo>
#include <iostream>
#include <limits>
#include <string>
using namespace std;

template< class T >
void bombensicher( T &a )
{
	string str = "Bitte geben Sie ";

	if ( typeid( a ) == typeid( double ) )
	{
		str += "eine Zahl ein: ";
	}

	if ( typeid( a ) == typeid ( char) )
	{
		str += "ein Zeichen ein: ";
	}

	if ( typeid( a ) == typeid ( string ) )
	{
		str += "eine Zeichenkette ein: ";
	}
	
	cout << str;

	while( !( cin >> a ) )
	{
		cin.clear();
		cin.ignore(numeric_limits<streamsize>::max(),'\n'); 
	    cout << endl << "Fehlerhafte eingabe! " << endl << str;
	}

	cin.ignore(numeric_limits<streamsize>::max(),'\n');
}

int main()
{    
	double	d = 0;
	char	c = 0;
	string  s ;
	
	bombensicher( d );
	cout << d << endl;
	
	bombensicher( c );
	cout << c << endl;
	
	bombensicher( s );
	cout << s << endl;

	return 0;
}

Sowas würde kein C++ Programmierer schreiben, ein paar überladene Funktionen und gut is die Sache ...

Vllt nen schönes OO - Beispiel, wo jemand denkt er käme ohne typeid nicht aus.

(hoffentlich habe ich mir nicht selber ne Grube gegraben )

Ein Beispiel das auch Sinn macht, wo du auf unterschiedliche Typen unterschiedlich reagieren musst

musste nur etwas abändern...

#include <iostream>
#include <typeinfo>
#include <vector>
using namespace std;

class B {public:virtual ~B(){}};
class X : public B {public:void f(){cout<<"hello B"<<endl;}};
class Y : public B {};

vector<B*> vec;

int main()
{
    int s;
    for (s=0; s<10; s++)
    {
        switch (rand()%3)
        {
            case 0:
            vec.push_back (new B);
            break;

            case 1:
            vec.push_back (new X);
            break;

            case 2:
            vec.push_back (new Y);
            break;    
        }
    }

    for (s=0; s<10; s++)
        if (typeid(*vec[s]) == typeid(X))  // nur X hat f() ;)
            ((X*)vec[s])->f();
}

Artchi schrieb:

Ich denke auch, das niemand typeid benutzt, außer für Debug-Ausgaben oder um einen what-Exception-String etwas informativer zu gestalten. Funktional ist das Ding nutzlos.

wieso? wenn man einen pointer auf die basisklasse hat und wissen will, wissen auf wen der wirklich zeigt, ist 'typeid' doch gut zu gebrauchen.

Verstehe nur Bahnhof...

Sowas würde kein C++ Programmierer schreiben, ein paar überladene Funktionen und gut is die Sache ...

Geht nicht, zu wenig RAM.

pale dog schrieb:

wieso? wenn man einen pointer auf die basisklasse hat und wissen will, wissen auf wen der wirklich zeigt, ist 'typeid' doch gut zu gebrauchen.

Ich gebe da Artchi Recht! Was net ( ) sagt deutet auf ein Design Fehler hin. Mach mir mal ein Beispiel mit typeId und ich mache daraus eins ohne

Mußte über diese Antwort seeehr lange nachdenken. Aber jetzt verstehe ich den ganzen unsinnigen geposteten Code.

Ich habe nicht gesagt, das man typeid nicht gebrauchen kann!!! Ich habe gesagt, das ihn niemand benutzt! Warum? Weil typeid nicht zu gebrauchen ist! Aber man KÖNNTE es nutzen, wenn typeid zu gebrauchen WÄRE!

Das der Threadersteller typeid gebrauchen könnte, steht außer fragen. Aber wir mußten ihm klar machen, das er es nicht gebrauchen kann, weil typeid nicht das macht, was er sich erhofft. Und als Lösung für sein Anforderung, muß er sich ein eigenes Typeid bauen.

musste nur etwas abändern...

#include <iostream>
#include <typeinfo>
#include <vector>
using namespace std;

class B {public:virtual ~B(){}};
class X : public B {public:void f(){cout<<"hello B"<<endl;}};
class Y : public B {};

vector<B*> vec;
 	
int main()
{
    int s;
    for (s=0; s<10; s++)
    {
        switch (rand()%3)
        {
            case 0:
            vec.push_back (new B);
            break;
            
            case 1:
            vec.push_back (new X);
            break;
            
            case 2:
            vec.push_back (new Y);
            break;    
        }
    }

    for (s=0; s<10; s++)
        if (typeid(*vec[s]) == typeid(X))  // nur X hat f() ;)
            ((X*)vec[s])->f();
}

Naja nen Code der bissl mehr aussagt und nen Bezug auf die reale Welt hat, wäre zwar schöner, aber dennoch hier:

#include <iostream>
#include <typeinfo>
#include <vector>
using namespace std;
enum IAM { BCLASS , XCLASS , YCLASS };

class B { public: virtual ~B(){} virtual  IAM type() const { return BCLASS;} };

class X : public B { public:void f(){cout<<"hello B"<<endl;} virtual  IAM type() const { return XCLASS;}};
class Y : public B { public: virtual  IAM type() const { return YCLASS;} };

vector<B*> vec;

int main()
{
    int s;
    for (s=0; s<10; s++)
    {
        switch (rand()%3)
        {
            case 0:
            vec.push_back (new B);
            break;

            case 1:
            vec.push_back (new X);
            break;

            case 2:
            vec.push_back (new Y);
            break;
        }
    }

    for (s=0; s<10; s++)
        if ( vec[s]->type() == XCLASS)  // nur X hat f() ;)
            ((X*)vec[s])->f();
}

proggingmania schrieb:

Geht nicht, zu wenig RAM.

Kauf dir nen neuen Rechner
Zudem macht das nicht viel aus, mit deinem Template werden auch drei Funktion generiert.
Dann sowas wie die Eingabe könnte man noch auslagern ...

Edit: Beispiel abgeändert ...

for (s=0; s<10; s++)
{
    X* xx = dynamic_cast<X*>(vec[s]);
    if ( xx )  
        xx->f();
}

Naja nen Code der bissl mehr aussagt und nen Bezug auf die reale Welt hat, wäre zwar schöner,

ist es denn so exotisch, wenn man pointer auf die basisklasse in einen vector steckt?

KasF schrieb:

aber dennoch hier:

#include <iostream>
#include <typeinfo>
#include <vector>
using namespace std;

enum IAM { BCLASS , XCLASS , YCLASS };

class B { IAM matype; public: B(IAM t = BCLASS):matype(t) { }; virtual ~B(){} IAM type() const { return matype; }};

class X : public B { public: X():B(XCLASS) { }; void f(){cout<<"hello B"<<endl;} };
class Y : public B { public: Y():B(YCLASS) { };  };

vector<B*> vec;

int main()
{
    int s;
    for (s=0; s<10; s++)
    {
        switch (rand()%3)
        {
            case 0:
            vec.push_back (new B);
            break;

            case 1:
            vec.push_back (new X);
            break;

            case 2:
            vec.push_back (new Y);
            break;
        }
    }

    for (s=0; s<10; s++)
        if ( vec[s]->type() == XCLASS)  // nur X hat f() ;)
            ((X*)vec[s])->f();
}

glückwunsch, du hast typeid nachgebaut

KasF schrieb:

Oder du behältst dein Code und änderst deine Schleife:

for (s=0; s<10; s++)
{
    X* xx = dynamic_cast<X*>(vec[s]);
    if ( xx )  
        xx->f();
}

ich hab' mal gehört, dass 'typeid' sehr schnell geht und konstante laufzeit hat, während 'dynamic_cast' die ganze vererbungshirarchie durchrödeln muss...

glückwunsch, du hast typeid nachgebaut

Ich habe doch gesagt, das ich es ohne typeid machen kann

Mit bissl schöner und so meinte ich Sachen wie:
Wieso gibt es kein f() in B. Sollte B abstrakt. Einfach ein Beispiel hinklatschen kann ja jeder, wenn man weiß was der Autor genau machen will, kann man vllt das Design umändern ...

Aber ich glaube wir belassen das hier mal so !

Kauf dir nen neuen Rechner

Geht nicht ist für nen Microcontroller, ohne RAM Erweiterung mit wenig KByte

KasF schrieb:

Ich gebe da Artchi Recht! Was net ( ) sagt deutet auf ein Design Fehler hin. Mach mir mal ein Beispiel mit typeId und ich mache daraus eins ohne

#include <typeinfo>
#include <iostream>
#include <limits>
#include <string>
using namespace std;

template< class T >
void bombensicher( T &a )
{
	string str = "Bitte geben Sie ";

	if ( typeid( a ) == typeid( double ) )
	{
		str += "eine Zahl ein: ";
	}

	if ( typeid( a ) == typeid ( char) )
	{
		str += "ein Zeichen ein: ";
	}

	if ( typeid( a ) == typeid ( string ) )
	{
		str += "eine Zeichenkette ein: ";
	}
	
	cout << str;

	while( !( cin >> a ) )
	{
		cin.clear();
		cin.ignore(numeric_limits<streamsize>::max(),'\n'); 
	    cout << endl << "Fehlerhafte eingabe! " << endl << str;
	}

	cin.ignore(numeric_limits<streamsize>::max(),'\n');
}

template< class T >
void bombensicher( T &a )
{
	string str = "Bitte geben Sie ein" + Filler(a) + " ein";

	cout << str;

	while( !( cin >> a ) )
	{
		cin.clear();
		cin.ignore(numeric_limits<streamsize>::max(),'\n'); 
	    cout << endl << "Fehlerhafte eingabe! " << endl << str;
	}

	cin.ignore(numeric_limits<streamsize>::max(),'\n');
}

int main()
{    
	double	d = 0;
	char	c = 0;
	string  s ;
	
	bombensicher( d );
	cout << d << endl;
	
	bombensicher( c );
	cout << c << endl;
	
	bombensicher( s );
	cout << s << endl;

	return 0;
}

Hi,

ich bin zwar nicht KasF und will auch nicht seine These in der Allgemeinheit stützen, aber das ist ein denkbar schlechtes "Gegenbeispiel", weil hier die Typinformation sowieso schon zur Compilezeit aufgelöst wird ... dafür braucht man wirklich keine Runtime-Type-Information.

#include <iostream>
#include <limits>
#include <string>
using namespace std;

string Filler(const string& a) {
   return "en String";
}

string Filler(const double& a) {
   return "e Fließkommazahl";
}

string Filler(const char& a) {
   return " Zeichen";
}

template< typename T >
void bombensicher( T &a )
{
	string str = "Bitte geben Sie ein" + Filler(a) + " ein";

	cout << str;

	while( !( cin >> a ) )
	{
		cin.clear();
		cin.ignore(numeric_limits<streamsize>::max(),'\n'); 
	    cout << endl << "Fehlerhafte eingabe! " << endl << str;
	}

	cin.ignore(numeric_limits<streamsize>::max(),'\n');
}

... und ausgelinkt braucht das auch nicht mehr Platz (eher weniger) und läuft schnller als Deine template-Variante.

Gruß,

Simon2.

ich hab' mal gehört, dass 'typeid' sehr schnell geht und konstante laufzeit hat, während 'dynamic_cast' die ganze vererbungshirarchie durchrödeln muss...

typeid() selbst ist schnell, allerdings type_info::operator == ist nicht immer so super schnell (oft einfach als strcmp implementiert).