3. Klassen vererben..../ und compilieren...

Klassen vererben..../ und compilieren...

  • D

    Ich hatte bisher folgendes richtig laufendes Programm, aus folgenden 3 Dateien:

    main.cpp:

    #include <iostream>
#include "c2dpoint.h"

using namespace std;

int main() // Main-Function
{

C2dpoint myPoint (1.0,2.0);
C2dpoint *myDynamicPoint;
myDynamicPoint = new C2dpoint();

myPoint.setX(3);
myPoint.setY(4);
myDynamicPoint->setX(5);
myDynamicPoint->setY(6);

myPoint.show();
myDynamicPoint->show();

*myDynamicPoint=myPoint;

myPoint.show();
myDynamicPoint->show();

delete myDynamicPoint;
return 0;
}

    die c2dpoint.h:

    #ifndef C2DPOINT_H
#define C2DPOINT_H

/******************************************************************
Klasse setzt X und Y, gibt diese aus, und Kopiert ein ganzes Objekt
******************************************************************/

class C2dpoint
{

  public:     // public methods

  double getX ();                      // X-Wert wird zurückgegeben
  double getY ();                      // Y-Wert wird zurückgegeben
  void setX (double xx);               // Setzen des X-Wertes
  void setY (double yy);               // Setzen des Y-Wertes
  C2dpoint ();                         // Kontruktor mit leerer Schnittstelle
  C2dpoint (double xx, double yy);     // Kontruktor mit Setzen von X und Y
  C2dpoint (const C2dpoint & toCopy);  // Kopier-Konstruktor
  void copy (const C2dpoint & toCopy); // Kopier-Methode
  C2dpoint operator = (const C2dpoint & toCopy);  // Kopier Operator
  virtual void show ();                        // Ausgabe von X und Y

  private:     // private member fields

   double m_X;                         // Variable X
   double m_Y;                         // Variable Y

}; // end of class

#endif

    und die c2dpoint.cpp:

    #include <iostream>
#include "c2dpoint.h"
using namespace std;

// Rückgabe des X-Wertes
double C2dpoint::getX ()
{
return (m_X);
}

// Rückgabe des Y-Wertes
double C2dpoint::getY ()
{
return (m_Y);
}

// Setzen des X-Wertes
void C2dpoint::setX (double xx)
{
m_X = xx;
}

// Setzen des Y-Wertes
void C2dpoint::setY (double yy)
{
m_Y = yy;
}

// Standard Kontruktor mit leerer Schnittstelle
C2dpoint::C2dpoint ()
{
m_Y = 0.0;
m_X = 0.0;

}

// Kontruktor mit Setzen vcn X und Y
C2dpoint::C2dpoint (double xx, double yy)
{
m_X = xx;
m_Y = yy;
}

// Kopier-Kontruktor
C2dpoint::C2dpoint (const C2dpoint & toCopy)
{
copy(toCopy);
}

// Mehthode kopiert die Werte aus toCopy in obige Klasse
void C2dpoint::copy (const C2dpoint & toCopy)
{
m_X = toCopy.m_X;
m_Y = toCopy.m_Y;
}

// Methode zum Kopieren per "=" - Operator mit Überprüfung ob das zu kopierende Objekt nicht gleich der obigen Klasse ist.
C2dpoint C2dpoint::operator = (const C2dpoint & toCopy)
{
if (this!=&toCopy)
copy(toCopy);
}

// Methode zur Ausgabe von X und Y
virtual void C2dpoint::show ()
{
cout << "\nX ist gleich : "<< m_X;
cout << "\nY ist gleich : "<< m_Y;
cout << "\n\n";
}

    So,und jetzt ist folgende Aufgabenstellung gegeben:

    Leiten sie von C2dpoint eine Klasse c2dline mit den zusätzlichen privaten Feldern m_X2, m_Y2 ab. Erstellen sie hierfür wieder Kontruktoren, copy Funktion, Operator = und show Funktion. Für m_X2 und m_Y2 werden zusätzliche set und get Funktionen benötigt.

    Das hört sich ja so an als bräuchte ich alles in der neuen klasse doppelt,also was nützt dann noch vererbung,wenn man letztendlich eine neue Klasse hat,mit ner Vererbung,aber in der Klasse auch wieder alle Methoden ändern und anstatt X immer X2 hat, oder geht das anders...

    So wie ichs jetzt habe, sollte es laut Professorin gehen (vllt. noch ein bis zwei kleine Fehler), aber es geht noch gar nichts,und sieht auch nicht danach aus.

    Hier meine zusätzlichen beiden Dateien:

    c2dline.h

    # include "c2dpoint.h"
#ifndef C2DPOINT_H
#define C2DPOINT_H

/******************************************************************
Klasse setzt X und Y, gibt diese aus, und Kopiert ein ganzes Objekt
******************************************************************/

class C2dline : public C2dpoint
{

  public:     // public methods

  double getX2 ();                      // X-Wert wird zurückgegeben
  double getY2 ();                      // Y-Wert wird zurückgegeben
  void setX2 (double xx);               // Setzen des X-Wertes
  void setY2 (double yy);               // Setzen des Y-Wertes
  C2dline ();                         // Kontruktor mit leerer Schnittstelle
  C2dline(double xx, double yy);     // Kontruktor mit Setzen von X und Y
  C2dline (const C2dline & toCopy);  // Kopier-Konstruktor
//  void copy (const C2dline & toCopy); // Kopier-Methode
//  C2dline operator = (const C2dline & toCopy);  // Kopier Operator
  virtual void show ();                        // Ausgabe von X und Y
//  virtual ~C2dpoint();                 // Standard virtual Destruktor

  private:     // private member fields

   double m_X2;                         // Variable X
   double m_Y2;                         // Variable Y

//  static int m_Counter;

}; // end of class

#endif

    und die c2dline.cpp

    #include <iostream>
#include "c2dline.h"
using namespace std;

// Rückgabe des X-Wertes
double C2dline::getX2 ()
{
return (m_X2);
}

// Rückgabe des Y-Wertes
double C2dline::getY2 ()
{
return (m_Y2);
}

// Setzen des X-Wertes
void C2dline::setX2 (double xx)
{
m_X2 = xx;
}

// Setzen des Y-Wertes
void C2dline::setY2 (double yy)
{
m_Y2 = yy;
}

// Standard Kontruktor mit leerer Schnittstelle
C2dline::C2dline ()
{
m_Y2 = 0.0;
m_X2 = 0.0;

}

// Kontruktor mit Setzen vcn X und Y
C2dline::C2dline(double xx, double yy)
{
m_X2 = xx;
m_Y2 = yy;
}

// Kopier-Kontruktor
C2dline::C2dline (const C2dline & toCopy)
{
copy(toCopy);
}

// Mehthode kopiert die Werte aus toCopy in obige Klasse
/*void C2dline::copy (const C2dline & toCopy)
{
m_X2 = toCopy.m_X2;
m_Y2 = toCopy.m_Y2;
}

// Methode zum Kopieren per "=" - Operator mit Überprüfung ob das zu kopierende Objekt nicht gleich der obigen Klasse ist.
C2dline C2dline::operator = (const C2dline & toCopy)
{
if (this!=&toCopy)
copy(toCopy);
}*/

// Methode zur Ausgabe von X und Y
void C2dline::show ()
{
cout << "\nX ist gleich : "<< m_X2;
cout << "\nY ist gleich : "<< m_Y2;
cout << "\n\n";
}

//static int C2dpoint::m_Counter = 0;

    Irgendwas läuft auch schon bei der compilierung shcief, er erstellt keine neue c2dline.o datei,warum das nicht ?

    Hier mein Kompilierungs-script der ersten 2 dateien:

    g++ -c c2dpoint.cpp 
g++ -o aufgabe1 c2dpoint.o  main.cpp

    und hier das der neuen 2 KLassen

    g++ -c c2dpoint.cpp c2dline.cpp
g++ -o aufgabe1 c2dpoint.o c2dline.o main.cpp
    0
  • K

    Schau doch einfach mal nach den Fehlermeldungen die Dir der Compiler liefert.

    0
Anmelden zum Antworten