Code complet, mais crée une boucle infinie?

Question

J'essaye d'imprimer un modèle comme ci-dessous, j'ai le code courant sans erreurs mais il génère une boucle infinie et je ne suis pas certain pourquoi;

Un conseil ou une aide serait génial! Merci

#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

Votre fonction star() est lui-même appelle la ligne avec le commentaire « augmentation * par un », ce qui signifie qu'il est une fonction récursive. Mais la condition de terminaison est rompu

Vous l'initialiser le paramètre starShape, qui est de type char, avec un littéral « * » qui a une valeur ASCII de 42. Mais plutôt que d'utiliser cela comme le symbole, vous utilisez réellement local variable de chaîne shape pour effectuer l'impression. Et vous traitez starShape comme un compteur, que vous essayez d'utiliser pour terminer la boucle. Mais il commence à 42 et ne monte à partir de là, il ne sera jamais égale à la valeur de 30 que vous passez.

La façon de résoudre ce problème est de changer starShape à une int plus simple (mais pas le meilleur) et transmettre 0 de main.

#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 

Ensuite, lisez les fonctions récursives et les conditions de terminaison. :)

Answer 2

Essayez dans votre corps principal

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

vous faire la valeur de starShape à *, la valeur ascii * est de 42, de sorte que votre code ne se rencontrent jamais le code:

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

parce que 42 est supérieur à 30, c'est pourquoi votre la boucle est infinie.

Answer 4

Votre utilisation de la variable est incorrecte. En outre, le placement de votre point de terminaison récursif est discutable (et dans ce cas, inefficace en raison de l'ancien, l'utilisation variable variable). Enfin, vous augmentez le niveau local starShape directement à l'aide du pré-incrément. Il n'y a pas besoin de le faire, et les raisons en fait de ne pas le faire.

La forme spécifique que vous décrivez est un nombre ascendant (en montée) de caractères par ligne jusqu'à ce qu'un seuil soit atteint, puis en répétant cette même séquence en descendant (descente) en sens inverse. L'algorithme de le faire est:

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 
} 

Avis cette volonté, par votre exemple donné, contient une répétition dans le centre de la figure si la même tâche est effectuée à la fois avant et après, la récursion.Dans le cas d'un ascendant, descendant ensuite motif de ligne, il ressemblerait à ceci:

Si vous ne voulez pas la ligne centrale répète, vous vous déplacez simplement l'emplacement de la récursivité et changer la condition d'égaler plutôt que supérieure:

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

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

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

    // TODO: perform task 
} 

cela se traduira par un modèle qui ressemble à ceci:

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

Notez la ligne médiane est pas répété comme tous les autres.

Enfin, la tâche elle-même, qui peut être simplement:

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

Vous pouvez prendre cette fonction d'utilité et l'utiliser dans soit algorithme présenté ci-dessus, et cela fonctionnera.

Enfin, les paramètres à tous de ce qui précède sont const parce que (a) il n'y a aucune raison de les modifier pour ces algorithmes, et (b) si vous le faites par inadvertance, vous voulez l'attraper à compile- temps; pas d'exécution.

---

Exemples

Les deux algorithmes utilisent la même fonction starline() indiqué précédemment. La seule différence est la fonction récursive, et les résultats qu'ils émettent.

Le premier algorithme et sa sortie sont en dessous

#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); 
} 

sortie

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

La seconde est représentée suivant:

#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); 
} 

sortie

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