Torre de Hanoi em C++: Como resolver sem recursão

 Neste tutorial de C++, vamos te mostrar como resolver o clássico problema da Torre de Hanoi, que sempre explicam por aí usando funções recursivas.

Algoritmo da Torre de Hanoi

Muitas das respostas fornecem uma solução direta que converte um algoritmo recursivo em um usando uma pilha.

Porém, existem algoritmos disponíveis que são livres de pilha e podem resolver o problema a partir do estado inicial ou de um estado intermediário.

No livro “The Tower of Hanoi — Myths and Maths” de Andreas Hinz , no capítulo 2, os autores introduzem o “Algoritmo 3: algoritmo Idle Peg” que opera com base na seguinte ideia:

1. Introduza um dedal começando no pino da fonte. A cada volta, pegue o dedal com a mão esquerda e mova-o pelos pinos em ordem, formando um ciclo.
2. Em seguida, com a mão direita, faça o único movimento legal evitando a cavilha que está bloqueada pelo dedal.
   
   
   

Nenhuma recursão necessária e nenhuma pilha de rastreamento de volta é necessária. É apenas um loop simples. Mas você precisa rastrear quais discos estão em qual pino para fazer a parte do “movimento legal”. Você pode fazer isso com uma matriz (uma localização para cada disco) ou com três pilhas, uma para cada pino.

Algoritmo 3 em pseudocódigo, do livro:

1. Parameter n: number of disks
2. Parameter i: source peg
3. Parameter j: goal peg
4.  
5. idle <- i
6. dir <- (-1)^n (j-i)
7. while not all discs are on peg j:
8. idle <- (idle + dir) mod 3
9. make legal move between pegs different from idle
10. end while

Código C++ da Torre de Hanoi

Para fazer isso em C++, simplificarei assumindo que o pino de origem é 0 e o pino de destino é 1 para eliminar a variável de direção. (Isso significa que minha implementação só funcionará corretamente para até n!) .

Usaremos pilha para cada um dos pinos para que encontrar o disco superior seja um tempo constante (e assim não preciso escrever um loop extra).

Veja o código da Torre de Hanoi em C++:

1. void tower_of_hanoi( int n ) {
2. int idle = 0;
3. std::stack<int> pegs[3];
4.  
5. // Disco numérico de 1 a n, n é o maior
6. for (int i = 0; i < n; i++ ) {
7. pegs[0].push( n - i );
8. }
9.  
10. while ( pegs[1].size() < n ) {
11. idle = (idle + 1) % 3;
12. int from, to;
13. switch (idle) {
14. case 0: from = 1; to = 2; break;
15. case 1: from = 0; to = 2; break;
16. case 2: from = 0; to = 1; break;
17. }
18. // Deve mover o disco menor para o disco maior
19. if ( pegs[from].empty() ||
20. (!pegs[to].empty() && pegs[from].top() > pegs[to].top()) ) {
21. std::swap( from, to );
22. }
23. int disc = pegs[from].top();
24. std::cout << "Mover disco " << disc << " de " << from << " para " << to << "\n";
25. pegs[from].pop();
26. pegs[to].push( disc );
27. }
28. }

O livro contém muitos outros algoritmos. Por exemplo, aqui está aquele que encontra o melhor movimento para um estado perfeito, dado qualquer estado regular arbitrário (ou seja, legal). É o algoritmo 10 no mesmo capítulo:

1. Parameter n: number of disks
2. Parameter s[1..n]: regular state, given as an array
3. Parameter j: goal peg
4.  
5. mu <- 0 // length of path
6. delta <- n+1 // active disc
7. k <- j // "state of the P1-automaton",
8. for d = n down to 1
9. if s[d] <> k then
10. mu <- mu + 2^(d-1)
11. delta <- d
12. k <- 3 - k - s[d]
13. end if
14. end for

Nenhuma pilha ou recursão é necessária! O algoritmo fornece o disco para mover e o comprimento do caminho para o estado final de nosso objetivo.

Números primos em C++ - Como descobrir

Neste tutorial, vamos destrinchar os primos. Vamos aprender como verificar se um número é primo ou não, bem como exibir uma lista de quantos primos quisermos, usando laços e loopings, em C++.

Números Primos na Matemática

Um número é dito ser primo quando pode ser dividido somente por 1 e por ele mesmo.
O 7 é primo, você pode dividir só por 1 e por 7, por qualquer outro valor vai dar um resultado quebrado.

O 12 não é primo, pois pode ser dividido por 1, 2, 3, 4, 6 e 12.

Vejamos alguns números primos: 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997...

Os primos são uma classe muuuuito especial na Matemática, tendo utilidade em diversos ramos e áreas, como na criptografia.

Vale a pena pesquisar sobre eles, há todo um véu de mistério neles, pois tentam há milênios encontrar uma fórmula para gerar números primos e nada até hoje deu certo.

Será que um dia você consegue? Quem sabe...se ganhar o prêmio Nobel, não esquece de compartilhar a grana com a gente...

Simbora caçar uns primos?

Como Descobrir se um número é primo

Para verificar se um número num é primo, basta verificar seus divisores, de 1 até num.

Por exemplo, vamos testar se o 9 é primo. Basta analisar o resto da divisão por 1, 2, 3, 4, 5, 6, 7, 8, e 9.
Se for primo, somente vai ser divisível por 1 e por ele mesmo, logo vai ter 2 divisores. Mas o resto da divisão vai dar 0 quando fizermos 9%3, logo 3 também é divisor, totalizando 3 divisores, logo não é primo.

Agora o 11.
Podemos pegar o resto da divisão por 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 e 11, que só vai dar 0 pra 1 e pra 11.
Logo, ele é primo.

Ou seja, basta fazer o resto da divisão de num por 1, 2, 3, 4, 5, ..., até num, e contar na variável div (inicializada com 0), quantos divisores tem.

Se for 2, é primo.
Se for mais que 2, não é primo.

Veja o código:

#include <iostream>
using namespace std;

int main()
{
    int aux, num=479001599, div=0;

    for(aux=1 ; aux<=num ; aux++)
        if(num%aux==0)
            div++;

    if(div==2)
        cout<<"É primo"<<endl;
    else
        cout<<"Não é primo"<<endl;
    return 0;
}

Testamos com um número primo gigante, o 479001599.
Aqui levou 1.831s pra verificar, e na sua máquina?

Otimizando a busca por primos

Ora, todo número é divisível por 1.
Então não precisamos fazer o resto da divisão por 1, já é uma checagem a menos.

E também não precisamos testar até num.
Passou da metade, não vai ter mais nenhum divisor possível.

Dando uma enxugada no código, ele fica assim:

#include <iostream>
using namespace std;

int main()
{
    int aux, num=479001599, div=0;

    for(aux=2 ; aux<=num/2 ; aux++)
        if(num%aux==0)
            div++;

    if(div==0)
        cout<<"É primo"<<endl;
    else
        cout<<"Não é primo"<<endl;
    return 0;
}

Agora levou só 1.012s
E na sua máquina?

Podemos ir mais além e calcular até a raiz quadrada de num, ao invés de apenas até num/2 (pesquise o motivo disso):

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

int main()
{
    int aux, num=479001599, div=0;

    for(aux=2 ; aux<=sqrt(num) ; aux++)
        if(num%aux==0)
            div++;

    if(div==0)
        cout<<"É primo"<<endl;
    else
        cout<<"Não é primo"<<endl;
    return 0;
}

0.004s ! Carai, maluco!

Achando primos num intervalo

Agora vamos imprimir todos os primos num determinado intervalo, de 1 até um valor Máximo, como 100.

Primeiro, uma variável pra testar todos os números de 2 até Max, é a aux.

Para cada número, vamos contar todos os divisores e armazenar na variável div, por isso ela deve começar zerada dentro do primeiro laço.

No segundo FOR, vamos verificar cada número aux, fazendo o resto da divisão deles por 2 até raiz quadrada do número, para verificar se tem divisores.

Se tiver, cai no IF (IF dentro de um FOR que está dentro de outro FOR, que loucura!), que incrementa div.

Após toda essa verificação interna, ele é primo se div tiver 0 como valor, se tiver, então imprimimos o valor de aux, pois é um primo.

Veja como fica o código:

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

int main()
{
    int aux, coun, Max=100, div;

    for(aux=2 ; aux<=Max ; aux++){
        div=0;

        for(coun=2 ; coun<=sqrt(aux) ; coun++)
            if(aux%coun==0)
                div++;

        if(!div)
            cout<<aux<<" ";
    }

    cout<<endl;

    return 0;
}

Teste com mil, 10 mil, 1 milhão...só agora você tem real noção do poder e capacidade de calcular que tem sua máquina

Fibonacci com Laços em C++

Neste tutorial de nosso curso de C++, vamos aprender como exibir os termos da série de Fibonacci, usando apenas laços!

Fibonacci em C++ com laço FOR

Os dois primeiros termos da série são: 0 e 1.
Então, vamos pedir números inteiros acima de 2.

Vamos armazenar nas variáveis ult e penult o último número da sequência e o penúltimo, assim inicialmente:
ult = 1
penult = 0

Pedimos o número ao usuário e armazenamos em n.
Vamos para a nossa estrutura de repetição, o FOR.

Como já exibimos os dois primeiros termos da sequência: 0 e 1
Nossa contagem começa no terceiro membro da sequência: aux = 3
E ele vai até percorrer n iterações: aux <= n
Isso garante que n elementos da sequência sejam exibidos.

Dentro do FOR, primeiro, imprimimos o próximo termo: ult + penult

Agora vem o pulo do gato.
O novo valor de ult será a soma dele mesmo com o número anterior, penult.
E o valor novo de penult será ult.

Queremos fazer isso:
penult = ult = 1
ult = 1 + 0 = 1

O problema é que quando fazemos: penult = ult, o valor original de penult é perdido, que é o valor antigo que iríamos utilizar para calcular o novo valor de ult.

A solução pra isso é armazenar o valor antigo de penult na variável temporária temp.
Então é só fazer:
temp = penult;
penult = ult;
ult = ult + temp;

Pronto, agora a sequência 'andou', e está pronta para exibir o próximo termo.
Veja como fica nosso código:

#include <iostream>
using namespace std;

int main()
{
    int n, aux, temp, ult=1, penult=0;

    cout << "Exibir quantos termos: ";
    cin >> n;

    cout << penult << endl << ult << endl;

    for(aux=3 ; aux<=n ; aux++){
        cout << (ult+penult) << endl;

        temp = penult;
        penult = ult;
        ult = ult + temp;
    }

    return 0;
}

Fibonacci com laço WHILE em C++

#include <iostream>
using namespace std;

int main()
{
    int n, aux=3, temp, ult=1, penult=0;

    cout << "Exibir quantos termos: ";
    cin >> n;

    cout << penult << endl << ult << endl;

    while(aux<=n){
        cout << (ult+penult) << endl;

        temp = penult;
        penult = ult;
        ult = ult + temp;

        aux++;
    }

    return 0;
}

Você consegue fazer com laço DO WHILE, que fica calculando quantos termos quiser, em um looping que só acaba quando o usuário digita 0?

Escreva nos comentários.

Estrutura de Repetição FOR - Laço controlado em C++

Finalizando a apresentação das estruturas de repetição de nosso Curso de C++, vamos apresentar o laço FOR, o looping controlado.

Estrutura de repetição FOR em C++

A instrução de repetição FOR tem a seguinte sintaxe:

for(inicialização ; teste_condicional ; atualização){
   // código que executa enquanto
   // o teste condicional
   // for verdadeiro
}

Vamos lá.
A estrutura de repetição FOR tem três expressões dentro dela, separadas por ponto e vírgula.

O laço começa com algum tipo de inicialização, geralmente uma variável de contagem, com algum valor inicial.

Após essa inicialização, ocorre o teste condicional. Se for verdadeiro, o código dentro das chaves do laço FOR é executado.

Após cada iteração, ocorre a 'atualização', onde geralmente atualizamos o valor do contador, muito comumente é uma variável que vai se incrementar ou decrementar.

Então, novamente o teste condicional é realizado, em caso de ser verdadeiro, novamente o código do FOR é executado. Após essa iteração, ocorre mais uma vez a atualização.

Exemplo de uso do laço FOR

Em programação, um exemplo vale mais que mil palavras.
Vamos contar de 1 até 10, usando o laço for, o código é o seguinte:

#include <iostream>
using namespace std;

int main()
{
    int count;

    for(count=1; count<=10 ; count++){
        cout << count << endl;
    }

    return 0;
}

A nossa variável de controle é a count, que vai iniciar valendo 1.
Vamos printar ela na tela enquanto seu valor for menor ou igual a 10.
A cada iteração, incrementamos ela em uma unidade (count++), pois queremos que ela vá de 1 até 10.

Note que já fazíamos isso no laço WHILE, mas inicializávamos as variáveis antes do laço, dentro dele a gente atualizava a variável a cada loop e ocorria o teste condicional dentro dos parêntesis do WHILE.

Ocorre a mesma maneira no laço FOR, mas de maneira mais organizado.

Como usar a estrutura de repetição FOR

Vamos fazer o contrário agora, uma contagem regressiva, que conta de 100 até 1.
Para isso, inicializamos nossa variável de controle como 100.

O teste a ser realizado é: count > 0
Ou seja, enquanto a variável tiver um valor acima de 0, as iterações do laço FOR vão ocorrer.

E a cada iteração temos que decrementar o count, pois ele vai de 100 pra 1, de um em um.
Veja como ficou nosso código:

#include <iostream>
using namespace std;

int main()
{
    int count;

    for(count=100; count>0 ; count--){
        cout << count << endl;
    }

    return 0;
}

Nem sempre, porém, vamos incrementar ou decrementar de 1 em 1.
Podemos atualizar nossas variáveis da maneira que quisermos.

Por exemplo, vamos imprimir na tela todos os números pares de 1 até mil.
O primeiro par é o 2, então inicializamos nossa variável com esse valor.
Vamos incrementar de 2 em 2: count += 2
E o teste é enquanto a variável for menor ou igual a mil: count <= 1000

#include <iostream>
using namespace std;

int main()
{
    int count;

    for(count=2; count<=1000 ; count+=2){
        cout << count << endl;
    }

    return 0;
}

Veja a incrível velocidade com que esse código é executado.
Duvida da capacidade do C++? Coloque 1 milhão.

Quando usar o laço FOR

Muitas vezes, queremos fazer loopings com determinado número de iterações.
Por exemplo, ao pedir as notas de um aluno, vamos pedir o tanto de matérias que existem, para calcular a média.

Para calcular seu imposto de renda, precisamos somar todo seu salário do ano, ou seja, 13 salários (tem o décimo terceiro).

O laço FOR é ideal quando você sabe exatamente o número de iterações que vai fazer: "ah, quero calcular isso nesse intervalo de x até y", então pimba, use a estrutura de repetição FOR.

Quando não sabe quando o looping deve terminar ou tem menos controle sobre quantas iterações devem ocorrer, aí use o laço WHILE.

Lembrando que, no fundo, eles são absolutamente a mesma coisa.
Só vai ser mais fácil trabalhar com FOR algumas vezes e com WHILE em outras ocasiões.

Estrutura de Repetição FOR

Crie um programa que pede quantas notas você quer calcular a média, em seguida pede cada uma dessas notas e por fim exibe a média.

Vamos armazenar o número de notas que vamos pedir na variável n.
O próximo passo é pedir nota por nota, e aqui vem o pulo do gato: calcular a soma de todas as notas.

Dentro do FOR, a variável de controle aux vai da nota 1 até a nota n, pedindo uma por uma e armazenando essa nota na variável grade.

Vamos armazenar na variável sum, a soma de todas essas notas.

Por fim, exibimos sum/n para exibir a média.
Veja nosso código C++:

#include <iostream>
using namespace std;

int main()
{
    int aux, n;
    float grade, sum=0;

    cout <<"Quantas matérias: ";
    cin >> n;

    for(aux=1; aux<=n ; aux++){
        cout <<"Nota "<<aux<<": ";
        cin >> grade;
        sum += grade;
    }

    cout << "Média: "<<(sum/n)<<endl;

    return 0;
}

Note como essa estrutura de repetição é controlada: ela vai sempre rodar 'n' iterações, seja lá qual o valor de 'n' (obviamente, o número de notas deve ser um valor inteiro positivo).

Pode preencher com 2 notas, 3 notas, mil notas, um milhão de notas...
Poderoso, esse laço FOR não é?

DO ... WHILE looping em C++

Neste tutorial de C++, vamos aprender a usar o looping do...while em C++, através de exemplos prontos com código comentado.

O Looping DO ... WHILE

Recapitulando: loop é um determinado trecho de código que pode se repetir quantas vezes desejarmos. Já estudamos o looping WHILE em C++, agora vamos conhecer o DO WHILE.

Lembrando que no laço WHILE, o teste condicional ocorre antes da execução do loop.
Essa é a principal diferença pro laço DO WHILE, neste, o teste condicional vai acontecer somente depois de cada iteração (repetição do código interno do laço).

A estrutura do looping DO WHILE é:

do
{
   // código
   // código
} while (condição) ; 

Ou seja, primeiro o código é executado (DO significa faça, em inglês).
Depois, ocorre o teste condicional dentro dos parêntesis do while.
Se for verdade, o código é repetido novamente, e de novo e de novo, enquanto a condição for verdadeira.

Veja o fluxograma:

Como usar DO WHILE em C++

A primeira coisa que você deve ter em mente ao decidir usar o DO WHILE, é que ele vai executar o código pelo menos uma vez! Ou seja, sempre executa uma iteração do laço!

Um uso muito comum é em menus. Um menu é sempre exibido pelo menos uma vez (seja num jogo ou no seu sistema bancário).

Vamos criar um menu de um banco.
Veja nosso código:

#include <iostream>
using namespace std;

int main()
{
    int op;

    do
    {
        cout << "Escolha uma opção:\n";
        cout << "0. Sair\n";
        cout << "1. Saldo\n";
        cout << "2. Extrato\n";
        cout << "3. Saque\n";
        cout << "4. Transferência\n";
        cin >> op;

    } while(op);

    return 0;
}

Cada vez que você digita uma opção, ele pode ir para uma seção diferente do sistema (aprenderemos como fazer isso usando funções), e só sai se você digitar 0 (ou seja, enquanto o valor op for diferente de 0, o laço ocorre, pois todo valor diferente de 0 é verdadeiro, só o 0 é False).

Note que nem precisamos inicializar a variável (se fossemos usar o laço while, precisaríamos inicializar, para garantir que o loop ocorresse pelo menos uma vez).

Exemplo de uso de DO WHILE

Usamos o looping do while também quando queremos fazer algo pelo menos uma vez, e queremos dar a opção de tudo se repetir novamente.

Por exemplo, o código abaixo calcula a média de duas notas que o usuário fornecer.
Ao final, ele pergunta se você deseja calcular outra média:

#include <iostream>
using namespace std;

int main()
{
    float grade1, grade2;
    int op;

    do
    {
        cout << "Primeira nota: ";
        cin >> grade1;

        cout << "Segunda nota: ";
        cin >> grade2;

        cout <<"Média: " << (grade1+grade2)/2 << endl;
        cout <<"Calcular novamente ?\n";
        cout <<"1. Sim\n";
        cout <<"2. Não\n";
        cin >> op;

    } while(op!=2);

    return 0;
}

Ou seja, a pessoa que usar esse programa poderá calcular quantas médias quiser, até infinitamente, graças ao looping do while.

Então, sempre que precisar rodar um código pelo menos uma vez (mas não sabe quantas vezes, depende do usuário), use o looping DO WHILE.

Por exemplo:

do
{
   cout << "Blá blá blá (ou digite 0 pra sair): ";
   //código
   //do seu sistema
} while(op);

Bacana ele, não é?

O laço WHILE em C++: Como usar a estrutura de repetição

Neste tutorial de laços e loopings, vamos apresentar a estrutura de repetição while, em C++.

Laço WHILE: Estrutura de Repetição

Como o nome pode sugerir na introdução, é uma estrutura que nos permite fazer repetições de determinados trechos de código em C++.

A estrutura do C++ é a seguinte:

while(teste){
   // Código caso o 
   // teste seja verdadeiro
}

Então, começa com o comando while, depois parêntesis, e dentro destes deve ter algum valor booleano, geralmente é uma expressão, um teste condicional que vai retornar verdadeiro ou falso.

Enquanto (while em inglês) aquele valor dentro dos parêntesis for verdadeiro, o código dentro da instrução while vai rodar.

Cada repetição é chamada iteração. Podem existir nenhuma, uma, mil, um milhão ou infinitas iterações em um laço (loopings infinitos), vai depender de como se comporta o teste condicional.

Veja o fluxograma do laço WHILE:

Exemplo de uso de WHILE - Estrutura de Repetição

Vamos para os exemplos, assim aprendemos melhor.

Vamos criar um programa que exibe na tela os números de 1 até 10.
Para isso, vamos usar uma variável de controle, vamos chamar de count, pois será nosso contador.

Inicializamos com valor 1.
O teste condicional é: enquanto count for menor ou igual a 10
Dentro do WHILE damos o cout para imprimir o número.
Em seguida, temos que incrementar o contador em uma unidade, veja o código:

#include <iostream>
using namespace std;

int main()
{
    int count=1;

    while(count<=10){
        cout << count << endl;
        count++;
    }
    return 0;
}

O que ocorre é o seguinte. O código chega no WHILE, e lá ele testa se a variável é menor ou igual a 10.
Como ela vale 1, o teste é verdadeiro e entra no código. Lá imprimimos a variável, e incrementamos o contador.

Depois, o teste ocorre novamente, agora nossa variável vale 2 e dá verdadeiro para o teste, sendo executado seu código.

Depois, o teste ocorre com o contador valendo 3 , e assim vai indo, até o contador ser 10.
Nesse caso, o teste ainda é verdadeiro.

Porém dentro do código, o contador incrementa e vira 11.
Quando for testar de novo, o resultado é falso, então a estrutura de repetição para de rodar e termina o laço.

Veja como seria o código do contrário, exibindo de 10 até 1:

#include <iostream>
using namespace std;

int main()
{
    int count=10;

    while(count>0){
        cout << count << endl;
        count--;
    }
    return 0;
}

Como usar laço WHILE em C++

O exemplo abaixo é um looping infinito, mas o teste dentro do laço WHILE é sempre verdadeiro, então ele via ficar imprimindo a mensagem na tela infinitamente...

#include <iostream>
using namespace std;

int main()
{
    while(1)
        cout << "Curso C++ Progressivo\n";

    return 0;
}

Podemos também fazer uma contagem infinita:

#include <iostream>
using namespace std;

int main()
{
    int count=1;

    while(count++)
        cout << count << endl;

    return 0;
}

Note que colocamos o operador de incremento diretamente dentro do laço while.
Também não usamos chaves, isso é permitido pois o código do while tem apenas uma linha.

WHILE em C++: Validando entradas

Uma das funcionalidades do comando WHILE é ficar validando a entrada do usuário.
Por exemplo, vamos pedir uma nota ao usuário, de 0 até 10.

Se ele digitar menor que 0 ou maior que 10, vai entrar no WHILE.
Dentro da estrutura de repetição, avisamos que ele inseriu uma nota errada e pedimos que ele insira a nota novamente.

O laço while é um laço teimoso...ele se repete quantas vezes forem necessárias.
Quer ver? Teste colocar notas menor que 0 ou maior que 10, ele só vai parar quando a nota digitada for entre 0 e 10:

#include <iostream>
using namespace std;

int main()
{
    int grade;

    cout << "Digite uma nota: ";
    cin >> grade;

    while(grade<0 || grade>10){
        cout <<"Nota inválida, digite outra vez: ";
        cin >> grade;
    }

    return 0;
}

Bem simples, porém poderoso, essa estrutura de controle.

Exemplo de uso de WHILE em C++

Crie um programa que pede um número ao usuário e exibe a tabuada deste número.

Vamos armazenar o número digitado na variável num. Nossa variável de controle é a aux, que vai percorrer de 1 até 10.

Veja como fica nosso código:

#include <iostream>
using namespace std;

int main()
{
    int num, aux=1;

    cout << "Digite um numero: ";
    cin >> num;

    while(aux<=10){
        cout <<num<<" x "<<aux<<" = "<<num*aux<<endl;
        aux++;
    }

    return 0;
}