3. Typen checken?

Typen checken?

  • C

    Helium schrieb:

    1. Spezialisieren kannst du nur Klassen.

    seit wann!?!? o_O

    2. Das, was du da machst, ist ziemlicher unsinn. Durch dein Template-Argument steht schon zur Compilezeit fest, um welchen Typ es sich handelt die Überprüfung zur Laufzeit mittels typeid ist demzufolge sinnlos.

    Versteh nicht ganz warum ein Template-Argument einen laufzeitcheck mit typeid sinnlos macht 😕
    Macht doch genau das was er oben in seinem ersten code machen will.

    0
  • H

    Ja, man kann Funktionen überladen. Was willst du mir jetzt damit sagen?

    es gibt zwei Lösungen, die du benutzen könntest:
    [snip]
    2. template specialization:

    Ja sicher könnte man spezialisieren:

    tempalte <typename T>
struct Foo {};

tempalte <>
struct Foo<float> {
   void foo()
   {
      glVector3f (1.0f, 1.0f, 1.0f);
   }
};

tempalte <>
struct Foo<double> {
   void foo()
   {
      glVector3d (1.0, 1.0, 1.0);
   }
};

tempalte <>
struct Foo<unsigned int> {
   void foo()
   {
       glVector3ui (1, 1, 1);
   }
};

    Der Sinn ist allerdings fraglich. Deine erste version übergibt sinnloserweise einen Wert, obwohl sie das nicht müsste.

    0
  • S

    Helium schrieb:

    Ja, man kann Funktionen überladen. Was willst du mir jetzt
    Der Sinn ist allerdings fraglich. Deine erste version übergibt sinnloserweise einen Wert, obwohl sie das nicht müsste.

    🙄
    dann mache ich so:

    void foo(float)
{
	glVector3f (1.0f, 1.0f, 1.0f);
}

void foo(double)
{
	glVector3d (1.0, 1.0, 1.0);
}

void foo(unsigned int)
{
	glVector3ui (1, 1, 1);
}

//und werde es so benutzen:
foo(float());
foo(double());
foo(unsigned int());

    😃

    0
  • S

    Helium schrieb:

    Ja sicher könnte man spezialisieren:

    tempalte <typename T>
struct Foo {};

tempalte <>
struct Foo<float> {
   void foo()
   {
      glVector3f (1.0f, 1.0f, 1.0f);
   }
};

    Ich verstehe immer noch nicht warum du statt eines Funktions-Templates und entsprechenden Spezialisierung, eine Klasse benutzt...

    0
  • V

    Warum unsinnig? Mach foo static und er kann schoen

    Foo<type>::foo();

    schreiben. Ist das denn wirklich so schlecht, wenn er sowas in der Art
    macht:

    template<typename T>
struct Foo {
};

template<>
struct Foo<int> {
    static int bar() {
	return 0;
    }
};

template<>
struct Foo<float> {
    static int bar() {
	return 1;
    }
};

int main() {
    std::cout<<Foo<float>::bar()<<endl;
    std::cout<<Foo<int>::bar()<<endl;
    return 0;
}

    mfg
    v R

    0
  • H

    Warum unsinnig? Mach foo static

    Wollte ich eigentlich auch 🙄

    0
  • V

    Helium schrieb:

    Warum unsinnig? Mach foo static

    Wollte ich eigentlich auch 🙄

    Achso, hab mir eigentlich auch gedacht, dass es ein vertippsler war 😃

    mfg
    v R

    0
  • ?

    CMatt schrieb:

    1. für das was du da vor hast, wurden template-spezialisierung erfunden.

    2. Du kannst die typen über die RTTI checken (muss allerdings beim compilieren an sein - beim VC++ ist es der parameter /CR )
    bsp:

    template<class irgendwas>
void foo (irgendwas value)
{
   if (typeid( irgendwas ) == typeid(float))
   {
       glVector3f (1.0f, 1.0f, 1.0f);
   }
   else if (typeid( irgendwas ) == typeid(double))
   {
       glVector3d (1.0, 1.0, 1.0);
   }
   else if (typeid( irgendwas ) == typeid(unsigned int))
   {
       glVector3ui (1, 1, 1);
   }
   // usw.
}

    Hi,

    danke den code find ich von all den vorgeschlagenen am einfachsten zu handhaben 🙂 Oder gehts noch besser jedoch bei selbem handling?

    Also die funktion sollte so benutzt werden:

    float x=1.0f;
foo (x);

    Dabei soll dann in der funktion der wert an die jeweiligen funktionen übergeben werden.

    0
  • S

    *** schrieb:

    Also die funktion sollte so benutzt werden:

    float x=1.0f;
foo (x);

    Dabei soll dann in der funktion der wert an die jeweiligen funktionen übergeben werden.

    in diesem Fall passt am besten function overloading, wie ich shon schrieb

    0
  • ?

    Ich kann aber nicht für jede meiner 40 mathestrukturen 10 überladene funktionen machen für 100 Operatoren! (würde 1.000 Funktionen machen!)

    0
  • H

    Ich kann aber nicht für jede meiner 40 mathestrukturen 10 überladene funktionen machen für 100 Operatoren! (würde 1.000 Funktionen machen!)

    40*10*100=1000??? eher 40000.
    Aber 40000 if-Zweige sind in Ordnung? Sicher, das da nicht ein prinzipfehler hintersteckt.

    Und überleg mal.
    Ist es so wirklich übersichtlicher:

    tempalte <typename T>
void foo (T value)
{
   if (typeid(T) == typeid(float))
   {
       glVector3f (value, value, value);
   }
   else if (typeid(T) == typeid(double))
   {
       glVector3d (value, value, value);
   }
   else if (typeid(T) == typeid(unsigned int))
   {
       glVector3ui (value, value, value);
   }
   // usw.
}

    Als so:

    void foo (float value)
{
   glVector3f (value, value, value);
}
void foo (double value)
{
    glVector3d (value, value, value);
}
void foo (unsigned int value)
{
    glVector3ui (value, value, value);
}

    Also auf jeden Fall ist die Variante mit dem Überladen deutlich kürzer und zudem wird garantiert zur Compilezeit entschieden, welche Version benötigt wird.
    Ich mein ja nur gl... hört sich so an, als ob Geschwindigkeit eine Rolle spielen könnte.

    0
  • H

    [quote="ssm"]

    Shlo schrieb:

    Helium schrieb:

    1. Spezialisieren kannst du nur Klassen.

    IMHO eine falsche Meinung, die keine Begründung hat

    Funktionstemplates kann man explizit nicht aber partiell spezialisieren.

    Das ist ok und eine explizite Spezialisierung:

    template <class T>
void foo(T t);

template <>
void foo(int);

    Das ist auch ok aber *keine* partielle Spezialisierung sondern eine
    Überladung, hier haben wir jetzt zwei Base-Templates:

    template<class T, class U> 
void foo1(T, U) { } 

template<class T> 
void foo1(T, unsigned) { }

    Der feine Unterschied zwischen Ünerladung und Spezialisierung wird hier sehr schön erlärt:
    http://www.gotw.ca/publications/mill17.htm

    0
  • S

    to HumeSikkins

    es ging nich um partielle Spezialisierung 😉 😃

    0
  • H

    ssm schrieb:

    to HumeSikkins

    es ging nich um partielle Spezialisierung 😉 😃

    Das Zitat sowie mein Beitrag sollten ausdrücken, dass ihr beide auf gewisse Art und Weise recht habt. Das Wort "spezialisieren" ist hier einfach nicht "speziell" genug 🙂

    0
  • S

    HumeSikkins schrieb:

    ssm schrieb:

    to HumeSikkins

    es ging nich um partielle Spezialisierung 😉 😃

    Das Zitat sowie mein Beitrag sollten ausdrücken, dass ihr beide auf gewisse Art und Weise recht habt. Das Wort "spezialisieren" ist hier einfach nicht "speziell" genug 🙂

    1. Spezialisierung ist Spezialisierung
    2. partielle Spezialisierung ist partielle Spezialisierung
    3. es gibt keinen Begriff "die ganze Spezialisierung", oder doch?

    0
  • H

    ssm schrieb:

    HumeSikkins schrieb:

    ssm schrieb:

    to HumeSikkins

    es ging nich um partielle Spezialisierung 😉 😃

    Das Zitat sowie mein Beitrag sollten ausdrücken, dass ihr beide auf gewisse Art und Weise recht habt. Das Wort "spezialisieren" ist hier einfach nicht "speziell" genug 🙂

    1. Spezialisierung ist Spezialisierung

    Nö. Spezialisierung ist das Ergebnis der Ersetzung von Template-Parametern durch tatsächliche Argumente und als solche kein eindeutiger Begriff. Eine Spezialisierung kann so z.B. durch eine Instanziierung oder durch eine explizite Spezialisierung entstehen. Sie ist aber keine explizite Spezialisierung.

    2. partielle Spezialisierung ist partielle Spezialisierung

    und nur für Template-Klassen möglich. Das Ergebnis ist eine alternative Definition eines primary Templates, die nach wie vor von mindestens einem Templateparameter abhängt.

    3. es gibt keinen Begriff "die ganze Spezialisierung", oder doch?

    Keine Ahnung was du meinst. Es gibt eine explizite Spezialisierung (explicit specialization).
    Eine explizite Spezialisierung ist ein Konstrukt, dass eine alternative Definition für ein sogenanntes primary Template deklariert oder definiert, so dass diese Definition nicht mehr von einem Templateparameter abhängt. Eine explizite Spezialisierung beginnt immer mit template <> und kann sowohl für Klassentemplates als auch für Funktionstemplates angegeben werden.

    0
  • S

    HumeSikkins schrieb:

    ssm schrieb:

    HumeSikkins schrieb:

    ssm schrieb:

    to HumeSikkins

    es ging nich um partielle Spezialisierung 😉 😃

    Das Zitat sowie mein Beitrag sollten ausdrücken, dass ihr beide auf gewisse Art und Weise recht habt. Das Wort "spezialisieren" ist hier einfach nicht "speziell" genug 🙂

    1. Spezialisierung ist Spezialisierung

    Nö. Spezialisierung ist das Ergebnis der Ersetzung von Template-Parametern durch tatsächliche Argumente und als solche kein eindeutiger Begriff. Eine Spezialisierung kann so z.B. durch eine Instanziierung oder durch eine explizite Spezialisierung entstehen. Sie ist aber keine explizite Spezialisierung.

    2. partielle Spezialisierung ist partielle Spezialisierung

    und nur für Template-Klassen möglich. Das Ergebnis ist eine alternative Definition eines primary Templates, die nach wie vor von mindestens einem Templateparameter abhängt.

    3. es gibt keinen Begriff "die ganze Spezialisierung", oder doch?

    Keine Ahnung was du meinst. Es gibt eine explizite Spezialisierung (explicit specialization).

    Eine explizite Spezialisierung ist ein Konstrukt, dass eine alternative Definition für ein sogenanntes primary Template deklariert oder definiert, so dass diese Definition nicht mehr von einem Templateparameter abhängt. Eine explizite Spezialisierung beginnt immer mit template <> und kann sowohl für Klassentemplates als auch für Funktionstemplates angegeben werden.

    👍 ok, ok, ich kapitulire 😃

    0
Anmelden zum Antworten