3. Loop

Loop

  • ?

    Hallo,

    ich programmiere normalerweise in Visual Basic und kenne mich mit C++ nur wenig aus. Zusätzlich bin ich nicht ganz so erfahren, was Loops angeht... 😞
    Ich habe den unten stehenden Code und kann ihn nicht interpretieren. Kann mir jemand von Euch bitte sagen, was da abgeht? Wenn Ihr zufällig auch noch wisst, wie man das in VB umsetzten kann wäre das top!

    int Inkr = floor(A/500.0);
double *z = new double[Inkr+1];
double *h = new double[Inkr+1];
double cosalpha = A/C;
double hilf = 0.0;
for (int i = 0; i < Inkr; i++)
{
        z[i] = 500.0/cosalpha;
        hilf += z[i];
        h[i] = i * 500.0;
}
h[Inkr] = A - 500.0;
z[Inkr] = C - hilf;
double t = 0.0;
for (int i = 0; i <= Inkr; i++)
        t += exp(-h[i]/1700.0) * z[i] * pow10(-3);

    Vielen Dank!
    Gruß, Tobias

    0
  • _

    Meine Empfehlung wäre, mal schrittweile (also Zeile für Zeile) mit dem Debugger durch den Code zu gehen. Dann fällt dir das Verstehen sicher leichter, du siehst ja dann, was mit den Variablen passiert und wie der Ablauf ist. Ansonsten: mit welchen Zeilen speziell hast du denn Probleme?

    Ganz kurz zur Schleife:

    //Wenn A z.B. 1200 ist, dann kommt hier 2.0 raus (1200/500=2 Rest 200).
int Inkr = floor(A/500.0);

//i wird hier auf 0 gesetzt und solange mit jedem Schleifendurchlauf um eins
//erhöht (i++), bis die Bedingung i<Inkr nicht mehr erfüllt ist. Wenn Inkr also
//z.B. 2 ist, dann finden 2 Durchläufe für i=0 und i=1 statt.
for (int i = 0; i < Inkr; i++)
{
  //...
}
    0
  • C

    Dieser Thread wurde von Moderator/in akari aus dem Forum VCL (C++ Builder) in das Forum ANSI C verschoben.

    Im Zweifelsfall bitte auch folgende Hinweise beachten:
    C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

    Dieses Posting wurde automatisch erzeugt.

    0
  • ?

    Hi Matze,

    vielen Dank für die Antwort! Ich habe den Code per Textdatei bekommen und bekomme ihn wegen Unwissenheit in Borland C++ nicht zum laufen...
    Mir sind in dem Code leider viele Dinge nicht klar.

    Zum einen verstehe ich den Unterschied zwischen *z, z[i] und z[Inkr] nicht. Das Selbe natürlich für *h, h[i] und h[Inkr].

    Dan nist mir nicht klar, wann genau die eine Schleife aufhört und die Zweite anfängt.

    Und zusätzlich bin ich mir nicht 100%ig über den Operator += im klaren, also wie der in 'ner Mathematischen Formel aussehen würde...

    Wäre toll, wenn Du mir da ein bisschen Klarheit reinbringen könntest.

    Danke!
    Tobias

    0
  • R
     

    double *z = new double[Inkr+1];
/*
  z ist ein Zeiger, der auf den Anfang des Speicherbereiches zeigt, den du mit
  new double[Inkr+1] reserviert hast. Dieser Bereich ist ein zusammenhängender Speicherbereich, also ein Array.
  Mit z[i] bzw. z[Inkr] wird auf ein bestimmtes Element in diesem Array zugegriffen.
*/

delete[] z;
/*
  Jeder reservierte Speicher sollte am Ende eines Programms freigegeben werden.
  Die Klammern hinter delete sind nötig, da du oben einen zusammenhängenden Speicherbereich (Array) reserviert hast.
*/

// ------------------------------

int x = 2;
int y = 4;

x = x + y;
x += y;    // Diese Zeile ist identisch mit der obigen, diese Form ist halt nur kürzer
// logischerweise gibt es dann noch -= *= und /=
    0
  • C

    Dieser Thread wurde von Moderator/in rüdiger aus dem Forum ANSI C in das Forum C++ verschoben.

    Im Zweifelsfall bitte auch folgende Hinweise beachten:
    C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

    Dieses Posting wurde automatisch erzeugt.

    0
  • _

    Panavia schrieb:

    Dan nist mir nicht klar, wann genau die eine Schleife aufhört und die Zweite anfängt.

    Eine Schleife wird normalerweise mit geschweiften Klammern ("{}") begrenzt. Du siehst also, wann die erste Schleife beginnt und endet. Die zweite Schleife ist eine Schleife mit nur einzeiligem Rumpf, da darf man die Klammern weglassen. Der Rumpf wird einfach nur durch die Einrückung deutlich gemacht. Ich persönlich finde das nicht so gut und benutze eigentlich immer Klammern zur besseren Übersicht.

    Der Rest wurde ja schon erklärt. Hierzu gibt es bei Interesse auch noch was zu lesen:

    Zur Speicherverwaltung (bei dir new[]/delete[]):
    http://magazin.c-plusplus.net/artikel/Speicherverwaltung in CPlusPlus (und C)

    Zu Pointern:
    http://magazin.c-plusplus.net/artikel/Pointer in C(PlusPlus)

    Bei weiteren Fragen sag Bescheid.

    Ich vermute mal, dass du das Visual Studio benutzt. In dem Fall kannst du (am besten am Anfang des Codes) mit F9 in einer Zeile einen Haltepunkt setzen. Der Debugger hält dann an dieser Stelle die Ausführung an. Mit F10 kannst du dann eine Zeile ausführen lassen. So kannst du dich Schritt für Schritt durch den Code arbeiten, Variableninhalte überprüfen (Tooltips, Auto- und Überwachungsfenster) und den Ablauf nachvollziehen.

    0
  • ?

    Hey, vielen Dank ür die Hilfe.
    Besser kann man sich's nicht wünschen!
    Dann werde ich no ein wenig unter den links weiterlesen und denke, dass ich so weiter komme. Wenn ich doch noch Probleme bekomme nehme ich Dein Angebot gerne an, Matze.

    Schönes Wochenende!
    Gruß, Tobias

    0
  • ?

    Hi Matze und Ravendark,

    sorry aber ich komme bei dem Code nicht weiter... Ich werde aus den Variablen und Schleifen nicht schlau. Wahrscheinlich reichen meine Programmierkenntnisse dafür nicht aus :(.
    Würde es euch was ausmachen mir mehr oder weniger Schritt für Schritt an einem Beispiel zu erläutern, was in dem Code abgeht? Das Debugging funktioniert auch nicht, weil ich den code nicht verstehe und nicht weiß, wie ich ihn in VB schreiben soll.

    Für mein Beispiel soll A=23000, C= 33420 und D=0,69 sein:

    int Inkr = floor(A/500.0);
double *z = new double[Inkr+1];
double *h = new double[Inkr+1];
double cosa = D;
double f = 0.0;
for (int i = 0; i < Inkr; i++)
{
        z[i] = 500.0/cosa;
        f += z[i];
        h[i] = i * 500.0;
}
h[Inkr] = A - 500.0;
z[Inkr] = C - f;
double t = 0.0;
for (int i = 0; i <= Inkr; i++)
        t += exp(-h[i]/1700.0) * z[i] * pow10(-3);
delete z;
delete h;

    Vielen Dank im Vorraus!
    Gruß, Tobias

    0
  • ?

    Panavia schrieb:

    Hi Matze und Ravendark,

    sorry aber ich komme bei dem Code nicht weiter... Ich werde aus den Variablen
    und Schleifen nicht schlau. Wahrscheinlich reichen meine Programmierkenntnisse dafür nicht aus :(.
    Würde es euch was ausmachen mir mehr oder weniger Schritt für Schritt an einem
    Beispiel zu erläutern, was in dem Code abgeht? Das Debugging funktioniert auch
    nicht, weil ich den code nicht verstehe und nicht weiß, wie ich ihn in VB schreiben soll.

    Für mein Beispiel soll A=23000, C= 33420 und D=0,69 sein:

    int Inkr = floor(A/500.0);
double *z = new double[Inkr+1];
double *h = new double[Inkr+1];
double cosa = D;
double f = 0.0;
for (int i = 0; i < Inkr; i++)
{
        z[i] = 500.0/cosa;
        f += z[i];
        h[i] = i * 500.0;
}
h[Inkr] = A - 500.0;
z[Inkr] = C - f;
double t = 0.0;
for (int i = 0; i <= Inkr; i++)
        t += exp(-h[i]/1700.0) * z[i] * pow10(-3);
delete z;
delete h;

    Vielen Dank im v******!
    Gruß, Tobias

    // du erstellst eine neue variable vom typ int mit namen "Inkr" die den wert von A/500 zugewiesen bekommen
int Inkr = floor(A/500.0);
// du erstellt ein neues array namens "z" vom typ double mit der größe von Inkr+1
double *z = new double[Inkr+1];
// du erstellt ein neues array namens "h" vom typ double mit der größe von Inkr+1
double *h = new double[Inkr+1];
// du legst dir eine neue double variable mit namen "cosa" an und gibst ihr den wert von D
double cosa = D;
// neue double variable "f" mit wert 0
double f = 0.0;
// hier beginnt die for schleife
// die zähler variable ist "i" und startet bei 0. Bei jedem durchlauf wird i um
//1 erhöht. Beendet wird die schleife wenn i nicht mehr kleiner als Inkr ist, in
//diesem fall bedeutet das, dass die schleife abbricht wenn i gleichen wert wie
//Inkr hat. die schleife zählt also von 0 bis (Inkr - 1).
for (int i = 0; i < Inkr; i++)
{
        // in deinem "z" array wird an der position die in "i" steht der wert
        // 500.0/cosa gesetzt
        z[i] = 500.0/cosa;
        // f wird um den wert der in z[i] (damit greifst du wieder auf dein
        //array z an stelle i zu, also das was du in der vorherigen zeile in z[i]
        //geschrieben hast, nämlich "500.0/cosa". dadurch spart man sich nur das neue
        //ausrechnen) steht erhöht. das entspricht f = f + z[i]
        f += z[i];
        // jetzt schreibst du in dein "h" array an der stelle "i" den wert von i * 500
        h[i] = i * 500.0;
}
// jetzt wird an die letzte stelle im "h" array der wert von A - 500
//gespeichert. hier wird auch nichts überschrieben, da der wert des arrays um 1
//größer ist als du durchläufe in deiner schleife gemacht hast. das sieht man an
//dem "double *h = new double[Inkr+1]".
h[Inkr] = A - 500.0;
// hier das gleiche, nur das "z" array und der wert C - F
z[Inkr] = C - f;
// neue variable "t" anlegen
double t = 0.0;
// jetzt gibts wieder eine schleife mit einer zählervariable "i" die von 0 bis
//Inkr zählt. Dieses mal also ein weiter als die vorherige schleife. Wenn keine
//klammern nach einem konstruct kommen, weisst das, dass nur die nächste zeile
//ausgeführt wird. Wenn du es lieber magst kannst du auch das schreiben:
/*
for (int i = 0; i <= Inkr; i++)
{
        t += exp(-h[i]/1700.0) * z[i] * pow10(-3);
}
*/
for (int i = 0; i <= Inkr; i++)
        // der wert von t wird genommen und es werden verschiedene dinge dazu
        //addiert. exp stellt eine funktion dar, genauer gesagt http://de.wikipedia.org/
        //wiki/Exponentialfunktion die. als wert für die funktion wird wieder der wert 
        //aus deinem array "h" an stelle "i" genommen und negiert (durch das "-" zeichen)
        //der negierte wert wird dann durch 1700.0 geteilt. Danach wird das aus der 
        //exponential funktion enstandene ergebnis mit dem wert aus array "z" 
        //multipliziert. Danach wird das ergebnis dieser beiden operatoren mit 0.001 
        //multipliziert und am ende auf t addiert.
        // t = t + exp(...) * z[i] * 0.001;
        t += exp(-h[i]/1700.0) * z[i] * pow10(-3);

// array "z" löschen. hier sollte aber ein "delete[] z" stehen da du nicht nur einen pointer, sondern ein array angefordert hast
delete z;
// wie bei delete z
delete h;
    0
  • ?

    Sehr geil!!!

    Vielen, vielen Dank für die Mühe, die Du Dir gemacht hast!
    Jetzt ist alles klar.

    Schönes Wochenende noch!

    Gruß,
    Tobias

    0
Anmelden zum Antworten