[affenjunge123]

Hallo, ich schreibe in ca einem Monat eine Informatik Klausur. Beschäftige mich schon den ganzen Nachmittag mit alten Klausuren vom Prof. Thema wird sein C++.
Da ich mich noch nie mit der Sprache beschäftigt habe, fällt es mir sehr schwer die Aufgaben zu lösen, trotz Hilfe des Skriptes.
Die Grundlegenden Dinge verstehe ich, aber wenn es dann heißt eine verschachtelte Schleife zu lösen, verstehe ich nicht wo der Anfang und wo das Ende ist.
Die Aufgaben sind sicherlich nicht schwer, wenn man es einmal gemacht hat.

Hier mal eine Aufgabe

int i = 1, j = 1;
while (i < 20)
{
do
{
i = j = i + j;
}
while (j < 3) ;
if (i == 4)
continue;
i += j;
}
cout << i;

Also hier handelt es sich um eine do-while Schleife, also Kopfgesteuert.
Bedingung i < 20 ist erfüllt, wie es dann genau weiter geht, weiß ich nicht.
Hoffe jemand kann es schritt für schritt erklären.

Danke


Edit: Wie lernt man für sowas am besten? Kennt jemand gute Internetseiten?

[Robar666]

Einfach der Reihe nach durchgehen und schauen was gemacht wird und welche Werte die Variablen haben.

int i = 1, j = 1; // variablen werden auf 1 gesetzt
  while (i < 20) { // schleife läuft solange bis i nicht mehr kleiner 20 ist
    do { // diese innere schleife wird bei jeder iteration aufgerufen nachdem es eine do-while ist wird sie auch IMMER mind. einmal durchlaufen
      i = j = i + j; // i und j werden auf deren summe gesetzt 
    } while (j < 3);
    if (i == 4) // ist i genau 4 so wird zur nächsten schleifeniteration/schleifenanfang gesprungen ohne das das i+=j durchgeführt wird
      continue;
    i += j; // in jedem schleifen durchgang wird i um j erhöht
  }
  cout << i;

Jetzt gehst du einfach logisch mal die iterationen von der äußeren schleife durch:

1. Iteration:
i ist 1 und j ist 1, i < 20 ist also noch erfüllt
do-while schleife beginnt und läuft solange bis i nicht mehr kleiner 3 ist
i und j wird 2 zugewiesen. Bedingung (j<3) noch erfüllt do-while schleife läuft nochmals
i und j wird 4 zugewiesen Bedingung (j<3) nicht mehr erfüllt weiter gehts zur if
die if ist erfüllt da i genau 4 ist, daher schleife startet von vorne

2. Iteration:
i und j sind 4, i < 20 ist also noch erfüllt
do-while schleife beginnt und läuft wie gesagt zumindest 1mal
i und j wird 8 zugewiesen. Bedingung (j < 3) nicht mehr erfüllt weiter gehts zur if
die if ist nicht erfüllt
i wird um j erhöht, damit ist i jetzt 16 und j ist 8

3. Iteration:
i ist 16 und j sind 8, i < 20 ist also noch erfüllt
do-while schleife beginnt und läuft wie gesagt zumindest 1mal
i und j wird 24 zugewiesen. Bedingung (j < 3) nicht mehr erfüllt weiter gehts zur if
die if ist nicht erfüllt
i wird um j erhöht, damit ist i jetzt 48 und j ist 24

Mögliche 4. Iteration wird nicht mehr gestartet da i ja jetzt nicht mehr kleiner als 20 ist.
Schleifenende.

cout gibt i aus, welche jetzt den Wert 48 hat.
Programm ende.

[affenjunge123]

Danke, für die Ausführliche erklärung hab es verstanden

Wie sieht es mit dieser Ausgabe aus?

void main (void)
{
string s1 = "ABCD";
string s2 = "GHIJ";
s[1] = tolower (s2[3]);
s[2] = toupper (s1[3]);
for (int i = 0; i < (int)s1.size(); i+=2)
{
s1[i] = tolower(s2[i]);
}
cout << s1;
}

Was ich weiß ist, dass tolower und toupper die Befehler für die Groß- bzw. Kleinschreibung sind und dass die Zahl in der eckigen Klammer für das Feld steht, welches bei 0 beginnt.

Also die Zeilen:
s[1] = tolower (s2[3]);
s[2] = toupper (s1[3]);

sagen aus, dass Feld [1] mit "j" ist und Feld [2] ein "D".

Lieg ich komplett falsch? Weiter komm ich nicht ...

[Robar666]

Strings sind nichts anderes als Char-Arrays also eine Aneinanderreihung von Zeichen. Mit dem Index-Operator (die eckigen Klammern) kannst du auf die einzelnen Elemente des Arrays zugreifen.

Wie du schon richtig erkannt hast, wird s[1] 'j' zugewiesen und s[2] 'D' zugwiesen.
Problem bei deinem Code ist allerdings das zuvor nirgendswo den string/array s angelegt hast.

Was die schleife machst dürftest du dann mit deinem erlangten Wissen glaub ich selbst rausfinden

[affenjunge123]

Okay, habs raus. Das Ergebnis lautet "gjiD".

Weiß jemand was hier raus kommt:

int feld1[5], feld2[5], i, j = 0;
for (i = 0; i < 5; i++)
{
feld1[i] = i;
feld2[i] = 5 - i;
}
feld1[1] = feld2[2];
feld2[1] = feld1[2];
for (i = 0; i < 5; i += 2)
{
j += feld1[i] + feld2[1];
}
cout << j << endl;

Hab 15 raus bekommen, kann das jemand bestätigen?

[Robar666]

Nun ja zur letzten Aufgabe: nicht ganz es kommt "gBjD" raus.
Die 0. und 2. Position von s1 wird einfach durch die "gelowerte" 0. und 2. Position von s2 ersetzt.

Die zwei Zeilen:

s[1] = tolower (s2[3]);
s[2] = toupper (s1[3]);

ändern s1 und s2 nicht.

Zur aktuellen Aufgabe:

  int feld1[5], feld2[5], i, j = 0; // zwei arrays werden angelegt und i,j auf 0 gesetzt
  for (i = 0; i < 5; i++) { // diese schleife befüllt nun beide arrays mit werten
   feld1[i] = i; 
   feld2[i] = 5 - i;
  }
  // feld1 schaut nun so aus: [0,1,2,3,4]
  // feld2 schaut nun so aus: [5,4,3,2,1]

  feld1[1] = feld2[2]; // die 1.position von feld1 wird auf den wert der 2.position von feld 2 gesetzt
  feld2[1] = feld1[2];

  // feld1 schaut nun so aus: [0,3,2,3,4]
  // feld2 schaut nun so aus: [5,2,3,2,1]

  // diese schleife addiert jetzt einige werte zu j
  // jeweils die summe von der 0.,2. und 4. position von feld1 UND den werte von 
  // 1. position von feld2 was '2' ist
  // also im ersten durchlaufe 0 und 2, im 2. durchlauf 2 und 2, im 3. durchlauf
  // 4 und 2 danach endet die schleife da i größer als 5 ist
  for (i = 0; i < 5; i += 2) {
    j += feld1[i] + feld2[1];
  }

  // daraus ergibt sich ein wert von 0 + 2 + 2 + 2 + 4 + 2 = 12 
  cout << j << endl; // ausgabe: "12"

Btw: wenn man schnell was ausprobieren will ist codepad.org ganz nett.

Hier da link zur aktuellen aufgabe: [ Link nur für registrierte Mitglieder sichtbar. Bitte einloggen oder neu registrieren ]

[affenjunge123]

Hab das so wie du bis zu letzten Schleife.

for (i = 0; i < 5; i += 2) {
j += feld1[i] + feld2[1];

da hab ich folgendes addiert:

0 + 5 + 2 + 3 + 4 + 1 = 15

Also so hab ich die Schleife verstanden.

[Robar666]

Zitat von affenjunge123

Hab das so wie du bis zu letzten Schleife.



da hab ich folgendes addiert:

0 + 5 + 2 + 3 + 4 + 1 = 15

Also so hab ich die Schleife verstanden.

Hab ich auch beim ersten mal "hinschauen" raus bekommen.

Wenn mans genau nimmt kommt aber 12 raus weil in der schleife folgendes steht:

j += feld1[i] + feld2[1]; // ergebnis: 12

und NICHT:

j += feld1[i] + feld2[i];  // ergebnis: 15

Würd mal vermuten du hast dich vertippt beim reinstellen oder es ist eine etwas eigenartige Angabe, weil ich hätte auch vermutet das immer die i. Position von Feld2 abgefragt wird.

[affenjunge123]

Ja, hab mich vertippt. Sorry und danke

[affenjunge123]

Bräcuhte Hilfe bei folgender Aufgabe:

#include <iostream>
using namespace std;
int z = 1;
void fkt (int &x)
{
int y = x +z +1;
for (int z = 1; z < 4; z += 2)
{
x = x * y + z;
}
}
void main (void)
{
int z = 1;
fkt (z);
cout << z << endl;

Das Problem bei der Aufgabe ist, dass es eine Funktion ist.
Z.B. verstehe ich nicht wofür der Ausdruck steht "void fkt(int &x)". Den Schluss versteh ich auch nicht. Kommt vllt z = 1 raus?


Bräuchte auch etwas Hilfe bei folgender Aufgabe:

#include <iostream>
using namespace std;
void main (void)
{
int feld1[5] = {1, 1, 2, 2, 3} ;
int feld2[5] = {0, 1, 2, 3, 4} ;
feld1[1] = feld2[2] ; feld1[3] = feld2[4] ;
feld2[1] = feld1[2] ; feld2[3] = feld1[4] ;
for (int i = 1; i < 4; i++)
{
feld1[0] += feld1[i] + feld2[i]
}
cout << feld1[0] << endl;

Das Ergebnis dieser Aufgabe lautet: 16. Ich komme jedoch auf 14, ich weiß nicht was ich falsch mache.

Schritt 1: Ich vertausche die einzelnen Felder und erhalte:

Feld1[5] = 11323
Feld2[5] = 11234

In der Schleife addiere ich folgende zahlen:

0 + 1 + 1 = 2
2 + 1 + 1 = 4
4 + 3 + 2 = 9
9 + 3 + 2 = 14

Habe ich vielleicht schon vorher beim Vertauschen etwas falsch gemacht?

Danke

[Your_Conscience]

Zitat von affenjunge123

Das Problem bei der Aufgabe ist, dass es eine Funktion ist.

Wieso sollte das ein Problem sein?

Zitat von affenjunge123

Z.B. verstehe ich nicht wofür der Ausdruck steht "void fkt(int &x)".

"void" sagt, dass es eine Funktion ist, die keinen Wert zurückliefert.
"int &x" bedeutet, dass du der Funktion beim Aufruf die Adresse eines int-Wertes übergeben musst.

Zitat von affenjunge123

Den Schluss versteh ich auch nicht. Kommt vllt z = 1 raus?

Nein, es kommt 15 raus.

y = 1 + 1 + 1 = 3
Schleife für z = 1:
	x = 1 * 3 + 1 = 4
Schleife für z = 3:
	x = 4 * 3 + 3 = 15

[affenjunge123]

Also wenn ich das richtig verstanden habe, sagt das "(int &x)", dass die 1 von z für das x übernommen wird?

Okay, danke die Aufgabe ist echt nicht schwer. Hab noch eine Frage bezgl. der Schleife. Wenn z = 3 ist gilt doch noch die Bedingung, dass z < 4 ist. Wieso läuft die Schleife nicht noch einmal mit z = 5 und bricht danach ab? Wird zuerst erhöht und dann geprüft?

Den letztesn Teil hab ich nicht ganz verstanden:

void main (void)
{
int z = 1;
fkt (z);
cout << z << endl;

Entfällt er wegen dem "(void)" ?

[Your_Conscience]

Zitat von affenjunge123

Also wenn ich das richtig verstanden habe, sagt das "(int &x)", dass die 1 von z für das x übernommen wird?

Jain.
"(int x)" heißt, dass ein Wert, z.B. eine 1, übernommen wird. "(int &x)" heißt, dass er die Adresse aus dem Arbeitsspeicher, wo sich dieser Wert befindet, übermittelt. Dadurch kann dieser Wert auch durch andere Funktionen geändert werden.

Zitat von affenjunge123

Wieso läuft die Schleife nicht noch einmal mit z = 5 und bricht danach ab? Wird zuerst erhöht und dann geprüft?

Genau. Zuerst kommt die Prüfung "z = 1 < 4" -> 1. Durchlauf und danach "z = 3 < 4" -> 2. Durchlauf. Bei "z = 5 < 4" kommt dann false raus und die Schleife bricht ab.

Zitat von affenjunge123

Den letztesn Teil hab ich nicht ganz verstanden:
...
Entfällt er wegen dem "(void)" ?

Leider weis ich hier nicht, was genau du nicht verstehst.
"fkt (z);" ruft die Funktion "fkt" auf und übergibt die Speicheradresse von z. Da die Funktion eine Speicheradresse erwartet (int &x), kann dieses z in der Funktion geändert werden.
"cout << z << endl;" gibt das z einfach nur aus.

[affenjunge123]

Okay, danke.

Jetzt kommt die letzte Aufgabe. Bin mir nicht sicher, ob ich die Aufgabe richtig verstanden habe.

#include <iostream>
using namespace std;
class CBsp1
{
private:
int m_i, m_j;
public:
CBsp1()
{
m_i = 1; m_j = 2;
}
int Berechne(int f)
{
return m_i + m_j * f;
}
};
class CBsp2 : CBsp1
{
private:
int m_k;
public:
CBsp2()
{
m_k = 3;
}
int Berechne(int f)
{
return CBsp1::Berechne(2) + m_k * f;
}
};
void main (void)
{
CBsp1 x;
CBsp2 y;
cout << x.Berechne(2) + y.Berechne(2);
}

1. Void Main (void) -> CBsp1 wird "x" und CBsp2 wird "y" zugewiesen.
2. Man geht hoch zu CBsp1 und setzt für "f" die 2 von unten ein.
-> 1 + 2 * 2 = 5
(Was genau das return bewirkt, weiß ich nicht ...)
3. Weiter geht es mit CBsp2
"f" ist wieder 2 und "Berechne(2)" erbt von CBsp1, d.h. 5 + 3 * 2 = 11
4. Man addiert beide Werte und erhält 5 + 11 = 16

[Robar666]

Mit dem Ergebnis hast du Recht jedoch glaub ich nicht das du das Klassenkonzept vollständig gecheckt hast.

Also du hast 2 Klassen "CBsp1" und "CBsp2", die jeweils einen Konstruktor haben (z.B. CBsp2() {..}) in dem private Membervariablen (z.B. m_i ) initialisiert werden.

Des Weiteren haben beide Klassen die Methode "Berechne(int f)", Methoden müsstest du jetzt denk ich schon verstanden haben. Die beiden Klassen implementieren jetzt "Berechne" verschieden.

In der Main legst du nun 2 Objekt von den Klassen an. Machst du aber nicht ganz richtig da du nur die variablen anlegst nicht aber ein Objekt erzeugst. Richtig wäre:

CBsp1 x = new CBsp();

Nachdem du das Objekt erzeugt hast kannst du die jeweilige Methoden dieser Klasse aufrufen. Ergebnis mit 16 müsste stimmen, aber wenn du Klassen und ähnliches zur Klausur können musst würde ich mir das nochmal ein bisschen anschauen.

[slahn]

Zitat von Your_Conscience

Jain.
"(int x)" heißt, dass ein Wert, z.B. eine 1, übernommen wird. "(int &x)" heißt, dass er die Adresse aus dem Arbeitsspeicher, wo sich dieser Wert befindet, übermittelt. Dadurch kann dieser Wert auch durch andere Funktionen geändert werden.

Auch jain ... "int& x" ist in diesem Falle eine Referenz (da du von Adressen redest, kann man das leicht mit Pointen verwechseln). Der Compiler geht an dieser Stelle her und ersetzt die Referenz x mit der Variable z (ganz grob gesagt ...). Eine Referenz ist also nicht anderes wie ein anderer/neuer Name für eine Variable ... x und z sind somit an dieser Stelle identisch.

Zitat von Robar666

In der Main legst du nun 2 Objekt von den Klassen an. Machst du aber nicht ganz richtig da du nur die variablen anlegst nicht aber ein Objekt erzeugst. Richtig wäre:

CBsp1 x = new CBsp();

Das stimmt nicht ganz. "new" dient nur dazu, Objekte dynamisch zur Laufzeit zu erstellen. "CBsp1 x;" legt genau so ein Objekt an (Konstruktor ohne Parameter), jedoch nicht erst zur Laufzeit, sondern schon beim Compilieren selbst. Würden wir hier jedoch von Java reden, hättest du natürlich recht, aber das ist C++ (und somit muss man, wenn man new verwendet, auch einen Pointer verwenden: Richtig:"CBsp1* x = new CBsp();") .

@affenjunge123:
Zudem würde ich raten, überall wo es möglich ist, Initialisierungslisten für Konstruktoren zu verweden, da somit die Initialisierung bereits bei der Konstruktion geschieht. Verwendet man diese nicht, wird der Speicher am Anfang ohne Wert Angelegt (für const-Elemente innerhalb des Objekts, wäre dies nicht mal möglich).

Konstruktor mit Initialisierungsliste:

CBsp1() : m_i = 1, m_j = 2 {}

Besonders bei Vererbungen ist es gut so zu arbeiten (eigentlich sollte man immer so arbeiten, da es einfach die beste Lösung ist, kenne keinen Grund es nicht zu verwenden ...), da sonnst ein für das Elternobjekt IMMER der Std-Konstuktor aufgerufen wird und später erst der korrekte Konstruktor (Hier unwichtig, da sowieso nur der STD-Konstruktor vorhanden ist ...).

Zu deinen aussagen:
1. Nein, es wird ein Objekt mit den Namen x, von der Klasse CBsp1 angelegt und ein Objekt mit dem Namen y, von der Klasse CBsp2
2-4. "Richtig", wenn auch etwas merkwürdig erklärt ... return gibt den Rückgabewert einer Funktion an, wenn du dass noch nicht verstanden hast, musst du dich noch mal mit Funktionen beschäftigen ...

[Robar666]

@slahn:
Tja stimmt haste recht, das kommt davon wenn man den ganzen tag c# programmiert und am abend dann c++ fragen beantwortet ^^

[affenjunge123]

Ok, danke. Hab jetzt mehr oder weniger gecheckt, wie das ganze fnktioniert. Bis zur Klausur ist ja noch etwas Zeit um sich etwas in die Thematik zu vertiefen

Lg

[affenjunge123]

Hab noch eine Frage:

Aufgabe 3:
Welche der folgenden Aussagen sind korrekt? (m aus n)
a) Der Compiler erzeugt ein ausführbares Maschinenprogramm.
b) Der Präprozessor bereitet den Quellcode für den Debugger vor.
c) Der Linker wird vom Compiler aufgerufen.
d) Der Editor wird zum Übersetzen des Quellprogramms verwendet.
e) Präprozessor-Anweisungen werden zur Laufzeit des Programms ausgewertet.

Diese Frage hab ich in einer alten Klausur gefunden und die Antwort ist: Keine Aussage ist richtig.

Das versteh ich nicht ganz.

a) ist falsch, weil der Compiler ein ausführbares Objektprogramm erzeugt, welches dann vom Linker in ein Maschinenprogramm umgewandelt wird.
b) würde ich sagen ist falsch, weil der Präprozessor den Quellcode für den Compiler vorereitet.
c) weiß ich nicht was ich davon halten soll, in meinen Unterlagen kommt nach dem Compiler der Linker zum einsatz. Ob er ihn jetzt aufruft oder nicht, weiß ich nicht, aber anscheinend nicht.
d) ich würde sagen, der Editor ist einfach das Feld wo man den Text eingibt. Also er gibt nur das eingetippe wider, ohne was zu übersetzen.
e) weiß ich nicht

[germgerm]

@c
Akademisch betrachtet ruft der Compiler den Linker nicht automatisch auf. In der Praxis kommt es aber trotzdem oft vor.

@e
Diese Frage solltest du aufgrund deiner eigenen Antworten selbst lösen können. Da die Präprozessor-Anweisungen vor dem Compiler berücksichtigt werden, werden diese natürlich nicht zur Laufzeit ausgewertet.

[slahn]

Also, der Weg ist im Prinzip so:

1. Editor [Erstellen des Sourcecodes] ->
2. Präprozessor [Präprozessor-Anweisungen umsetzen, Leerzeichen uns sonstige Formatierung löschen] ->
3. Compiler [meist zwei getrennte Einheiten; ein Übersetzer der Programmiersprache in Assembler und ein Assembler, welcher dann den Maschinencode erstellt; Daraus entsteht das Objektprogramm (Objektfiles, welche noch nicht ausführbar sind, jedoch schon Maschinenabhängig)] ->
4. Linker [Einfügen von Bibliotheks-Modulen und Binden (zusammenfügen) der Objektprogramme; hier entsteht eine Ausführbare Datei (Maschinencode in HEX, *.exe, *.elf, ...)]

Darum stimmt bei a) das mit dem "ausführbares Objektprogramm" nicht. dies ist noch nicht ausführbar.

b) ist von dir richtig verstanden worden. Der Debugger ist erst dann gefragt, wenn man eine Ausführbare Datei hat.

Die Sache mit c) ist die, dass der Compiler nicht unbedingt den Linker ausführen muss. Das ist es sehr stark von der Interpretation abhängig. Klar kommt nach dem Compilieren, das Linken. Jedoch ist es nicht zwingend notwendig. Wenn man nur Bibliotheks-Module erstellt, muss man nicht unbedingt Linken. Somit kann man die Frage nicht zu 100% beantworten, weil es eben Fraglich ist, wie das gegenüber die Frage versteht.

d) ist auch korrekt von dir. Der Editor ist ein reines Textverarbeitungsprogramm, welches nicht compilieren kann. Jedoch könnte man auch hier, bei großem Interpretationsspielraum sagen, dass bie so Editoren wie Emacs die Frage mit JA zu beantworten sein könnte, da man da mit dem Editor den Compiler aufrufen kann. Grundsätzlich ist es jedoch FALSCH.

Präprozessor-Anweisungen werden vom Präprozessor interpretiert und verarbeitet. Dieser wird ja nach der Liste oben, bereits vor dem Compilieren tätig. Daher ist es nicht möglich dass diese Sachen zur Laufzeit ausgewertet werden (Durch Interpretation könnte man auch hier sagen, dass sie vom Präprozessor, interpretierten Anweisungen dann aber sehr wohl zur Laufzeit ausgewertet werden können, aber auch das ist eher Unfug).

[affenjunge123]

Okay, danke erstmal.
Jetzt kommt die letzte Frage und zwar geht es um Vererbung. Ich dachte ich hätte das Prinzip verstanden, aber wohl nicht ganz...

Hier ist eine etwas komplexere Vererbung.

class CKlasse1 
{
private:
        int m_i, m_j = 2;
public:
        CKlasse1 ()
        {
                     m_i = 1; m_j = 2;
         }
        int Berechne (int f)
        {
                    return m_i + m_j + f;
         }
        void Ausgabe ()
         {
                 cout << "Das Ergebnis lautet: ";
          }
};

class CKlasse2 : public CKlasse1
{
private:
         int m_k;
public:
         CKlasse2(int zahl):m_k(zahl)
         {
         }
         int Berechne(int f)
         {
                     return CKlasse1::Berechne(f) + m_k + f;
          }
         void Ausgabe()
         {
                      cout << "Die Zahl lautet: ";
         }
}:

void main()
{
            CKlasse2 Objekt1(2);
            CKlasse1 Objekt2;

            Objekt2.Ausgabe();
            cout << Objekt2.Berechne(2) + Objekt1.Berechne(3) << endl;
}

Kann das jemand Schritt für Schritt durchgehen? Das Ergebnis habe ich.... Nur bin ich mir nicht ganz sicher wie man darauf kommt.

Ich gehs mal durch:

1) Man fängt bei void main an.
Der Klasse CKlasse 2 wird Objekt1 mit dem Parameter 2 zugewiesen und der Klasse CKlasse1 wird Objekt2 zugewiesen.
Objekt2.Ausgabe hat keinen Parameter.

2) Ich würde jetzt zunächst einmal zur CKlasse1 hüpfen und dort indem ich f = 2 setze 5 rausbekommen und die 5 würde ich jetzt unten bei Objekt2.Berechne(2) schonmal eintragen.

3) Jetzt würde ichzur CKlasse2 hüpfen und für m_k würde ich die Zahl 2 einsetzten aus dem vorher definierten Parameter für Objekt1
Also habe ich: [HIER MUSS ICH AUF 6 KOMMEN] + 2 + 3 (für f von unten Berechne)

Hier komm ich nicht weiter. Ich weiß, dass hier Cklasse2 von Cklasse1 erbt. Aber wie kommt man auf die 6?

Und woher weiß man ob ausgegeben wird "Das Ergebnis lautet" oder "Die Zahl lautet" ?
Ich denke mal es wird "Das Ergebnis lautet" ausgegeben, weil vorher Objekt2.Ausgabe definiert wurde und das zu CKlasse1 gehört.

[affenjunge123]

Ich vermute man kommt auf die 6, da Berechne(f) für Objekt1 von CKlasse2 3 ist und von CKlasse 1 wird nur m_i und m_j geerbt? Also ergibt das zusammen 6.

So würde ich dann auf das Endergebnis kommen. Das Ergebnis muss lauten:

"Das Ergebnis lautet: 16"

Sorry, dass ich pushe, aber morgen Nachmittag ist es schon soweit, und bei der Vererbung hakt es noch ein wenig.