ich beschäftige mich Hobby mäßig mit C++ und habe noch nicht sehr viel Erfahrung mit C++.
Nun bin ich aber bei Konstruktoren und deren Vererbung auf ein Problem gestoßen und ich hoffe das mir hier jemand weiterhelfen kann.

Ich habe die folgenden 2 Klassen:

class Hersteller
{
      private:
             char name[80];

      public:
             friend ostream& operator<<(ostream& out, const Hersteller&);

             Hersteller(char *);
             const char * getName() const;
};

(Die Funktionen der Hersteller Klasse habe ich implentiert)

class Modell
{

      private:
              Hersteller & hersteller;
              char bez[60];
              char ausfuehrung[120];
              int leistung;
              int hubraum;

      public:
              friend ostream& operator<<(ostream& out, const Modell&);

              Modell(Hersteller&, char *, char *, int, int);
              Hersteller & getHersteller() const;
              const char * getBez() const;
              const char * getAusfuehrung() const;
              int getLeistung() const;
              int getHubraum() const;
};

An dieses Stelle komme ich schon beim implementieren des Modell-Konstruktors nicht weiter und würde mich freuen wenn mir jemand helfen könnte.

(Mein derzeitger Konstruktor sieht so aus:)

Modell :: Modell(Hersteller& hst, char * _bez, char * _ausfuehrung, int _leistung, int _hubraum)
{
       phst = &hst;
       strncpy(bez, _bez, 60);
       strncpy(ausfuehrung, _ausfuehrung, 120);
       this->leistung = _leistung;
       this->hubraum = _hubraum;
}

Mit freundliche Grüßen

Björn

In constructor 'Modell::Modell(Hersteller&, char *, char *, int, int)':
no matching function for call to 'Hersteller::Hersteller()'
candiates are: Hersteller::Hersteller(const Hersteller&)
Hersteller::Hersteller(char

uninitialized reference member 'Modell::Hersteller'

Ich interpretiere die Fehlermeldung so, dass der Compiler nicht weiss welche Funktion er aufrufen soll, habe allerdings keine Ahnung wie ich ihm sagen soll welche er verwenden soll.

Ich hatte das "phst" schon einmal im protected Bereich implementiert aber dann erhalte ich folgende Fehlermeldung:

Die Fehlermeldung deutet eher darauf hin, dass du statt einer Referenz einen normalen Member hattest.

So oder so musst du deinen Hersteller-Member in der Initialisierungsliste des Modell-Konstruktors initialisieren, denn nachträgliches Zuweisen im Konstruktor selbst geht weder bei Referenzen noch bei Objekten von Klassen, die keinen Defaultkonstruktor haben.

ich beschäftige mich Hobby mäßig mit C++ und habe noch nicht sehr viel Erfahrung mit C++.

Merke ich, da du auch keine Vererbung im Beispiel verwendest [Vererbung: A ist ein B], aber von dieser sprichst (Du verwendest Komposition [Komposition: A enthält ein B]).

BjoVo schrieb:

Nun bin ich aber bei Konstruktoren ... auf ein Problem gestoßen

(Falsches durch ... gestrichen)

Und bitte verwende nicht die code- sondern die cpp-Tags für C/C++ Code (Der Button liegt direkt neben den Code-Button)...

1. Mach dir das leben leichter, und arbeite mit der std::string klasse statt mit char-Arrays.
2. Niemals "using namespace std" im Header!
3. Bitte keine Kryptischen Abkürzungen (bez für Bezeichnung...)
4. Ich würde im Header Parameter immer Ausschreiben. Man sollte niemals gezwungen sein in die Implementierung zu schauen um die Parameter zu verstehen (Unterstützt auch die Regel: Programmiere immer gegen die Schnittstelle, niemals die Implementierung).

Ich passe mal etwas an:

// Hersteller.h
#ifndef HERSTELLER_HEADER
#define HERSTELLER_HEADER

#include <string>
#include <ostream>

class Hersteller
{
    private:
        std::string name;

    public:
        friend std::ostream& operator<<(
            std::ostream &,
            Hersteller const &);

        Hersteller(
            std::string const & name);

        std::string getName() const;
};

std::ostream& operator<<(
    std::ostream & out,
    Hersteller const & hersteller);

#endif // HERSTELLER_HEADER

// Modell.h
#ifndef MODELL_HEADER
#define MODELL_HEADER

#include <string>
#include <ostream>

class Hersteller; // Vorwärtsdeklaration

class Modell
{
    private:
        Hersteller & hersteller;
        std::string bezeichnung;
        std::string ausfuehrung;
        int leistung;
        int hubraum;

    public:
        friend std::ostream& operator<<(
            std::ostream &,
            Modell const &);

        Modell(
            Hersteller & hersteller,
            std::string const & bezeichnung,
            std::string const & ausfuehrung,
            int leistung,
            int hubraum);

        Hersteller & getHersteller() const;
        std::string getBez() const;
        std::string getAusfuehrung() const;
        int getLeistung() const;
        int getHubraum() const;
};

std::ostream& operator<<(
    std::ostream& out,
    Modell const & modell);

#endif // MODELL_HEADER

BjoVo schrieb:

An dieses Stelle komme ich schon beim implementieren des Modell-Konstruktors nicht weiter und würde mich freuen wenn mir jemand helfen könnte.

Refernzen lassen sich nur initialisieren, niemals zuweisen. Was du machst ist eine Zuweisung, den die Initialisierung erfolgt vor dem Konstruktorrumpf. Stichwort hier ist die Initialisierungsliste.

Modell::Modell(
    Hersteller & hersteller,
    std::string const & bezeichnung,
    std::string const & ausfuehrung,
    int leistung,
    int hubraum)
:   hersteller(hersteller),    // Initialisierungsliste
    bezeichnung(bezeichnung),  // Schreibweise hier "<Membername>(<Wert>)"
    ausfuehrung(ausfuehrung),  // Begonnen wird das ganze mit einen Doppelpunkt.
    leistung(leistung),        // Jede Initialisierung mit Komma trennen, und
    hubraum(hubraum)           // nach möglichkeit Reihenfolge wie in der
{   // Deklaration verwenden, da die Initialisierung in dieser Reihenfolge
}   // geschieht, egal wie du sie hier angibst

Und "phst = &hst" ist eh falsch. Du arbeitest mit einer Referenz, nun willst du wohl einen Zeiger zuweisen (Ich deute mal das p als Pointer), laut deinen Beispiel ist aber eine Referenz im Header deklariert.

cu André