Warum hat C++ so eine aufwendige Syntax?

camper

Undertaker schrieb:

es gibt klassen-templates. haben die keine konstruktoren?

Nein. Was sollte der konstruieren? Ein Klassentemplate erzeugt Klassen, keine Objekte. Andererseits ist der Gedanke ja nicht ganz unsinnig: wenn es nur darum geht, Ausdrücke, deren Wert bereits während des Compilierens feststeht, zu verwenden, so ist die Benutzung von Templates (um den Compiler zu zwingen, die Berechnung gleich durchzuführen) eigentlich mit Kanonen auf Spatzen geschossen. Einerseits ist die Templatesyntax ziemlich barock und mit einigen Stolperfallen versehen, anderseits ist es im Wesentlich nur für integrale Typen möglich. Nicht ganz zufällig wird es C++0x nutzerdefinierte Literale und Erweiterung hinsichtlich konstanter Ausdrücke (Schlüsselwort constexpr) geben.

Mr. N

Undertaker schrieb:

also mal angenommen ich habe sowas
template <typename T>
struct A
{
    T i;
    
    A(T x)
    {
        i = x * x;
    }
    
    T get (void)
    {
        return i;
    }
};
und rufe es so auf:
int x = A<int>(3).get();
dann ist es doch das gleiche, als wenn ich schreiben würde
int x = 9;
weil der compiler ja den template-code selber ausrechnet. es steht ja alles schon zur compile-time fest. es sollte doch kein funktionsaufruf o.ä. erzeugt werden.
oder nicht?

Schau dir mal diesen Code an:

struct A_int {
    int i;

    A(int x)
    {
        i = x * x;
    }

    int get()
    {
        return i;
    }
};

int x = A_int(3).get();

Der Code ist mit deinem vergleichbar. Der Compiler kann in beiden Fällen

int x = 9;

draus machen. Metaprogrammierung wäre was anderes:

template<int x>
struct A {
  static const int get = x * x;
};
int x = A<3>::get;

Hier ist garantiert, dass der Compiler die Berechnung zur Compile-Zeit ausführt.

Simon2

Shade Of Mine schrieb:

...
von value typen erbt man nunmal nicht. ...
...hätte sie final/sealed zu sein. da man eben von ihr nicht erben soll. ergo verstehe ich das ganze nicht.

"Du sollst nicht von int erben !" ? Elftes Gebot ?

Also diese moralischen Grenzen kann ich in dem Zusammenhang nicht recht akzeptieren. Es wäre schön, etwas zu haben, was den Intellekt anspricht.

Gruß,

Simon2.

P.S.: In meinem Beispiel hieße das dann "Man soll eben nicht dieselbe Weltformel für Zwerpinscher wie für alle anderen haben !"

Undertaker

Mr. N schrieb:

template<int x>
struct A {
  static const int get = x * x;
};
int x = A<3>::get;
Hier ist garantiert, dass der Compiler die Berechnung zur Compile-Zeit ausführt.

und was ist damit:

template <typename T>
T square (T x)
{
    return x * x;
}
...
int x = square<int>(3);
...

?
ist dabei garantiert, dass die berechnung beim compilieren gemacht wird, oder auch nicht?

darthdespotism

EDIT://
stand ja schon oben ...

Undertaker schrieb:

Mr. N schrieb:
template<int x>
struct A {
  static const int get = x * x;
};
int x = A<3>::get;
Hier ist garantiert, dass der Compiler die Berechnung zur Compile-Zeit ausführt.
und was ist damit:
template <typename T>
T square (T x)
{
    return x * x;
}
...
int x = square<int>(3);
...
?
ist dabei garantiert, dass die berechnung beim compilieren gemacht wird, oder auch nicht?

Du kannst ja sämtliche deiner Vorschläge selbst testen. Kombiniert man beide Beispiele müsste folgendes funktionieren, wenn es denn zur Compile-Time berechnet wird.

int x = A<square<int>(3)>::get;

Das macht eben den Unterschied aus, wobei ich auch sagen muss, dass dieses Beispiel auch gekünstelt ist und ich mir hier eben wirklich keinen Fall vorstellen kann, indem ich zur "echten" Compile-Time das Quadrat von 3 brauche.

Undertaker

dsfsdf schrieb:

int x = A<square<int>(3)>::get;

error C2975: 'x' : invalid template argument for 'A', expected compile-time constant expression

offenbar wird das function template nicht zur compile-time berechnet.
...und ich dachte, templates wären eine tolle sache
jetzt bin ich aber echt enttäuscht

DEvent

Wozu braucht man das ueberhaupt? Ich mein, es ist zwar schoen wenn der Compiler mir etwas ausrechnen kann, aber das sind doch alles Konstanten? Also mann kann doch nicht waerend das Programm laeuft, etwas vom Compiler ausrechnen lassen.

Beispiel, dieses Meta-Programm um zu testen ob eine Zahl eine perfekte ist. Man kann es doch nicht so machen, dass der Benutzer eine Zahl eingibt, und dann wird getestet, ob die Zahl perfekt ist. Sondern man gibt eine Zahl vor, dann laest man das Programm kompelieren und dann hat man das Ergebnis. Dann kann ich aber gleich ein "normales" Programm schreiben.

Gibts da irgendeinen reallen Mehrwert?

Michael E.

Undertaker schrieb:

...und ich dachte, templates wären eine tolle sache
jetzt bin ich aber echt enttäuscht

Ach, weil du keine Ahnung hast, bist du enttäuscht? Nicht wissen, was TMP ist, aber dann mal drüber ablästern...

Undertaker

Michael E. schrieb:

Undertaker schrieb:

...und ich dachte, templates wären eine tolle sache
jetzt bin ich aber echt enttäuscht

Ach, weil du keine Ahnung hast, bist du enttäuscht? Nicht wissen, was TMP ist, aber dann mal drüber ablästern...

klar bin ich enttäuscht, wenn's noch nicht mal bei so einfachen sachen wie x*x funktioniert. stattdessen muss man mit komischen structs mit 'static const' membern rumfrickeln und kann noch nicht mal normale kontrollstrukturen wie if/else einsetzen?
das ist doch nur noch zum heulen

Michael E.

Dann geh doch heulen und verschon uns.

Mr. N

Undertaker schrieb:

Michael E. schrieb:

Undertaker schrieb:

...und ich dachte, templates wären eine tolle sache
jetzt bin ich aber echt enttäuscht

Ach, weil du keine Ahnung hast, bist du enttäuscht? Nicht wissen, was TMP ist, aber dann mal drüber ablästern...

klar bin ich enttäuscht, wenn's noch nicht mal bei so einfachen sachen wie x*x funktioniert. stattdessen muss man mit komischen structs mit 'static const' membern rumfrickeln und kann noch nicht mal normale kontrollstrukturen wie if/else einsetzen?

Wieso ist ein Konstrukt schlechter, weil dus komisch findest? Nur mal ein klitzekleines Beispiel für TMP:

template<
      typename Graph,
      typename First = typename boost::mpl::begin<Graph>::type,
      typename Last = typename boost::mpl::end<Graph>::type,
      typename Result = boost::mpl::map0<>
    >
    struct clean_graph {
      typedef typename boost::mpl::deref<First>::type::first key;
      typedef typename boost::mpl::if_<
          typename boost::mpl::has_key<
            Result,
            key
          >::type,
          Result,
          typename boost::mpl::insert<
            Result,
            boost::mpl::pair<
              key,
              typename boost::mpl::at<
                Graph,
                key
              >::type
            >
          >::type
        >::type next;
      typedef typename clean_graph<
          Graph,
          typename boost::mpl::next<First>::type,
          Last,
          next
        >::type type;
    };

    template<typename Graph, typename First, typename Result>
    struct clean_graph<Graph, First, First, Result> {
      typedef Result type;
    };

Diese Funktion löscht Duplikate aus einer Graphenliste. Wird benutzt um Toposort zur Compilezeit zu implementieren. Frag bitte nicht, wozu das gut sein soll, es hat seinen Zweck. Und vielleicht ließe sich das auch eleganter implementieren. Aber es funktioniert, so wie es ist.

Kein Grund zur Trauer.

Undertaker

Mr. N schrieb:

Wieso ist ein Konstrukt schlechter, weil dus komisch findest?

es ist zumindest schlechter als ich dachte.
sorry, ich bin nicht so der erfahrene C++ user und war bisher der meinung, dass mit templates (z.b. function templates) alles was möglich ist, zur compile-time berechnet wird. das scheint aber nicht der fall zu sein und wirkt auf mich deshalb ziemlich ernüchternd...

this-*gt*that

Assembler funktioniert auch. Normales C++ is ja schon grausig, aber sowas is einfach nur noch :kotzsmilie:

Mr. N

Undertaker schrieb:

Mr. N schrieb:

Wieso ist ein Konstrukt schlechter, weil dus komisch findest?

es ist zumindest schlechter als ich dachte.
sorry, ich bin nicht so der erfahrene C++ user und war bisher der meinung, dass mit templates (z.b. function templates) alles was möglich ist, zur compile-time berechnet wird. das scheint aber nicht der fall zu sein und wirkt auf mich deshalb ziemlich ernüchternd...

Doch, es wird alles was möglich ist zur Compile-Zeit berechnet. Ein Funktionsaufruf gehört nicht dazu - wobei der oft vom Optimierer entfernt werden kann.

Und nein, C++-Templates sind nicht das Non-Plus-Ultra. Aber sie sind besser als nichts und es wäre lächerlich, sich über ihre Präsenz zu beklagen.

darthdespotism

Undertaker schrieb:

Mr. N schrieb:

Wieso ist ein Konstrukt schlechter, weil dus komisch findest?

es ist zumindest schlechter als ich dachte.
sorry, ich bin nicht so der erfahrene C++ user und war bisher der meinung, dass mit templates (z.b. function templates) alles was möglich ist, zur compile-time berechnet wird. das scheint aber nicht der fall zu sein und wirkt auf mich deshalb ziemlich ernüchternd...

Ich meine irgendwo gelesen zu haben das TMP Turing-Volllständig sei ...

Zweck:

Undurchsichtige Konstanten vermeiden. Bei einem Quadrat mag es kein Problem sein die Konstante selber auszurechnen, bei einem Sinus wirds dann schon lustig wenn man was ändern will. da ist sin<1.2>::value einfach eine eindeutige Lösung (TMP mit Fließkommazahlen, war das vom std abgedeckt?)
Schreibarbeit abnehmen, z.B. beim unrolling von loops
to be continued

Simon2

Undertaker schrieb:

dsfsdf schrieb:
int x = A<square<int>(3)>::get;
error C2975: 'x' : invalid template argument for 'A', expected compile-time constant expression

offenbar wird das function template nicht zur compile-time berechnet.
...und ich dachte, templates wären eine tolle sache
jetzt bin ich aber echt enttäuscht

Gleich noch eine Enttäuschung für Dich: Sie können kein Brot toasten und das "Blei in Gold verwandeln" klappt bei denen auch nicht so recht.

templates (= "Schablonen") sind eben genau das: Schablonen für C++-Klassen oder -Funktionen. Dass sie zur Compilezeit ausgewertet werden, verschafft erhöhte Typsicherheit, ist aber nicht ihr Kernziel.

Gruß,

Simon2.

Undertaker

Mr. N schrieb:

Und nein, C++-Templates sind nicht das Non-Plus-Ultra. Aber sie sind besser als nichts und es wäre lächerlich, sich über ihre Präsenz zu beklagen.

ich beklage ja nicht die präsenz, sondern einfach nur dass sie nicht soviel können, wie ich erhofft hatte.
wie Simon2 schon schrieb, sind templates nichts anderes als schablonen, mit denen man klassen und funktionen losgelöst von festen datentypen entwickeln kann. das ist wohl ihr einziger bestimmungszweck und diese basteleien mit TMP scheinen eine art abfallprodukt zu sein.
naja, ich war noch nie der meinung, dass C++ besonders nützlich ist. was soll's also - es stört mich nicht wirklich...

Michael E.

Mit Templates kann man noch viel mehr. Guck dir mal Loki und Boost an.

Artchi

Michael E. schrieb:

Mit Templates kann man noch viel mehr. Guck dir mal Loki und Boost an.

Ehm, meinste das wird seine Meinung ändern? Das Posting hättest du dir ersparen können.
Warum wollen ihm alle C++ und Templates erklären, wo er schon vor Monaten nichts dazu gelernt hat und es anscheinend auch nicht will.
Fallt doch nicht immer wieder auf seine Verarschung rein.