bin grade dabei mir etwas C++ anzueignen und komme an der Stelle Vererbung - Überschreiben von Konstruktoren nicht weiter. Programmiere schon seit längerer Zeit mir objektorientieren Programmiersprachen - verstehe also den Hintergrund - jedoch weiß ich nicht wie weiter.
Hier mal der Code:

#include <iostream>
#include <string>

using namespace std;

class Person {
    public:
        Person(string name, int age);
        void info() const;
    private:
        string name;
        int age;
};
Person::Person(string name, int age):
    name(name),
    age(age)
    {}
void Person::info() const {
    cout << "Name: " << name << endl << "Alter: " << age << endl;
}

class Pupil: public Person {
    public:
        Pupil(string name, int age, string _class);
        void info() const;
    private:
        string name;
        int age;
        string _class;
};
Pupil::Pupil(string name, int age, string _class):
    Person(name, age) {;}
    _class(_class)
    {}
void Pupil::info() const {
    cout << "Schüler " << name << endl << "Alter: " << age << endl
         << "Klasse: " << _class << endl;
}

int main() {
    Person ich("Blah", 900);
    ich.info();
    Pupil ichs("Blah", 900, "50c");
    ichs.info();
}

G++ wirft mir folgendes:

helloworld.cpp:33: Fehler: expected constructor, destructor, or type conversion before »(« token

Ich will mit `Pupil::Pupil` eigentlich nur den Konstruktor `Person::Person` überschreiben...

Pupil::Pupil(string name, int age, string _class):
    Person(name, age),
    _class(_class)
    {}

_class(_class)

Also der Unterstrich am Anfang des Bezeichners. Der könnte bereits von der Implementierung besetzt sein. (Was bei class nicht einmal unwahrscheinlich ist).

int main()
{
 Pupil *ppl = new Pupil("Horst", 16, 4); // ^^
 std::cout << ppl->GetName() << " != " << ppl->GetName2() << std::endl;
 delete ppl;
 system ("pause"); //siehe consolen faq, warum man das eigtl nich macht, sondern anders - und wie ^^
}

Wie du siehst, hab ich mal 2 Fkt geschrieben und dir nen kleines Beispiel gepostet - sollte eigtl rel. schnell klar werden, was ich dir damit sagen möchte ^^

bb

edit:

drakon schrieb:

Das hier sieht auch gefährlich aus.

_class(_class)

Also der Unterstrich am Anfang des Bezeichners. Der könnte bereits von der Implementierung besetzt sein. (Was bei class nicht einmal unwahrscheinlich ist).

glaub ich nicht dran...
imho ist nur folgendes reserviert:

__x //2 unterstriche - egal, was folgt
_A // 1 unterstrich und ein großbuchstabe

aber ich hätte den member so und so class genannt - wieso dort nen unterstrich davor und bei dem rest aber nicht? Oo
ich regel das eigtl immer so, dass variablenamen klein sind und übergebene namen (wie bei ctor oder settern) kann ich dann einfach mit Unterstrich (_varname und dann varname = _varname) schreiben...

2.edit: delete hinzugefügt ^^

bb

— Each name that begins with an underscore is reserved to the implementation for use as a name in the
global namespace.165)

17.4.3.1.2 schrieb:

— Each name that begins with an underscore is reserved to the implementation for use as a name in the global namespace.165)

"For use as a name": Heißt das nicht, dass bei einer Namensauflösung dem lokalen Bezeichner Vorrang gewährt würde und die Regel hier deshalb gar nicht in's Gewicht fällt?

Zudem sollte man Klassentypen wie std::string grundsätzlich als Const-Referenz anstatt als Kopie übergeben.

Öh... das verstehe ich (noch) nicht. Code wäre nett

unskilled schrieb:

aber ich hätte den member so und so class genannt - wieso dort nen unterstrich davor und bei dem rest aber nicht? Oo

Möglicherweise, weil `class` ein reserviertes Keyword ist?!

@_unterstrichschreibweise: Werd dann halt class_ nehmen

Naja - b2t:
Das spielt aber keine Rolle!?

int _class = 123; //

class abc
{
int _class;
public:
 abc (int _class_) : _class (_class_) {}
};

Egal, ob da iwas im globalen Namespace ist - lediglich Makros werden doof:

16.8.4 schrieb:

Any other predefined macro names shall begin with a leading underscore followed by an uppercase letter or a second underscore.

17.6.4.3.3 schrieb:

Each name that contains a double underscore _ _ or begins with an underscore followed by an uppercase letter (2.11) is reserved to the implementation for any use.

bb

Eine Const-Referenz-Übergabe sieht so aus:

Pupil(const string& Name, int Age, const string& Class);