template<class T,T Value> nicht erlaubt?

[davie]

ich würde allerdings nicht zu sehr auf diese technik setzen und gleich einfach int nehmen, (fast) alles andere lässt sich schlecht aufzählen (enum) oder static const machen.

[otze]

hmpf float/double geht ja wirklich nicht
wieso mache ich mir denn dann die ganze arbeit? arrgh

//edit *snief* keine vorberechnete sinus-/cosinuswert-liste *heul*

[HumeSikkins]

otze schrieb:

hmpf float/double geht ja wirklich nicht

Wenn du noch ein paar Jahre Zeit hast, kannst du ja auf den nächsten Standard warten. Soweit ich weiß wird darüber nachgedacht ob man dort dann floating-Point-Typen als non-type-Argumente zulässt.

[virtuell Realisticer]

HumeSikkins schrieb:

otze schrieb:

hmpf float/double geht ja wirklich nicht

Wenn du noch ein paar Jahre Zeit hast, kannst du ja auf den nächsten Standard warten. Soweit ich weiß wird darüber nachgedacht ob man dort dann floating-Point-Typen als non-type-Argumente zulässt.

Darf ich mal ganz bescheiden fragen: Wieso ist das nicht zulaessig?

mfg
v R

[otze]

HumeSikkins schrieb:

otze schrieb:

hmpf float/double geht ja wirklich nicht

Wenn du noch ein paar Jahre Zeit hast, kannst du ja auf den nächsten Standard warten. Soweit ich weiß wird darüber nachgedacht ob man dort dann floating-Point-Typen als non-type-Argumente zulässt.

aber nur, wenn wenn die typed enums nicht durckommen, imho empfinde ich die sache mit var als absolut nutzlosen und design zerstörenden hack,der code wird dadurch sicherlich nicht lesbarer^^

[otze]

ich geb nicht auf

da floating point nicht geht, hab ich ne nachtschicht(bzw frühschicht) eingelegt, und kam auf folgendes ergebnis:

template<int N,int Z=1>
struct var{
    typedef var<int N,int Z> Value;
};

template <class T>
struct Get : public Get<typename T::Value>{};

template <int N,int Z>
struct Get<var<N,Z> >{
    static const double Value=N/Z;//hoffe das geht wenigstens^^
};
template <int N>
struct Get<var<N,1> >{
    static const int Value=N;
};

jetzt muss ich mich zwar in jeder operation mit dem kuerzen rumschlagen, aber immerhin noch besser als nichts^^

[HumeSikkins]

virtuell Realisticer schrieb:

HumeSikkins schrieb:

otze schrieb:

hmpf float/double geht ja wirklich nicht

Wenn du noch ein paar Jahre Zeit hast, kannst du ja auf den nächsten Standard warten. Soweit ich weiß wird darüber nachgedacht ob man dort dann floating-Point-Typen als non-type-Argumente zulässt.

Darf ich mal ganz bescheiden fragen: Wieso ist das nicht zulaessig?

Also laut "C++ Templates" sind die Gründe historischer nicht aber technische Natur. Genaueres weiß ich allerdings nicht.

[otze]

imho hat man wohl nicht geglaubt, was die kranken programmierer mit den templates anfangen wollen und können, ints waren wahrscheinlich nur dafür gedacht, verschiedene templates besser identifizieren zu können, von meta programmierung hat doch zu dem zeitpunkt noch keiner gewagt zu sprechen, sodass man sich im endeffekt dazu entschieden hat,floats rauszunehmen,und es somit den compiler-machern einfacher zu machen.

[Helium]

template <int N,int Z>
struct Get<var<N,Z> >{
static const double Value=N/Z;//hoffe das geht wenigstens^^
};

Wenn du daran denkst, das z.B. 2/3 == 0 ist, ... :p

[otze]

wie meinen?

[Helium]

int x = 2;
int y = 3;

double z = x / y;

Der wert von z ist jetzt 0.

x hat den Typ int, y hat den Typ int, also ist das Ergebnis der Division auch int. 2/3 ist also 0 und diese 0 wird dann der Variable z (vom Typ double) zugewiesen, wobei umgewandelt werden muss.
Das selbe kommt in deinem Code vor.

Hätte ich hingegen geschreiben

int x = 2;
int y = 3;

double z = static_cast<double>(x) / y;

, dann würde y in double konvertiert werden, eine Fließkomma-Division stattfinden und .666666666666666 herauskommen.

[otze]

hmm guter einwand

[Gast]

Man kann aber Referenzen verwenden:

template<const float& f>
class A
{};

A<5.0f> x;

Vielleicht kannst du damit was anfangen.

[Irgendwer]

Ich habe mal irgendwo gelesen, dass der gcc das vor der standardisirung konnte. Wurde aber rausgenommen um standard konformer zu werden.

Der eigentlich Grund wieso man es rausgelassen hat ist glaub ich :

const double a=5.8;
char a[b];

Damit du double als template parameter verwenden kannst, muss es eine compiletime Variable. Diese muss aber ganzahlig sein damit man damit ein Array erschaffen kann.

Also braucht man dafür 2 compiletime Variablen und den Aufwand dies zu implementiren übersteigt den Nutzen.

Wenn du Kommazahlen brauchst dann schreib dir doch einfach eine Bruch Klasse.

[otze]

Wenn du Kommazahlen brauchst dann schreib dir doch einfach eine Bruch Klasse.

hab ich schon
waren imho nur 2 zeilen in var die geändert werden mussten(mal abgesehen davon, dass ich alle anderen operationen die ich bis dahin geschrieben hab überarbeiten musste^^)

[HumeSikkins]

space schrieb:

Man kann aber Referenzen verwenden:

template<const float& f>
class A
{};

A<5.0f> x;

Das ist kein legales C++.