ich arbeite schon länger an einem Programm, aber jetzt kommt plötzlich immer diese Fehlermeldung:

Unbehandelte Ausnahme bei 0x00843dd7 in Taschenrechner.exe: 0xC00000FD: Stack overflow.

Wenn ich Kompiliere wird kein Fehler angezeigt. Erst wenn ich das Progamm starte, kommt die Fehlermeldung. Das Konsolenfenster wird noch geöffnet aber zeigt nichts an.

Ich habe auch alle Veränderrungen an dem Programm, die ich vorgenommen habe seit es noch funktionierte, wieder rausgenommen. Es kommt trotzdem diese Fehlermeldung.
Was bedeutet diese Fehlermeldung und was kann ich dagegen machen?

Stack overflow bedeutet, dass zu viele Daten auf dem Stack liegen (Das ist der Bereich des Speichers, den ein Programm für statische Datenobjekte und Rücksprungadressen bei Funktionsaufrufen benutzt). Stack Overflow hat in den häufigsten Fallen eine dieser 2 Ursachen: a) Zu viele Funktionsaufrufe, weil man eine Endlosrekursion hat. b) Zu große/ zu viele Datenobjekte auf dem Stack (in der Regel sehr große statische Arrays).

Ich hatte einen Array deklariert (double f[100000]).
Das habe ich jetzt rausgenommen und es funktioniert.
Kann man keinen Array mit so vielen teilen benutzen?

Doch, kann man. Aber wenn du (vielleicht per Rekursion) viele Versionen dieses Arrays erzeugst, dann summiert sich das natürlich ganz schnell. Und der Stack ist nunmal begrenzt (z.B. 1 MB). Wenn der Stack für dich nicht ausreicht, musst du dynamisch Speicher auf dem Heap reservieren (mit new/new[]). Denk aber auch daran, ihn wieder freizugeben (mit delete/delete[]), sonst produzierst du Speicherlecks.

EDIT: Dein double-Array ist ja mit 100000 Elementen schon 800000 Bytes groß (bei sizeof(double)=8), also ca. 800 KB. Bis zum vollen MB ist es da nicht mehr weit (falls das deine Stack-Größe ist). Sowas sollte doch eher auf den Heap gepackt werden.

Wenn du ein solch grosses Array hast, dann nimmt man da üblicherweise ein dynamisches (also per new anfordern und mit delete wieder freigeben). Aber besser du nimmst ein std::vector , der macht dir die Verwaltung ganz automatisch.

Ich wollte eingentlich mit so nem goßem Array einen Funktionsgraphen zeichnen, aber der Aufwand ist dann wohl doch zu hoch und sprengt den Rahmen des Programms.

Danke für die Hilfe.

Ich wollte eingentlich mit so nem goßem Array einen Funktionsgraphen zeichnen, aber der Aufwand ist dann wohl doch zu hoch und sprengt den Rahmen des Programms.

Musst du denn unbedingt jeden Wert in einem Riesen-Array speichern oder reicht es nicht, wenn du den jeweiligen Wert der Funktion beim Zeichnen des Graphen berechnest?

cout << "\nGrundstrucktur: f(x) = 1.Koeffizient*x^n +...+ m.Koeffizient*x^n + Absolutglied";
				cout << "\n 0 =< n <= 10";
				cout << "\nFunktion eingeben, wobei das Absolutglied als letztes eingegeben wird und bei \nder darauffolgenden Abfrage einer Potenz von x 0 eingegeben wird" << endl;	
				for (int loop_x_pot=0; loop_x_pot==100;++loop_x_pot)
					x_pot[loop_x_pot]=1;

				f_zae=0;
				while (x_pot[f_zae-1]!=0)
				{
					++f_zae;
					cout << endl;
					cout << f_zae << ". Koeffizienten eingeben: "; 
					cin >> koeff[f_zae-1];
					cout << "Dazugehoerige Potenz von x eingeben: ";
					cin >> x_pot[f_zae-1];

				}
				cout << "\nBei welchem x-Wert soll begonnen werden?" << endl;
				cin >> x_wert1;
				cout << "\nBei welchem x-Wert soll die Tabelle enden?" << endl;
				cin >> x_wert2;
				schr = 0.0001;
				f_x, f_y =0;
				x_zaeler=0;
				fff=0;
				spx = 0;
				spy = 0;
				zp=1;
				f_x = 0;
				x_zaeler=-schr;
				for (double loop_tab1=x_wert1; loop_tab1<x_wert2; loop_tab1+=schr)
				{
					x_zaeler+=schr;
					f_x = koeff[f_zae-1];
					zp=1;
					for (int loop_i=0; loop_i<f_zae; ++loop_i)
					{
                        ++zp;
						if (x_pot[f_zae-zp] == 1)
						f_x+=koeff[f_zae-zp]*(x_wert1+x_zaeler);
						if (x_pot[f_zae-zp] == 2)
						f_x+=koeff[f_zae-zp]*(x_wert1+x_zaeler)*(x_wert1+x_zaeler);
						if (x_pot[f_zae-zp] == 3)
						f_x+=koeff[f_zae-zp]*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler);
						if (x_pot[f_zae-zp] == 4)
						f_x+=koeff[f_zae-zp]*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler);
						if (x_pot[f_zae-zp] == 5)
						f_x+=koeff[f_zae-zp]*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler);
						if (x_pot[f_zae-zp] == 6)
						f_x+=koeff[f_zae-zp]*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler);
						if (x_pot[f_zae-zp] == 7)
						f_x+=koeff[f_zae-zp]*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler);
						if (x_pot[f_zae-zp] == 8)
						f_x+=koeff[f_zae-zp]*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler);
						if (x_pot[f_zae-zp] == 9)
						f_x+=koeff[f_zae-zp]*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler)*(x_wert1+x_zaeler);
					}
					gotoxy (f_x, x_wert1+ff*schr);
					cout << ".";
					++spy;
					++fff;
				}

leider werden Die Punkte nur in eirner Reihe gesetzt.

gibt es da noch eine andere Möglichkeit, um eine Funktion zu zeichnen?

Und gotoxy ist eine Funktion, die dir den Cursor in der Konsole positioniert, ja (zeig die bitte auch mal)? Die Konsole ist aber ein wenig knapp bemessen, um Graphen zu "zeichnen"...

hier die gotoxy-Funktion:

HANDLE hOuput = GetStdHandle(STD_OUTPUT_HANDLE); 

void gotoxy (int x, int y) 
{ 
    COORD pos; 
    pos.X = x; 
    pos.Y = y; 
    SetConsoleCursorPosition(hOuput,pos); 
}

In dem obenstehenden Code wird est die Funktion eingelesen. Dann werden die x und y-Werte berechnet, wobei x-Werte im Abstand von 0.0001 verwendet werden.
Danach soll die Funktion gezeichnet werden. Dazu wird mit gotoxy der Cursor in der Konsole auf die jeweilige Position gebracht und ein Punkt gesetzt.
Leider funktioniert es nicht. Die Punkte kommen nur in einer Reihe und sind nicht eng beieinander.

Zeig mal den kompletten Code, da fehlen ja (mindestens) alle Deklarationen.

Der ganze Code umfasst 4923 Zeilen, weil dies ein Teil eines größeren Programms ist.
Aber hier mal die Deklarationen:

int zp=1;
long double f_x, f_y =0;
double x_zaeler=0;
int fff=0;
int spx = 0;
int spy = 0;
long double fx[100];
long double fy[100];
double schritte=0;
int ergg;
double x_wert1, x_wert2, schr;
double koeff[100];
double x_pot[100];		
int f_zae=0;

Gibt es eine andere Methode um Funktionen in der Konsole zu zeichnen?

Die Methode mit gotoxy und dem Punktsetzten funktioniert vermutlich nicht.

Gibt es eine andere Methode um Funktionen in der Konsole zu zeichnen?

Nee, funktioniert so nicht, weil die Konsole textbasiert ist und du nur 80*25 Zeichen "Auflösung" hast (das Maximum wäre 160*60 oder so, weiß ich nicht mehr genau). Daher können sind Punkte halt immer so weit auseinander, wie du schon festgestellt hast. Dass deine Punkte auf einer waagerechten Linie sind, liegt vermutlich daran, dass du feine Fließkomma-Abstufungen hast, die du für gotoxy wieder zu int castest. 1.1 und 1.4 ist als int natürlich beides 1...

Du müsstest schon auf Grafikmodus umstellen, und dazu brauchst du eine passende Bibliothek (ich kann dir leider keine nennen, in C++ habe ich das noch nie gemacht). Such ruhig mal in der Richtung im Internet.

Ich persönlich würde zu dem Zweck natürlich ein Windows-Programm schreiben und irgendein Bild-Control benutzen.