Code abgeschlossen, aber schafft eine Endlosschleife?

Question

Ich versuche, ein Muster wie folgt zu drucken, ich habe den Code ohne Fehler ausgeführt, aber es erzeugt eine Endlosschleife und ich bin nicht sicher, warum;

Jede Anleitung oder Hilfe wäre großartig! Dank

#include <iostream> 
#include <string> 
using namespace std; 

// function member 
void star(int amountStars, char starShape); 

// function 
void star(int amountStars, char starShape) 
{ 
    int i; 
    string shape = "*"; 
    for (i = 0; i < starShape; i++) 
     // loop to increment through 
     cout << shape; 

    cout << endl; 

    if (starShape == amountStars) 
     // if * is equal to the amount of stars (30) 
     return; //************** 
    star(amountStars, ++starShape); // increase * by one *********** 

    for (i = 0; i < starShape; i++) 
     cout << shape; 
     cout << endl; 


} 
int main() 
{ 
    int amountStars = 30; // variable to store the amount of stars 

    star(amountStars, '*'); // function print for the amount of stars and the shape 

    return 0; 
}//end main 

Answer 1

Ihre star() Funktion selbst mit dem Kommentar „Erhöhung * durch ein“ auf der Linie ruft, was bedeutet es eine rekursive Funktion ist. Aber die Abbruchbedingung ist

gebrochen

Sie intialise die starShape Parameter, der vom Typ char, mit einem wörtlichen ‚*‘, die einen ASCII-Wert von 42 hat, aber anstatt diese als Symbol verwenden Sie tatsächlich die lokalen String-Variable shape, um den Druckvorgang auszuführen. Und Sie behandeln starShape als einen Zähler, mit dem Sie versuchen, die Schleife zu beenden. Aber es beginnt bei 42 und geht nur von dort nach oben, also wird es nie gleich dem Wert von 30 sein, den Sie übergeben.

Die einfachste (aber nicht beste) Weise, das zu beheben, ist, starShape zu einem int zu ändern und geben Sie 0 von main ein.

#include <iostream> 
#include <string> 
using namespace std; 

// function member 
void star(int amountStars, char starShape); 

// function 
void star(int amountStars, char starShape) 
{ 
    int i; 
    string shape = "*"; 
    for (i = 0; i < starShape; i++) 
     // loop to increment through 
     cout << shape; 

    cout << endl; 

    if (starShape == amountStars) 
     // if * is equal to the amount of stars (30) 
     return; //************** 
    star(amountStars, ++starShape); // increase * by one *********** 

    for (i = 0; i < starShape; i++) 
     cout << shape; 
     cout << endl; 


} 
int main() 
{ 
    int amountStars = 30; // variable to store the amount of stars 

    star(amountStars, 0); // function print for the amount of stars and the shape 

    return 0; 
}//end main 

Dann gehen Sie und lesen über rekursive Funktionen und Abbruchbedingungen. :)

Answer 2

Versuchen Sie dies in Ihrem Hauptkörper

main() 
{ 
    //inside main() 
    int i,n,j; 

    //Reads number of columns from user 

    cout<<"Enter value of n : "<<endl; 
    cin>>n; 

    //Prints the upper half part of the pattern 
    for(i=1; i<=n; i++) 
    { 
     for(j=1; j<=i; j++) 
     { 
      cout<<"*"; 
     } 
     cout<<endl; 
    } 

    //Prints the lower half part of the pattern 
    for(i=n; i>=1; i--) 
    { 
     for(j=1; j<i; j++) 
     { 
      cout<<"*"; 
     } 
     cout<<endl;; 
    } 

    return 0; 
} 

Answer 3

Sie den Wert Starshape machen * werden, ist der ASCII-Wert von * 42, so dass Ihr Code nie den Code erfüllen:

if (starShape == amountStars) 
     // if * is equal to the amount of stars (30) 
     return; //************** 

weil 42 größer als 30 ist, das ist, warum Ihr Schleife ist unendlich.

Answer 4

Die Verwendung Ihrer Variablen ist nicht korrekt. Auch die Platzierung Ihres rekursiven Endpunkts ist fraglich (und in diesem Fall wegen der früheren, inkorrekten Variablennutzung ineffektiv). Schließlich erhöhen Sie die lokale starShape direkt mit Pre-Inkrement. Es besteht keine Notwendigkeit, dies zu tun, und in der Tat Gründe nicht zu.

Die spezifische Form, die Sie beschreiben, ist eine aufsteigende (bergauf) Anzahl von Zeichen pro Zeile, bis ein Schwellenwert erreicht ist. Dann wird die gleiche Sequenz in umgekehrter Reihenfolge (abwärts) wiederholt. Der Algorithmus, das zu tun ist:

void func(const int limit, const int current) 
{ 
    // termination case (note >) 
    if (current > limit) 
     return; 

    // TODO: perform task 

    // recurse 
    func(limit, current+1); 

    // TODO: perform task 
} 

Hinweis dies wird nach Ihrem gegebenen Beispiel enthält eine Wiederholung in der Mitte der Figur, wenn die gleiche Aufgabe erledigt ist, sowohl vor und nach, der Rekursion.Im Falle eines ansteigenden, dann Linienmuster absteigend, würde es so aussehen:

Wenn Sie die Mittellinie wiederholt nicht möchten, können Sie einfach die Position der Rekursion bewegen und die Bedingungen ändern, eher passend als weniger:

void func(int limit, int current) 
{ 
    // TODO: perform task 

    // termination case (note ==) 
    if (current == limit) 
     return; 

    // recurse 
    func(limit, current+1); 

    // TODO: perform task 
} 

Dieses in einem Muster führt, das wie folgt aussieht:

* 
** 
*** 
**** 
*** 
** 
* 

Beachten Sie die Mittellinie ist nicht wie alle anderen wiederholt.

schließlich die Aufgabe selbst, die einfach sein können:

void starline(const int length) 
{ 
    for (int i=0; i<length; ++i) 
     std::cout.put('*'); 
    std::cout.put('\n'); 
} 

Sie können diese Programmfunktion übernehmen und verwenden Sie es in entweder Algorithmus oben dargestellt, und es wird funktionieren.

Schließlich werden die Parameter alle der oben genannten sind const, weil (a) gibt es keinen Grund, sie für diese Algorithmen zu ändern, und (b), wenn Sie versehentlich so tun, wollen Sie es bei der Kompilierung fangen Zeit; keine Laufzeit.

---

Beispiele

Beide Algorithmen verwenden die gleiche starline() Funktion früher gezeigt. Der einzige Unterschied ist die rekursive Funktion und die Ergebnisse, die sie ausgeben.

Der erste Algorithmus und seine Ausgabe unterhalb

#include <iostream> 

void starline(const int length) 
{ 
    for (int i=0; i<length; ++i) 
     std::cout.put('*'); 
    std::cout.put('\n'); 
} 

// function 
void star(const int amountStars, const int length = 1) 
{ 
    // termination case 
    if (length > amountStars) 
     return; 

    starline(length); 
    star(amountStars, length+1); 
    starline(length); 
} 

int main() 
{ 
    star(10); 
} 

Output

* 
** 
*** 
**** 
***** 
****** 
******* 
******** 
********* 
********** 
********** 
********* 
******** 
******* 
****** 
***** 
**** 
*** 
** 
* 

Die zweite ist unten gezeigt:

#include <iostream> 

void starline(const int length) 
{ 
    for (int i=0; i<length; ++i) 
     std::cout.put('*'); 
    std::cout.put('\n'); 
} 

// function 
void star(const int amountStars, const int length = 1) 
{ 
    starline(length); 

    // termination case 
    if (length == amountStars) 
     return; 

    star(amountStars, length+1); 
    starline(length); 
} 

int main() 
{ 
    star(10); 
} 

Output

* 
** 
*** 
**** 
***** 
****** 
******* 
******** 
********* 
********** 
********* 
******** 
******* 
****** 
***** 
**** 
*** 
** 
*