Infos über neuen C++-Standard? Thread Nr.2

Gerard

Original erstellt von Lars:
**Whats the sence of the possibility to overload the postfix operator?
Why is the postfix operator not auto-implemented?
That would has the advantage that compiler could optimize postfix-uses (even it
is a mistake of the programmer, that he used the postfix one).
**

ich glaube das die sich ähnliche gedanken zu c++98 gemacht haben, es gibt bestimmt gute gründe wieso man die postfix version überladen darf.
Aber mir kann eine änderung sowieso egal sein, wie oft überlade ich den, den op++?
und mit meiner eselsbrücke langammer postfix == häslicher int dummy kann ich mir das relativ leicht merken

Lars

Original erstellt von Dimah:
**
ich glaube das die sich ähnliche gedanken zu c++98 gemacht haben, es gibt bestimmt gute gründe wieso man die postfix version überladen darf.
Aber mir kann eine änderung sowieso egal sein, wie oft überlade ich den, den op++?
und mit meiner eselsbrücke langammer postfix == häslicher int dummy kann ich mir das relativ leicht merken**

Es geht ja gar nicht um Lesbarkeit oder Hässlichkeit des int-dummys, sondern um Redudanz und Optimierung. Ich hab folgende Antwort erhalten:

One could say something similar about operator + and operator += :
class Example
{
public:
   Example& operator += (const Example& other)
   {  // implementation
      return *this;
   }

   Example operator + (const Example& other) const
   {
      Example temp(*this);
      temp+=other;
      return temp;
   }
};

and perhaps more examples; if you allow me, let me generalize your
proposition by using some directive to let the compiler know : "I want
this method: auto-implement it", for example with the already existent
'auto' keyword.

An 'auto-implementation' table should be standarized (i.e. saying:
method    auto-implemented using
------    ----------------------------
++(int)   ++()
+         +=
...       ...

and a standard auto-implementation for each one (left column).

Your example would look like:

class Example
{
public:
   Example& operator += (const Example& other)
   {  // implementation
      return *this;
   }

   auto Example operator + (const Example& other) const;

   Example& operator ++ ()
   {  /* your example */ }

   auto Example operator ++(int);
};

I think this is important in terms of optimization and readability (as
far as the client 'see' that some operator is auto-implemented).

 Daniel.

genau das halt ich auch für sinnvoll

HumeSikkins

Hallo,
hat jetzt eigentlich schon jemand ein Vorschlag für ein foreach ohne typeof gemacht?

Wenn nein, hier meiner:

struct ForEachHelper
{
    void* cur_;
    template <class T, class U>
    bool assign (T& r, U& c)
    {
        typedef typename U::iterator iter;
        if (*static_cast<iter*>(cur_) != c.end())
        {
            r = **static_cast<iter*>(cur_);
            ++*static_cast<iter*>(cur_);
            return true;
        }
        delete static_cast<iter*>(cur_);
        return false;
    }
    template <class U>
    ForEachHelper(U& cont)
    {
        typedef typename U::iterator iter;
        cur_ = (void*)new  iter(cont.begin());
    }
};

#define FOREACH(var, cont) for (ForEachHelper b(cont) ; b.assign(var,cont);)

Anwendung:

vector<int> vec;
vec.push_back(6);
vec.push_back(5);
vec.push_back(4);
int n;
FOREACH(n, vec)
{
    cout << n << endl;
}
set<string> s;
s.insert("abc");
s.insert("cde");
s.insert("efg");
string str;
FOREACH(str, s)
{
    cout << str << endl;
}

Bashar

lol, da hätte man eigentlich früher drauf kommen können. Statt den deklarierten Typ zu parametrisieren, einfach bei jeder Anwendung davon einen parametrisierten Cast benutzen

nice

cur_ = (void*)new iter(cont.begin());

Warum nimmst Du nen C-Style-Cast hier?
Dass man seinen Iterator auf den Heap legen muss is performance-mäßig auch ein bisschen traurig.

Aber ziehmlich cool eigentlich. Werd ich mal verwenden und mich vielleicht sogar dran gewöhnen

HumeSikkins

Warum nimmst Du nen C-Style-Cast hier?

Um etwas Inkonsistenz reinzubringen und damit den Leser wach zu halten

Dass man seinen Iterator auf den Heap legen muss is performance-mäßig auch ein bisschen traurig

Richtig. Das ist ein echter Nachteil. Allerdings lässt sich dieser zur Not auch umgehen. Man muss ja nur new passend überladen.

Was wird der nächste Standard beinhalten? Templatetypedefs?

otze

*** schrieb:

Was wird der nächste Standard beinhalten? Templatetypedefs?

das wär mal was

//edit wow is der thread schon alt

Michael E.

Wie wärs mal mit nem neuen Thread. Auf den ersten kann man leider schon nicht mehr zugreifen

Wie stehts eigentlich im Moment um C++0x? Welche Änderungen gibts? Ach, ich mach jetzt einfach nen neuen auf.

was beudetet eigentlich C++0x?

Michael E.

0x steht für das Erscheinungsjahr.

ness

*** schrieb:

Was wird der nächste Standard beinhalten?

Template-Parameter als friends deklarieren zu können

ness schrieb:

*** schrieb:

Was wird der nächste Standard beinhalten?

Template-Parameter als friends deklarieren zu können

auch sowas wie Hummes dirstream?

Weiß schon einer wann der neue Standard kommt? Kommt der schon im nächsten Jahr? Welche Compiler werden ihn unterstützen?

guyondrugs

Wie wäre es denn, wenn du einfach mal den neuen Thread zu diesem Thema liest?
http://www.c-plusplus.net/forum/viewtopic.php?t=97205