Ich soll aus einem Array mit Instanzen der Klasse Figur und deren Subklassen den Index bestimmen, an dem sich die Figur mit der größten Fläche befindet.

Die Baumstruktur sieht wie folgt aus:
FIGUR
KREIS || RECHTECK
||||||||||||| QUADRAT

Bis auf die Klasse Figur besitzen alle Klassen die Methode berechneFlaeche(), die die Fläche des Objektes ausgibt. Das Problem ist, dass bei direkten Instanzen der Klasse Figur die Funktion berechneFlaeche() einen Fehler ausgibt. Um herauszufinden, ob die jeweiligen Arrayelemente direkte Instanzen der Klasse Figur sind oder nicht, habe ich dynamic_cast verwendet.

Mein Code für die Suche nach dem Index sieht wie folgt aus:

int index=0;
	for(int i=0;i<sizeof(fig)-1;i++){
		//Berechnung der Fläche beim aktuellen Index
		double f1;
		Kreis* k1= dynamic_cast<Kreis*>(fig[i]);
		Quadrat* q1=dynamic_cast<Quadrat*>(fig[i]);
		Rechteck* r1=dynamic_cast<Rechteck*>(fig[i]);
		if (q1!=0){f1=q1->berechneFlaeche();}
		if (r1!=0){f1=r1->berechneFlaeche();}
		if (k1!=0){f1=k1->berechneFlaeche();}
		else{f1=0;}
		double f2;
		Kreis* k2= dynamic_cast<Kreis*>(fig[i+1]);
		Quadrat* q2=dynamic_cast<Quadrat*>(fig[i+1]);
		Rechteck* r2=dynamic_cast<Rechteck*>(fig[i+1]);
		if (q2!=0){f2=q1->berechneFlaeche();}
		if (r2!=0){f2=r1->berechneFlaeche();}
		if (k2!=0){f2=k1->berechneFlaeche();}
		else{f2=0;}
		if (f2>f1){index++;}

		}

Beim Kompilieren gibts keine Fehler/Warnungen.
Woran kann es liegen, dass das Programm abstürzt?

LG
Markus

Es gibt auch viele andere möglichen Gründe... Ist aber auch egal, du willst ja wissen, weshalb dein Programm abstürtzt, also zeig mal ein minimales Beispiel, das dein Problem zeigt.

Wie wird denn ein Exception vom Betriebssystem abgefangen

lol

Markus97 schrieb:

wie kann ich durch mein Code verhindern?

Indem man auf dynamic_cast und Konsorten verzichtet.

Was mir ins Auge springt ist gleich deine Abbruchbedingung

for(int i=0;i<sizeof(fig)-1;i++){

Ist das wirklich was du willst? Du willst hier doch alle Elemente des Arrays von Figuren iterieren, bzw. bis das vorletzte Element, da du ja auch mit i+1 indexierst.

Ich will mal folgendes minimale Beispiel zeigen:

#include <iostream>

int main()
{
    const std::size_t a = 5;
    int arr[a];
    std::cout << "Anzahl der Elemente im Array: " << a << '\n'
              << "sizeof(Array): " << sizeof(arr) << '\n'
              << "sizeof(int): " << sizeof(int) << '\n';
}

In Anderen Worten: sizeof() liefert hier nicht die Anzahl der Elemente in deinem Array, sondern die Größe als Vielfaches von sizeof(char) ( == 1) (hui, hoff das ist so ok rausgedrückt, sonst gebt mir halt aufn Deckel)
D.h. wenn du es mit sizeof machen willst, müsste es etwa so aussehen:

i < sizeof(arr) / sizeof(Figur) - 1
// was zum Problem wird, wenn du arr als Funktionsparameter übergeben willst.

Oder du nimmst einfach std::array, dann hast du diese ganzen Probleme nicht, denn std::array kennt sein Größe. Siehe http://www.cplusplus.com/reference/array/array/

Doch auch nach der Änderung stürzt das Programm leider ab:

int index=0;
	for(unsigned int i=0;i<(sizeof(fig)/sizeof(fig[0])) -1;i++){
		//Berechnung der Fläche beim aktuellen Index
		double f1;
		Kreis* k1= dynamic_cast<Kreis*>(fig[i]);
		Quadrat* q1=dynamic_cast<Quadrat*>(fig[i]);
		Rechteck* r1=dynamic_cast<Rechteck*>(fig[i]);
		if (q1!=0){f1=q1->berechneFlaeche();}
		if (r1!=0){f1=r1->berechneFlaeche();}
		if (k1!=0){f1=k1->berechneFlaeche();}
		else{f1=0;}
		double f2;
		Kreis* k2= dynamic_cast<Kreis*>(fig[i+1]);
		Quadrat* q2=dynamic_cast<Quadrat*>(fig[i+1]);
		Rechteck* r2=dynamic_cast<Rechteck*>(fig[i+1]);
		if (q2!=0){f2=q1->berechneFlaeche();}
		if (r2!=0){f2=r1->berechneFlaeche();}
		if (k2!=0){f2=k1->berechneFlaeche();}
		else{f2=0;}
		if (f2>f1){index++;}

		}

Wutze ich habe nach einer Funktion gesucht, die mir angibt, ob eine Instanz ein Element einer bestimmten Klasse ist oder nicht. Leider habe ich nichts gefunden, sodass ich dynamic_cast verwenden musste.

Das ist doch wohl eine Hierarchie à la

struct figur{
  virtual double flaeche() const = 0;
  virtual ~figur() = default;
};

struct kreis : figur{
  kreis(double r) : r(r){}
  double flaeche() const { return 3.1415 * r * r; }
  double r;
};

struct rechteck : figur{
  rechteck(double b, double h) : b(b), h(h){}
  double flaeche() const { return b*h; }
  double b, h;
};

struct quadrat : rechteck{
  quadrat(double b) : rechteck(b,b) {}
};

Typisches Lehrbeispiel also. Oder nicht?

Sry aber was bringt mir jetzt dein Beispiel?

LOL. Das ist genau der Trick dabei. Indem du dir Zeiger auf die Basisklasse figur hälst, musst du nie wissen, obs jetzt ein Rechteck, ein Kreis, oder sonst was ist. Du musst nur public ableiten, das hat Furble Wurble unterschlagen. dynamic_cast und alle anderen Varianten rauszufinden, obs eine Instanz einer Klasse ist, sind Mist, weil du damit deine Hierarchie nicht erweitern kannst. Jetzt schreibst du irgendwo noch eine Klasse Triangle, und schon musst du alle Stellen mit dem dynamic_cast anpassen. Genau deswegen gibts Ableitungen und Polymorphismus.

Ich will mal folgendes minimale Beispiel zeigen:

#include <iostream>

int main()
{
    const std::size_t a = 5;
    int arr[a];
    std::cout << "Anzahl der Elemente im Array: " << a << '\n'
              << "sizeof(Array): " << sizeof(arr) << '\n'
              << "sizeof(int): " << sizeof(int) << '\n';
}

In Anderen Worten: sizeof() liefert hier nicht die Anzahl der Elemente in deinem Array, sondern die Größe als Vielfaches von sizeof(char) ( == 1) (hui, hoff das ist so ok rausgedrückt, sonst gebt mir halt aufn Deckel)

Das Problem ist nur, was ist im Fall vom OP denn "fig"?
Ist das ein

Figure fig[n];

oder ein

Figure * fig = new Figure[n];
// bzw
Figure figs[n];
//...
Figure * fig = figs;

Weil wenn du ein Array-to-Pointer-Decay dabei hast, dann klappt der Trick mit dem sizeof nicht mehr. Da wird dann rauskommen sizeof(pointertype)/sizeof(type).

Abgesehen davon, dass ein Figure fig[n] auch gar nicht polymorph ist/sein kann.

@Markus97: Zeig mal die Definition von fig.

Ich dachte, dass alle Elemente eines Arrays dieselbe Speichergröße beanspruchen.

Auch wenn der Trick mit sizeof nicht funktioniert und ich es stattdessen mit einer 2 austausche, stürzt das Programm leider ab.

Geht aber schon in die richtige Richtung.

ein Figur*[3] hat übrigens auch nur 3 Elemente (0,1 und 2).
Und was soll der cast noch? Du weisst doch, dass das Array Figur* enthält.

Figur ist übrigens das Paradebeispiel für eine abstrakte (Basis-)Klasse. Wäre es nicht sinnvoll, wenn man keine Instanzen von Figur erstellen kann? Z.b. weil man eh nix damit machen kann?
Zeichnen? Was?
Flaeche berechnen? Wie?

Zu deinem Programm:
Wenn du das wirklich so geshcrieben hast, ohne Funktiosnaufruf zwischen den Figuren und der Schleife (sprich ohne, dass das Array zu einem pointer degeneriert) sollte das eigentlich klappen. Aber es geht auch besser.

Dann dein dynamic_cast ist immer noch unnötig, denn dein "Objekt" ist eine Figur (oder Unterklasse, aber damit ists auf jedenfall eine Figur!), du musst nicht nochmal eine Figur draus machen.
Der Nullcheck kann bleiben, aber prüf da gegen nullptr und nicht gegen 0.

Das hier wäre ein Vorschlag wie das ganze etwas eifnacher gehen würde.

std::vector<std::unique_ptr<Figure>> fig;
//std::array<std::unique_ptr<Figure>, 4> fig; // egal ob std::vector doer std::array

fig.push_back(std::make_unique<Figure>(0, -1));
fig.push_back(std::make_unique<Kreis>(0,0,1));
fig.push_back(std::make_unique<Rechteck>(0,1,2,2));
fig.push_back(std::make_unique<Quadrat>(0,2,3));

// Gebe die Figuren auf der Konsole aus.
for(auto const& f : fig)
	std::cout << f->asString() << std::endl;

for(unsigned int i = 0; i < fig.size()-1; i++)
{
	double f1 = (fig[i] == nullptr) ? 0 : fig[i]->berechneFlaeche();
	double f2 = (fig[i+1] == nullptr) ? 0 : fig[i+1]->berechneFlaeche();

	if (f2>f1)
		index++;
}

ein Figur*[3] hat übrigens auch nur 3 Elemente (0,1 und 2).

Stimmt, das habe ich übersehen. Leider stürzt die exe-Datei wieder ab.

Figur ist übrigens das Paradebeispiel für eine abstrakte (Basis-)Klasse. Wäre es nicht sinnvoll, wenn man keine Instanzen von Figur erstellen kann? Z.b. weil man eh nix damit machen kann?
Zeichnen? Was?
Flaeche berechnen? Wie?

Den Sinn dieser komischen Aufgabe hinterfrage ich erst garnicht
Laut Aufgabenstellung sollte ich es so programmieren.

Eine 0 habe ich aus dem Grund verwendet, weil ich bei Nullpointern die Fehlermeldung "nullptr was not declared in this scope" erhalte.

Hast du einen Debugger zur Hand? Wenn ja nutz ihn, dann siehst du wo es kracht (bzw solltest sehen).

Und zeig mal am besten den gesamten Quellcode, wenn er denn die paar hundert Zeilen nicht übersteigt.

Übrigens, für nullptr musst du glaub C++11 "aktivieren". (googeln)

@Skym0sh0:
"array-to-pointer-decay" Danke, genau so ein Begriff hat mir gefehlt
Ich wollte in meinem Beispiel auch eigentlich verdeutlichen, dass man da das "a" verwenden soll, also die eigentliche Größe, um eben solchen Problemen zuvorzukommen.

Ich will noch anmerken, dass solche "asString" "toString" methoden auch nicht gerade C++-like sind. Wozu kann man den << Operator überladen.
Und wirklich komplizierter ist das auch nicht, wenn man schon so eine toString Funktion hat.

#include "figur.hpp"

Figur::Figur(double pos_x, double pos_y)
  : pos_x(pos_x), pos_y(pos_y){}

Figur::~Figur(){}

void Figur::verschiebe(double dx, double dy)
{
  pos_x += dx;
  pos_y += dy;
}

std::string Figur::asString()
{
  return "Dies ist eine Figur. Koordinaten: ("
    + std::to_string(pos_x) + "," + std::to_string(pos_y) + ")";
}

hpp:

#ifndef FIGUR_HPP
#define FIGUR_HPP

#include <string>
#include "tostring.hpp"

class Figur
{
protected:
  // Attribute
  double pos_x;
  double pos_y;

public:
  // Konstruktor
  Figur(double pos_x, double pos_y);
  //Destruktor
  virtual ~Figur();
  // Verschiebt die Figur um dx in x-Richtung und um dy in y-Richtung.
  void verschiebe(double dx, double dy);
  // Gibt einen den die Figur beschreibenden String zurueck.
  virtual std::string asString();
};

#endif

main-Datei:

#include <iostream>

/* Das Einbinden der Header-Dateien wuerde 
 * ohne Include-Guards zum mehrfachen Einbinden
 * der selben Header-Datei (z.B. figur.hpp) fuehren. 
 */
#include "figur.hpp"
#include "kreis.hpp"
#include "rechteck.hpp"
#include "quadrat.hpp"

int main()
{

	//Erzeugung des Arrays mit den jeweiligen Figuren
	Figur* fig[4];
	fig[0]=new Figur(0,-1);
	fig[1]=new Kreis(0,0,1);
	fig[2]=new Rechteck(0,1,2,2);
	fig[3]=new Quadrat(0,2,3);

    // Gebe die Figuren auf der Konsole aus.
    std::cout << fig[0]->asString() << std::endl;
    std::cout << fig[1]->asString() << std::endl;
    std::cout << fig[2]->asString() << std::endl;
    std::cout << fig[3]->asString() << std::endl;

	int index=0;
	for(unsigned int i=0;i<2;i++){
		//Berechnung der Fläche beim aktuellen Index
		double f1;
		Kreis* k1= dynamic_cast<Kreis*>(fig[i]);
		Quadrat* q1=dynamic_cast<Quadrat*>(fig[i]);
		Rechteck* r1=dynamic_cast<Rechteck*>(fig[i]);
		if (q1!=0){f1=q1->berechneFlaeche();}
		if (r1!=0){f1=r1->berechneFlaeche();}
		if (k1!=0){f1=k1->berechneFlaeche();}
		else{f1=0;}
		double f2;
		Kreis* k2= dynamic_cast<Kreis*>(fig[i+1]);
		Quadrat* q2=dynamic_cast<Quadrat*>(fig[i+1]);
		Rechteck* r2=dynamic_cast<Rechteck*>(fig[i+1]);
		if (q2!=0){f2=q1->berechneFlaeche();}
		if (r2!=0){f2=r1->berechneFlaeche();}
		if (k2!=0){f2=k1->berechneFlaeche();}
		else{f2=0;}
		if (f2>f1){index++;}

		}
    // Verschiebe Figuren
    fig[0]->verschiebe(10,10);
    fig[1]->verschiebe(10,10);
    fig[2]->verschiebe(10,10);
    fig[3]->verschiebe(10,10);

    // Gebe die Figuren auf der Konsole aus
    std::cout << fig[0]->asString() << std::endl;
    std::cout << fig[1]->asString() << std::endl;
    std::cout << fig[2]->asString() << std::endl;
    std::cout << fig[3]->asString() << std::endl;

    // Bereinige Speicher.
    delete fig[0];
    delete fig[1];
    delete fig[2];
    delete fig[3];

}

if (q1!=0){f1=q1->berechneFlaeche();}
if (r1!=0){f1=r1->berechneFlaeche();}
if (k1!=0){f1=k1->berechneFlaeche();}
else{f1=0;}
double f2;
Kreis* k2= dynamic_cast<Kreis*>(fig[i+1]);
Quadrat* q2=dynamic_cast<Quadrat*>(fig[i+1]);
Rechteck* r2=dynamic_cast<Rechteck*>(fig[i+1]);
if (q2!=0){f2=q1->berechneFlaeche();}
if (r2!=0){f2=r1->berechneFlaeche();}
if (k2!=0){f2=k1->berechneFlaeche();}
//     hier: --^

main-Datei:

#include <iostream>

/* Das Einbinden der Header-Dateien wuerde 
 * ohne Include-Guards zum mehrfachen Einbinden
 * der selben Header-Datei (z.B. figur.hpp) fuehren. 
 */
#include "figur.hpp"
#include "kreis.hpp"
#include "rechteck.hpp"
#include "quadrat.hpp"

int main()
{
  
	//Erzeugung des Arrays mit den jeweiligen Figuren
	Figur* fig[4];
	fig[0]=new Figur(0,-1);
	fig[1]=new Kreis(0,0,1);
	fig[2]=new Rechteck(0,1,2,2);
	fig[3]=new Quadrat(0,2,3);

    // Gebe die Figuren auf der Konsole aus.
    std::cout << fig[0]->asString() << std::endl;
    std::cout << fig[1]->asString() << std::endl;
    std::cout << fig[2]->asString() << std::endl;
    std::cout << fig[3]->asString() << std::endl;
	
	
	
	int index=0;
	for(unsigned int i=0;i<2;i++){
		//Berechnung der Fläche beim aktuellen Index
		double f1;
		Kreis* k1= dynamic_cast<Kreis*>(fig[i]);
		Quadrat* q1=dynamic_cast<Quadrat*>(fig[i]);
		Rechteck* r1=dynamic_cast<Rechteck*>(fig[i]);
		if (q1!=0){f1=q1->berechneFlaeche();}
		if (r1!=0){f1=r1->berechneFlaeche();}
		if (k1!=0){f1=k1->berechneFlaeche();}
		else{f1=0;}
		double f2;
		Kreis* k2= dynamic_cast<Kreis*>(fig[i+1]);
		Quadrat* q2=dynamic_cast<Quadrat*>(fig[i+1]);
		Rechteck* r2=dynamic_cast<Rechteck*>(fig[i+1]);
		if (q2!=0){f2=q1->berechneFlaeche();}
		if (r2!=0){f2=r1->berechneFlaeche();}
		if (k2!=0){f2=k1->berechneFlaeche();}
		else{f2=0;}
		if (f2>f1){index++;}
		
		}
    // Verschiebe Figuren
    fig[0]->verschiebe(10,10);
    fig[1]->verschiebe(10,10);
    fig[2]->verschiebe(10,10);
    fig[3]->verschiebe(10,10);

    // Gebe die Figuren auf der Konsole aus
    std::cout << fig[0]->asString() << std::endl;
    std::cout << fig[1]->asString() << std::endl;
    std::cout << fig[2]->asString() << std::endl;
    std::cout << fig[3]->asString() << std::endl;

    // Bereinige Speicher.
    delete fig[0];
    delete fig[1];
    delete fig[2];
    delete fig[3];
}

Ähm...jetzt bin ich baff...

Bist Du sicher dass Du die Aufgabe richtig verstanden hast? Gibt es dazu einen Lehrer oder Prof, bei dem Du nachfragen kannst?

Und noch eins:

// Gebe die Figuren auf der Konsole aus
    std::cout << fig[0]->asString() << std::endl;
    std::cout << fig[1]->asString() << std::endl;
    std::cout << fig[2]->asString() << std::endl;
    std::cout << fig[3]->asString() << std::endl;

Kennst Du einen Mechanismus in C++, der ohne copy&paste einen Programmabschnitt x-mal wiederholt?

Und noch eins:
C++:
// Gebe die Figuren auf der Konsole aus
std::cout << fig[0]->asString() << std::endl;
std::cout << fig[1]->asString() << std::endl;
std::cout << fig[2]->asString() << std::endl;
std::cout << fig[3]->asString() << std::endl;
Kennst Du einen Mechanismus in C++, der ohne copy&paste einen Programmabschnitt x-mal wiederholt?

Ja natürlich kenne ich da einen Mechanismus^^ Nur war die Aufgabe so gegeben.

Nur war die Aufgabe so gegeben.

Vielleicht eine pädagogische Volte...

Guten Rutsch jedenfalls!