Hier muss ich jetzt nicht schreiben: B b();

#include <iostream>
using namespace std;

class A
{
public:
        int f;
};
class B : public A
{
public:
};

int main(int argc, char* argv[])
{
A a;
B b;

system("PAUSE");
return 0;

Wo ist der Unterschied zwischen: B b; und B b();

Warum im ersten Fall kein Defaultkonstruktor automatisch generiert werden kann ist dir aber klar, oder?

Warum im ersten Fall kein Defaultkonstruktor automatisch generiert werden kann ist dir aber klar, oder?

Das hängt wohl irgendwie mit der Vererbung zusammen.^^

Aber ich habs jetzt hinbekommen:

#include <iostream>
using namespace std;

class A
{
public:
        int f;
        A();
        A(int p);
};

A::A()
{ }

A::A (int p) : f(p)
{ }

class B : public A
{
public:
string name;

B();
B ( string s );

};

B::B()
{ }

B :: B ( string s ) : name(s)
{ }

int main(int argc, char* argv[])
{
A a(4);
B b("a");
B bb;

system("PAUSE");
return 0;
}

Wenn ich zuhause bin werd ich mal in meinem Buch das Kaptiel Vererbung aufschlagen. ^^

Macht es Sinn, A ohne Parameter erzeugen zu können?

Ist das A dann trotzdem in einem gültigen Zustand (das heißt hier konkret, dass der Wert A::f nicht initialisiert ist)?

1. Nein, denn ich will ja die Variable f initialisieren.
2. Nein, ich will doch gerade das dass f initialisiert ist.

SeppJ schrieb:

Falls ein A nicht sinnvoll ohne Parameter erzeugt werden kann, musst du diese Parameter in der Initialisierungsliste von B angeben.

Soll der Konstruktor aus A dann entfernt werden und in B eingebaut werden oder wie ist das zuverstehen?

#include <iostream>
using namespace std;

class A
{
public:
 int f;
 A(int para);
};
A::A( int para) : f(para) {}

class B : public A
{
public:
 B(int para); 
};
B::B(int para): A(para) {}   // Guckst du hier

int main(int argc, char* argv[])
{
A a(4);
B b(4); // So ist es nun richtig
}