3. Sone (Hacker) erklärt die Welt (C++11). War: C++ auto

Sone (Hacker) erklärt die Welt (C++11). War: C++ auto

  • K

    pumuckl schrieb:

    auto ist nicht dazu gedacht, dir Tipparbeit zu sparen, sondern es ist dazu gedacht, redundante Typangaben zu vermeiden.

    Das würde ich anders formulieren. Und im Motivationsabschnitt des auto-Proposals tauchen sicherlich auch extrem lange Iterator-Typen auf, die man nicht wirklich hinschreiben will. Um das Sparen von Tipparbeit geht's also auch. Bei "redundante Typangaben" fällt mir spontan nur

    auto sp = make_shared<Thing>(42);

    ein, wo es klar sein sollte, dass sp ein shared_ptr<Thing> ist. Aber oft weiß man den Typ ja gar nicht genau (z.B. Lambdas, std::bind-Ergebnis u.s.w.). auto erlaubt da auch ein besseres generic programming:

    template<class T>
void show(T const& c)
{
  auto it = begin(c);
  auto ee = end(c);
  // Was ist decltype(it)? Keine Ahnung
  // Ggf gibt es den Typ T::const_iterator
  // Ggf auch nicht (bei rohen Arrays)
  while (it!=ee) {
    cout << *it << ' ';
    ++it;
  }
}

    auto eilt also zur Hilfe, wenn man den Typen nicht explizit hinschreiben will oder kann.

    Ich weiß aber auch noch nicht, wie schlau es ist, auto auch dann einzusetzen, wenn ich den Typen auch selbst kurz hätte hinschreiben können. Ich denke, wenn vom Kontext nicht klar ist, was für eine Art von Typ eine "auto-Variable" hat, dann macht man es dem Leser eventuell unnötig schwer, das Programm nachzuvollziehen. Aber irgendwie arrangieren sich die Nutzer von dynamischen Sprachen ja auch damit, in denen ganz selten mal Typen explizit genannt werden -- wobei mich das aber eigentlich ein bisschen stört.

    0
  • K

    Sone schrieb:

    auto a(4);//das anstatt
int a(4); //dem zu schreiben
auto b = {1, 2, 5, 8};//Ist das jetzt eine Initializerlist oder ein C-Style Array?
int b[] = {1, 2, 5, 8};//Keine Frage

    Suuuuper Beispiele, ganz grosses Kino, nein ... wirklich ...

    0
  • C
    Mod

    Sone schrieb:

    auto a(4);//das anstatt
int a(4); //dem zu schreiben
auto b = {1, 2, 5, 8};//Ist das jetzt eine Initializerlist oder ein C-Style Array?
int b[] = {1, 2, 5, 8};//Keine Frage

    Mir fehlt da noch ein

    auto c[] = { 2, 3, 5 };

    .. kommt ja vielleicht mit dem nächsten Standard.

    0
  • S

    knivil schrieb:

    Sone schrieb:

    auto a(4);//das anstatt
int a(4); //dem zu schreiben
auto b = {1, 2, 5, 8};//Ist das jetzt eine Initializerlist oder ein C-Style Array?
int b[] = {1, 2, 5, 8};//Keine Frage

    Suuuuper Beispiele, ganz grosses Kino, nein ... wirklich ...

    ??? Was zum Teufel war daran jetzt schlecht? Bei Skalaren ist es doch wirklich ein wenig unnötig, den Typ anhand des Literals o. ä. deduzieren zu lassen. Eben so bei C-Arrays. Das wollte ich damit nur sagen.

    0
  • N
     

    #include <vector>
#include <tuple>

int main (){
    std::vector<std::tuple<std::string,std::string,std::string>> v;
    std::vector<std::tuple<std::string,std::string,std::string>>::const_iterator it=v.cbegin();
    auto it2=v.cbegin();
}

    Will man ernsthaft sowas tippen?

    Für einfache ints ist es aber unnötig.. Da habt ihr schon recht.

    0
  • S
     

    std::vector<std::tuple<std::string,std::string,std::string>>

    Wer zum Teufel hat so einen Container? 😃
    Dann würde ich mir schon eine Datenstruktur schreiben.

    0
  • K

    Sone schrieb:

    auto b = {1, 2, 5, 8};//Ist das jetzt eine Initializerlist oder ein C-Style Array?

    Falls das eine ernste Frage war: decltype(b) wird std::initializer_list<int> sein.

    0
  • ?

    krümelkacker schrieb:

    Sone schrieb:

    auto b = {1, 2, 5, 8};//Ist das jetzt eine Initializerlist oder ein C-Style Array?

    Falls das eine ernste Frage war: decltype(b) wird std::initializer_list<int> sein.

    Sowas liebe ich: quasi zitiert, aber so tun, als ob dass Allgemeinwissen sei, und jeder wissen müsste.

    C++11 schrieb:

    7.1.6.4 auto specifier
    6 Once the type of a declarator-id has been determined according to 8.3, the type of the declared variable using the declarator-id is determined from the type of its initializer using the rules for template argument deduction. Let T be the type that has been determined for a variable identifier d. Obtain P from T by replacing the occurrences of auto with either a new invented type template parameter U or, if the initializer is a braced-init-list (8.5.4), with std::initializer_list<U>. The type deduced for the variable d is then the deduced A determined using the rules of template argument deduction from a function call (14.8.2.1), where P is a function template parameter type and the initializer for d is the corresponding argument. If the deduction fails, the declaration is ill-formed. [ Example:
    ` auto x1 = { 1, 2 }; // decltype(x1) is std::initializer_list<int>

    auto x2 = { 1, 2.0 }; // error: cannot deduce element type`
    —end example ]

    Wenig glanzvoll, lieber krümelkacker.

    0
  • K

    Komisch. Normalerweise sind die Leute froh, wenn jemand den Standard zitiert. Aber hauptsache, du hast was zu meckern. 🙄

    0
  • K

    Furble Wurble schrieb:

    Sowas liebe ich: quasi zitiert, aber so tun, als ob dass Allgemeinwissen sei, und jeder wissen müsste.

    Da liest du zu viel zwischen den Zeilen. Ich wusste nur nicht, ob das eine rhetorische Frage innerhalb seiner Argumentation sein sollte oder eben nicht. Und da fiel mir nur "ernst" als Gegenteil von "rhetorisch" ein. Das mit dem "quasi zitiert" kapiere ich nicht ganz. Klingt so, als glaubtest du, ich hätte das im Standard extra nachgeguckt. Zu sagen "decltype(b) ist ..." statt "Der typ von b ist ..." liegt auch irgendwie nahe, oder?

    Furble Wurble schrieb:

    Wenig glanzvoll, lieber krümelkacker.

    Leck mich.

    0
  • P

    Sone schrieb:

    Trotzdem wirst du mir zustimmen dass das höchstens bei Klassen gut ist, [...]

    Und bei Initializern, die Funktionsaufrufe sind. Oder Variablen, die vielleicht (wahrscheinlich) selber mit auto deklariert wurden. Oder allgemeiner: bei allen Ausdrücken, die einen Hauch komplexer als das extrem triviale Beispiel eines int-Literals, das du angeführt hast. Also bei fast Allem, was über Einsteigerniveau hinausgeht.

    Furble Wurble schrieb:

    Sowas liebe ich: quasi zitiert, aber so tun, als ob dass Allgemeinwissen sei, und jeder wissen müsste.

    Sollte jeder wissen, der sich mit den entsprechenden C++11 Features auseinandergesetzt hat, ja. Man braucht den Standard nicht im Hinterkopf zu haben, geschweige denn ihn als Zitatvorlage zu nutzen, um das hinzuschreiben. " int i; definiert eine Variable vom Typ int." - Hab ich ausm Kopf geschrieben. Aber hey, könnte so ähnlich auch im Standard stehn, ich fühl mich ertappt.

    0
Anmelden zum Antworten