void f(int const) {}
void f(int) {}

sind doch verschiedene parameter!

void foo(const int);

// ...

const int i;
int j;
f(i);
f(j);

Das wäre alles das gleiche, da das const im foo hier bloß ein Implementierungsdetails von foo wäre, kein Teil der Schnittstelle.

Das hier ist sehr wohl zulässig:

void f(int &&){}
void f(int const&) {}
void f(int) {}

After producing the list of parameter types, any top-level cv-qualifiers modifying a parameter type are deleted when forming the function type.

Das ist der Natur der Sprache innewohnend, da bei einer solchen Überladung für beide Varianten äußerlich kein Unterschied existiert und damit immer eine Ambiguität entsteht.

Edit: Dritter? Sagt mal, seid ihr auch ständig auf Streife?

§8.3.5/5 schrieb:

After producing the list of parameter types, any top-level cv-qualifiers modifying a parameter type are deleted when forming the function type.

Aber nur von den Parametertypen! Eine const-Überladung des Rückgabetyps wäre in Ordnung.

Sone schrieb:

§8.3.5/5 schrieb:

After producing the list of parameter types, any top-level cv-qualifiers modifying a parameter type are deleted when forming the function type.

Aber nur von den Parametertypen! Eine const-Überladung des Rückgabetyps wäre in Ordnung.

Edit: Ach, du bist ein offensichtlicher Troll!

obvious troll schrieb:

Sone schrieb:

§8.3.5/5 schrieb:

After producing the list of parameter types, any top-level cv-qualifiers modifying a parameter type are deleted when forming the function type.

Aber nur von den Parametertypen! Eine const-Überladung des Rückgabetyps wäre in Ordnung.

Edit: Ach, du bist ein offensichtlicher Troll!

Bevor da noch jemand drauf reinfällt, hier die Richtigstellung:

C++Standard, 13.1/2 schrieb:

Function declarations that differ only in the return type cannot be overloaded.

class C {
    public:
        void f(int i) {
                cout << "non-const" << endl;
        }
        void f(int i) const {
                cout << "const" << endl;
        }
};

Hier kommt es aber auf die constness des Objektes an und nicht des Parameters.

Etwas ähnliches geht aber im Zusammenhang mit Memberfunktionen:

class C {
    public:
        void f(int i) {
                cout << "non-const" << endl;
        }
        void f(int i) const {
                cout << "const" << endl;
        }
};

Hier kommt es aber auf die constness des Objektes an und nicht des Parameters.

Nope. Du hast wohl nicht verstanden, was top-level cv-qualifiers bedeutet.

Nope. Du hast wohl nicht verstanden, was top-level cv-qualifiers bedeutet.

Doch. Vllt. hast du nicht verstanden, was "modifying a parameter type" bedeutet.

Nope. Du hast wohl nicht verstanden, was top-level cv-qualifiers bedeutet.

Doch. Vllt. hast du nicht verstanden, was "modifying a parameter type" bedeutet.

Der this -Parameter hat aber keinen top-level cv-qualifier (welcher indes den Zeiger selbst konstant macht, was aber überflüssig ist, da this ein prvalue ist), sondern nur einen, der den Pointee-Typen verändert.

Und was soll 'modifying a parameter type' heißen? Den Parametertypen verändern, auf gut Deutsch....

http://stackoverflow.com/questions/3056655/can-overloading-is-possible-with-two-version-of-function-constant-member-functi
http://prashanth-cpp.blogspot.de/2007/08/overloading-const-and-non-const-member.html

edit: S. 444, Kap. 16.3.2: Iterators
http://books.google.de/books?id=KW1F9GPUFjkC&pg=PA489&lpg=PA489&dq=stroustrup+16.3.2+iterators&source=bl&ots=zn_U2O7DKt&sig=Leueq0ulKtNJnhzj-Px7Ju2qTW8&hl=de&sa=X&ei=YBFLUrjPM6aU4ASr44DIAQ&ved=0CFsQ6AEwBg#v=onepage&q=stroustrup 16.3.2 iterators&f=false

Der "this"-Pointer ist aber kein Parameter der Parameterliste, nur ein impliziter Parameter.

Natürlich geht Overloading, das streitet doch keiner ab!
Es hat nur nichts mit dieser Regel zu tun. Denn, wie So'n eifrige Standardzitierer* schon sagte, this hat kein top-level cv.

*Hehe, Wortwitz.

impliziter Parameter.

Was soll denn das sein?

Gut, ich sollte mich hüten, von Parametern zu reden. Aber hier noch mehr STandard:

The type of this in a member function of a class X is X* .
If the member function is declared const , the type of this is const X* , if the member function is declared volatile , the type of this is volatile X* , and if the member function is declared const volatile , the type of this is const volatile X* .

Hehe, Wortwitz.

Gut, dieser ist nicht gut, aber seis drum: "Was hast n'a 'tan?" (Kurz für Was hast' denn da getan?)

Natürlich geht Overloading, das streitet doch keiner ab!

Doch, noope. Zitat:

Nope.

Ich sprach ja auch von etwas ähnlichem.

Sone schrieb:

impliziter Parameter.

Was soll denn das sein?

Einer der nicht explizit angegeben ist. :p

Natürlich geht Overloading, das streitet doch keiner ab!

Doch, noope. Zitat:

Nope.

Das bezieht sich auf das Ähnliche.