Eine heutige kurze einführende Erörterung unseres Dozenten, ganz neu ist mir das Thema nicht, von Stack und Heap, hat mich zu einer Frage veranlasst, von der ich befürchte, dass sie in den wenigen noch verbleibenden Kurstagen vielleicht nicht beantwortet wird.
Bekanntlich können rekursive Funktionsaufrufe den verfügbaren Speicher (Stack) überstrapazieren.
Hier, vielleicht eher des reinen Spaßes willen eine Übungsaufgabe, die ich für mich durch Rekursion gelöst habe.
Code: Alles auswählen
#include <iostream>
using namespace std;
unsigned short countCarry( unsigned int eins, unsigned int zwei,
unsigned int carry, unsigned int uebertraege )
{
// Die letzten Ziffern beider Zahlen ermitteln:
unsigned int n1 = eins % 10;
unsigned int n2 = zwei % 10;
// Beide Ziffern und einen eventuell bestehenden Uebertrag addieren und
// dabei feststellen, ob es einen Uebertrag gibt und wie gross er ist:
unsigned sum = n1 + n2 + carry;
if ( sum > 9 ) // Gegebenenfalls den Uebertragszaehler um eins erhoehen:
{
uebertraege += 1;
carry = sum / 10;
}
/*
cout << "n1 = " << n1 << " / n2 = " << n2 << " / sum = " << sum << endl;
cout << "new eins: " << eins / 10 << " / new zwei: " << zwei / 10;
cout << " / carry: " << carry << " / uebertraege: " << uebertraege << endl;
cout << endl;
*/
if (eins / 10 > 0 || zwei / 10 > 0 || sum > 10)
{
// Die Ausgangszahlen durch 10 geteilt als neue Ausgangszahlen benutzten.
uebertraege = countCarry( eins / 10, zwei / 10, carry, uebertraege );
}
return uebertraege;
}
int main()
{
unsigned short number1 = 0;
unsigned short number2 = 0;
cout << "Bitte geben Sie zwei ganze Zahlen grösser als 0 ein!" << endl;
cout << "Die 1. Zahl: ";
cin >> number1;
cout << "Die 2. Zahl: ";
cin >> number2;
cout << endl << number1 << " + " << number2 << " = " << number1 + number2 << endl;
cout << "Bei der Addition ergeben sich " << countCarry(number1, number2, 0, 0) <<
" Überträge." << endl;
}
/* AUFGABE 9: **********************************************************************
*
* Schreiben Sie ein C++-Programm, das die Anzahl der Uebertraege beim Addieren
* zweier Zahlen berechnet.
*
* Algorithmus:
*
* Zunaechst sollen vom Benutzer zwei nicht negative Zahlen mit jeweils weniger als
* 10 Ziffern eingelesen werden.
*
* Anschliessend soll die Anzahl an Uebertraegen beim ziffernweisen Addieren der
* beiden Zahlen von rechts nach links berechnet werden.
*
* Zum Schluss soll die Anzahl an Uebertraegen auf den Bildschirm ausgegeben werden.
*
***********************************************************************************/
Ich frage mich daher, wie C++-Programmierer abfragen, ob ein Rekursionsschritt den Stack überfordern wird oder wie sie eine solche Problemsituation zumindest geregelt handhaben?