Ausgabe ohne überschreiben der Methode

Hallo Leute,
nun brauch ich mal eine wenig Hilfe.
Ich soll eine Aufgabe lösen.

Die Klasse elternBaer ist von der Klasse baer abgeleitet und verfügt über eine eigene Methode ausgeben(), die die Methode ausgeben() der Basisklasse überschreiben soll.

Wie lautet der vollständige Name der Methode, die in der Schleife in "int main(array<System::String ^> ^args)" aufgerufen werden, wenn die Methode ausgeben() in der Basisklasse nicht als virtual vereinbart ist? Geben Sie die Namen bitte im Format *Klassenname::Methodenname*an.

#include "stdafx.h"

using namespace System;

//die Klasse baer

ref class baer
{

protected:

	Int32 gewicht;

	Int32 alter;

public:

	//der Konstruktor

	baer(Int32, Int32);

	Int32 gewichtLiefern();

	Int32 alterLiefern();

	~baer();

	!baer();

	void ausgeben();

};

ref class elternBaer : baer 
{

	Int32 anzahlKinder;

public:

	//der Konstruktor

	elternBaer(Int32, Int32, Int32);

	Int32 kinderLiefern();

	void schock();

	~elternBaer();

	!elternBaer();

	//die überschriebene Methode

	void ausgeben();

};

//die Methode für die Klasse baer

//der Konstruktor

baer::baer(Int32 tGewicht, Int32 tAlter)
{
	gewicht = tGewicht;

	alter = tAlter;
}

//die Methode leifert das Gewicht zurück

Int32 baer::gewichtLiefern()
{
	return gewicht;
}

//die Methode liefert das Alter zurück

Int32 baer::alterLiefern() 
{
	return alter;
}

//die Ausgabemethode

void baer::ausgeben()
{
	//bitte jeweils in einer Zeile eingeben

	Console::WriteLine("Die Ausgabe erfolgt aus der Klasse baer.\n");

	Console::WriteLine("Der Bär ist {0} Jahre alt und wiegt {1} Kilo.\n", alter, gewicht);
}

baer::~baer()
{
	Console::WriteLine("Der Destruktor in der Klasse baer wurde aufgerufen.\n");
}

baer::!baer()
{
	Console::WriteLine("Der Finalisierer in der Klasse baer wurde aufgerufen.\n");
}

//die Methoden für die Klasse elternBaer

//der Konstruktor

elternBaer::elternBaer(Int32 tGewicht, Int32 tAlter, Int32 tKinder) : baer(tGewicht, tAlter)
{
	anzahlKinder = tKinder;
}

Int32 elternBaer::kinderLiefern()
{
	return anzahlKinder;
}

//die Eltern erleiden einen Schock

void elternBaer::schock() 
{
	gewicht--;
}

//die überschriebene Methode zur Ausgabe

void elternBaer::ausgeben() 
{
	//bitte jeweils in einer Zeile eingeben

	Console::WriteLine("Die Ausgabe erfolgt aus der Klasse elternBaer.\n");

	Console::WriteLine("Der Bär ist {0} Jahre alt, wiegt {1} Kilo und hat {2} Kinder.\n", alter, gewicht, anzahlKinder);
}

elternBaer::~elternBaer()
{
	Console::WriteLine("Der Destruktor in der Klasse elternBaer wurde aufgerufen.\n");
}

elternBaer::!elternBaer()
{
	Console::WriteLine("Der Finalisierer in der Klasse elternBaer wurde aufgerufen.\n");
}

int main(array<System::String ^> ^args)
{
   	array <baer^> ^baerenliste = 

	{gcnew baer(200,20),gcnew elternBaer(150,10,2)};

	for each (baer^ testBaer in baerenliste)
	{
		testBaer->ausgeben();

		delete testBaer;
	}

    return 0;
}

Ich habe keinen Schimmer wie ich auf die Methode ausgeben() in der Klasse baer und in der Unterklasse elternBaer zugreifen soll.

Ich sitze nun schon fast die ganze Nacht dran, aber ohne Erfolg.

Vielleicht denke ich ja wieder völlig schief.
Kann mir da vielleicht jemand einen Denkanstoß geben?
Wäre euch immer zum Dank verpflichtet.

Gruß Doug_HH

Centurio

Hi doug, der Beitrag ist schon was älter sehe ich. Aber wollt mal fragen wie es auschaut bist weiterkommen ?

DanielK.

Hi,

ich habe gerade das selbe Problem, ich habe schon den ganzen Sonnabend daran verheizt,diese Problem zu lösen. Leider bisher ohne Erfolg.

Hast Du zwischenzeitlich eine Lösung?

Gruß Daniel

Jochen Kalmbach

Weiss zwar nicht, ob ich die Frage jetzt korrekt verstanden habe...

using namespace System;

ref class baer
{
public: void ausgeben() { Console::WriteLine("baer"); }
};
ref class elternBaer : baer
{
public: void ausgeben() { Console::WriteLine("elternBaer"); } 
};

int main()
{
  array<baer^> ^bl = {gcnew baer(), gcnew elternBaer()};
  for each(baer ^b in bl)
  {
    if (dynamic_cast<elternBaer^>(b) != nullptr)
      ((elternBaer^)b)->ausgeben();
    else
      b->ausgeben();
  }
}

baer::ausgeben()

Da die Methode nur eine statische Bindung hat, wird sie nicht überschrieben.
Deswegen wird nur die Methode bear::ausgeben() aufgerufen.

Jochen Kalmbach

War das jetzt die Antwort auf die Frage?

Ja, das ist die Antwort auf die Frage.
Gibt eine eins in der Schule.
Die 1 hab ich selber bekommen.
Man sollte nicht zu quer denken, hat mein Lehrer gesagt...

Gruß

Jochen Kalmbach

Dann sag aber mal Deinem Lehrer, dass er zuerst mal Deutsch lernen soll...

"Wie lautet der vollständige Name der Methode, die in der Schleife in "int main(array<System::String ^> ^args)" aufgerufen werden"

Entweder ist das "werden" falsch oder das "Methode"...

Das kann ich den doch nicht so vorm Kopf knallen.
Setzen, sechs.
Da sind noch mehr solche Teile, glaub mir.
Wenn Du dann was sagst, dass ist jetzt nich das Thema!
Deswegen bin ich hier doch unter einem Nick drin.

Gruß