[Dúvidas com Execícios]

Você tentou fazer alguma parte? Mostre o código que você tentou fazer e vamos tentar lhe ajudar.

[Dúvidas com Execícios]

Mostre o que você tentou fazer e lhe ajudaremos; não fazemos dever de casa.

[Duvida somando numeros]

Olá, amigo.

Fiz o código para o programa em C++ (não sei programar em C). Deve servir de base para você entender a lógica.

Qualquer dúvida me avise.

#include <iostream>
#include <locale>
#include <vector>

using namespace std;

int n = 0; int Numero_de_Primos = 0;
vector<float> Primos;


void Primos_ate_n(int);
void Construir_Sequencia(vector<float>, int);
void Mostrar_Soma(vector<float>, int);

void Primos_ate_n(int n)
{
    Primos.resize(n);
    Primos[0] = 2;

    int i = 0; int j = 0; int Numero_de_Divisores = 0; int Vector_Index = 1;

    for(i = 3; i <= n; i++)
    {
        Numero_de_Divisores  = 0;
        for(j = 2; j < i; j++)
        {
            if ( i % j == 0)
            {
                Numero_de_Divisores++;
            }

        }
        if (Numero_de_Divisores == 0)
        {
            Primos[Vector_Index] = i;
            Vector_Index++;
            Numero_de_Primos++;
        }
    }
    Construir_Sequencia(Primos,Numero_de_Primos);
}

void Construir_Sequencia(vector<float> Primos, int Numero_de_Primos)
{
    int i = 0;
    for (i = 0; i <= Numero_de_Primos;i++)
    {
        if (i == 0 || i % 2 == 0)
        {
            Primos[i] = 1/(Primos[i]);
        }
        else
        {
            Primos[i] = (1/Primos[i]) * (-1);
        }
    }

    Mostrar_Soma(Primos, Numero_de_Primos);

}

void Mostrar_Soma(vector<float> Primos, int Numero_de_Primos)
{
    int i = 0; float Soma = 0;
    for (i = 0; i <= Numero_de_Primos; i++)
    {
        Soma +=  Primos[i];
    }

    cout << "\n\nO valor da soma é: " << Soma << endl;
}

int main()
{
    setlocale(LC_ALL, "Portuguese");
    cout << "Digite até que valor a sequência deve ir" << endl;
    cin >> n;
    Primos_ate_n(n);
    cin.get();
    return 0;
}

Att.,
Pedro

[programa c++ /]

Olá, amigos.

Se vocês declarem "q" como int, ao fazer q = x/y automaticamente vocês já terão o valor do quociente inteiro.

Suponha x = 5, y = 3:

5/3 = 1,66 --> q = parte inteira de 1,66 = 1

x = 6, y = 4:

6/4 = 1,5 --> q = parte inteira de 1,5 = 1

x = 29, y = 3

29/3 = 9,66 --> q = parte inteira de 9,66 = 9

Att.,
Pedro

[Enquanto - While em C]

Fiz um código básico para esse programa em C++:

#include <iostream>
#include <vector>
#include <locale>
#include <limits>

using namespace std;

vector<float> Alturas_dos_Homens;
vector<float> Alturas_das_Mulheres;
float Numero_de_Homens = 0;
float Numero_de_Mulheres = 0;
float Maior_altura_dos_Homens = 0;
float Menor_altura_dos_Homens = 0;
float Maior_altura_das_Mulheres = 0;
float Menor_altura_das_Mulheres = 0;

void Perguntar_Valores(vector<float>&, vector<float>&);
void Calcular_maior_e_menor_alturas(vector<float>&, vector<float>&);
void Media_de_altura_das_Mulheres(float, float);
void Quantidade_de_Homens(float);
void Sexo_da_pessoa_mais_alta(float,float);

void Perguntar_Valores(vector<float>& Alturas_dos_Homens, vector<float>& Alturas_das_Mulheres)
{
    int i = 0; int j = 0; int Sexo; int Sim_ou_Nao = 0; bool Continuar = true;
    while ( Continuar == true)
    {
     Sexo = 0;
    cout << "Digite o sexo da pessoa (1 - Homem / 2 - Mulher)" << endl;
    cin >> Sexo;
    cin.sync();
    if (Sexo == 1)
    {
        Numero_de_Homens++;
        Alturas_dos_Homens.resize(Numero_de_Homens);
        cout << "\nDigite a altura da pessoa (em metros)." << endl;
        cin >> Alturas_dos_Homens[i];
        if (!cin)
        {
        cin.clear();
        cin.ignore(numeric_limits<streamsize>::max(), '\n');
        cout << "Valor inválido." << endl << endl;
        Numero_de_Homens--;
        Perguntar_Valores(Alturas_dos_Homens,Alturas_das_Mulheres);
        }
        i++;
    }
    else if (Sexo == 2)
    {
        Numero_de_Mulheres++;
        Alturas_das_Mulheres.resize(Numero_de_Mulheres);
        cout << "\nDigite a altura da pessoa (em metros)." << endl;
        cin >> Alturas_das_Mulheres[j];
        if (!cin)
        {
        cin.clear();
        cin.ignore(numeric_limits<streamsize>::max(), '\n');
        cout << "Valor inválido." << endl << endl;
        Numero_de_Mulheres--;
        Perguntar_Valores(Alturas_dos_Homens,Alturas_das_Mulheres);
        }
        j++;
    }
    else if ( Sexo != 1 || Sexo != 2 || !cin)
    {
        cin.clear();
        cin.ignore(numeric_limits<streamsize>::max(), '\n');
        cout << "Opção inválida" << endl << endl;
        Perguntar_Valores(Alturas_dos_Homens,Alturas_das_Mulheres);
    }
    cout <<"\nDeseja inserir informações de outra pessoa? (1 - Sim/ 2 - Não) " << endl;
    cin >> Sim_ou_Nao;
    cin.sync();
    cout << "\n\n";
    switch(Sim_ou_Nao)
    {
        case 1:
        Continuar = true;
        break;
        case 2:
        Continuar = false;
        break;
        default:
        cout << "Opção inválida. Continuando o programa" << endl << endl;
        Continuar = false;
    }
}
    Calcular_maior_e_menor_alturas(Alturas_dos_Homens, Alturas_das_Mulheres);
}

void Calcular_maior_e_menor_alturas(vector<float>& Alturas_dos_Homens, vector<float>& Alturas_das_Mulheres)
{
    int i = 0; int j = 0;
    float Maior_altura = 0; float Menor_altura = 0;
    if (Numero_de_Homens > 1)
    {
    for (i = 0; i < Numero_de_Homens; i++)
    {
        if ( i != Numero_de_Homens - 1)
        {
        if (Alturas_dos_Homens[i+1] > Alturas_dos_Homens[i])
        {
            Maior_altura_dos_Homens = Alturas_dos_Homens[i+1];
            Menor_altura_dos_Homens = Alturas_dos_Homens[i];
        }
        else
        {
            Maior_altura_dos_Homens = Alturas_dos_Homens[i];
            Menor_altura_dos_Homens = Alturas_dos_Homens[i+1];
        }
        }
        else
        {
            if ( Alturas_dos_Homens[i] > Maior_altura_dos_Homens)
            {
                Maior_altura_dos_Homens = Alturas_dos_Homens[i];
            }
        }
    }
    }
    else
    {
        Maior_altura_dos_Homens = Menor_altura_dos_Homens = Alturas_dos_Homens[0];
    }
    if (Numero_de_Mulheres > 1)
    {
    for (j = 0; j < Numero_de_Mulheres; j++)
    {
        if ( j != Numero_de_Mulheres-1)
        {
         if (Alturas_das_Mulheres[j+1] > Alturas_das_Mulheres[j])
        {
            Maior_altura_das_Mulheres = Alturas_das_Mulheres[j+1];
            Menor_altura_das_Mulheres = Alturas_das_Mulheres[j];
        }
        else
        {
            Maior_altura_das_Mulheres = Alturas_das_Mulheres[j];
            Menor_altura_das_Mulheres = Alturas_das_Mulheres[j+1];
        }
        }
        else
        {
            if (Alturas_das_Mulheres[j] > Maior_altura_das_Mulheres)
            {
                Maior_altura_das_Mulheres = Alturas_das_Mulheres[j];
            }
        }
    }
    }
    else
    {
      Maior_altura_das_Mulheres = Menor_altura_das_Mulheres = Alturas_das_Mulheres[0];
    }

    if (Maior_altura_dos_Homens > Maior_altura_das_Mulheres)
    {
        Maior_altura = Maior_altura_dos_Homens;
    }
    else
    {
        Maior_altura = Maior_altura_das_Mulheres;
    }
    if (Menor_altura_dos_Homens < Menor_altura_das_Mulheres)
    {
        Menor_altura = Menor_altura_dos_Homens;
    }
    else
    {
        Menor_altura = Menor_altura_das_Mulheres;
    }

    cout << "\n\nA maior altura do grupo é: " << Maior_altura << "m" << endl;
    cout << "\n\nA menor altura do grupo é: " << Menor_altura << "m" << endl;
}

void Media_de_altura_das_Mulheres(vector<float>& Alturas_das_Mulheres, float Numero_de_Mulheres)
{
    int i = 0;
    float Soma_das_alturas_das_Mulheres = 0;
    for(i = 0; i < Numero_de_Mulheres; i++)
    {
        Soma_das_alturas_das_Mulheres += Alturas_das_Mulheres[i];
    }

    cout << "\n\nA média das alturas das mulheres é: " << (Soma_das_alturas_das_Mulheres)/(Numero_de_Mulheres) << "m" << endl;
}

void  Quantidade_de_Homens (float Numero_de_Homens)
{
    cout << "\n\nO numero de homens é: " << Numero_de_Homens << endl << endl;
}

void Sexo_da_pessoa_mais_alta (float Maior_altura_dos_Homens, float Maior_altura_das_Mulheres)
{
    if (Maior_altura_dos_Homens > Maior_altura_das_Mulheres)
    {
        cout << "A pessoa com a maior altura ( " << Maior_altura_dos_Homens << "m ) é um homem.";
    }
    else
    {
        cout << "A pessoa com a maior altura ( " << Maior_altura_das_Mulheres << "m ) é uma mulher.";
    }

}

int main()
{
    setlocale(LC_ALL, "Portuguese");
    Perguntar_Valores(Alturas_dos_Homens,Alturas_das_Mulheres);
    Media_de_altura_das_Mulheres(Alturas_das_Mulheres, Numero_de_Mulheres);
    Quantidade_de_Homens(Numero_de_Homens);
    Sexo_da_pessoa_mais_alta(Maior_altura_dos_Homens, Maior_altura_das_Mulheres);
    cin.get();
    return 0;
}

Poste a sua tentativa para que possamos comparar os códigos e a lógica e melhorar o programa.

Att.,
Pedro

[Efetuando a expressão]

Olá, amigos.

ArteEN, cuidado com o seu loop: numeroqualquer < 1 só impede que o usuário dê valores decimais menores do que 1 para n. Se ele digitar 2.5, por exemplo, o seu programa deixa passar.

Fiz da seguinte maneira:

/*
Coder: Pedro Milreu Cunha
Tester: Pedro Milreu Cunha
Date: 04/21/2015
*/

#include <iostream>
#include <limits>
#include <iomanip>
#include <locale>

using namespace std;

float n = 0;
float Valor_da_Soma = 0;

void Perguntar_valor_da_variavel(float);
void Calcular_Soma(float);
void Mostrar_soma(float);

void Perguntar_valor_da_variavel(float n)
{
    int parte_inteira_n = 0;
    cout << "\n\nDigite o valor de n (n deve ser positivo e inteiro)." << endl;
    cin >> n;
    cin.sync();
    parte_inteira_n = n;
    if ( (!cin) || (n < 0) || ((n - parte_inteira_n) != 0))
    {
        cout << "\nValor inválido." << endl;
        cin.clear();
        cin.ignore(numeric_limits<streamsize>::max(), '\n');
        Perguntar_valor_da_variavel(n);
    }
    else
    {
      cin.sync();
      Calcular_Soma(n);
    }
}

void Calcular_Soma(float n)
{
    float i = 0;
    float soma_parcial = 0;
    for (i = 1; i <= n; i++)
    {
        soma_parcial = (1/i);
        Valor_da_Soma += soma_parcial;
    }
    Mostrar_soma(Valor_da_Soma);
}

void Mostrar_soma(float Valor_da_Soma)
{
    cout << fixed << setprecision(6) << endl;
    cout << "O valor da soma é " <<  Valor_da_Soma << endl;
}

int main()
{
    setlocale(LC_ALL, "Portuguese");
    Perguntar_valor_da_variavel(n);
    cin.get();
    return 0;
}

Abraços,
Pedro

[NÚMEROS PRIMOS EM UMA MATRIZ 3X3]

Uma ideia seria usar um for-loop e acessar um elemento da matriz de cada vez. Para checar se é primo, para acelerar, veja se ele é par e diferente de 2; se for, já não é primo. Para os números que não se encaixarem, verifique (utilizando um for-loop novamente) qual o resto da divisão deles por todos os números entre 2 e n/2 (onde n é o número em questão). Se algum dos restos for 0, aborte o loop pois o número não é primo. Se nenhum dos restos for 0, o número é um número primo.

Att.,

Pedro

[Enquanto - While em C]

Mostre o que você tentou fazer e tentaremos lhe ajudar.

Obs.: fiz o programa. Não é muito difícil. Tenho certeza que se tentar irá conseguir.

[Enquanto - While em C]

O que você tentou fazer?

Mostre o seu código e tentaremos lhe ajudar.

Não podemos ajudar se você nem tentar.

Att.,
Pedro

[Resolvedor de equações quadráticas]

Olá, amigos.

Poderiam me dizer o que acham do meu programa? Críticas, sugestões, etc. .

#include <iostream>
#include <locale>
#include <math.h>
#include <cmath>
#include <complex>
#include <windows.h>
#include <conio.h>
#include <limits>
using namespace std;

float a = 0; float b = 0; float c = 0;float x1 = 0; float x2 = 0;
double Delta = 0;
bool repetir = false;
int i = 0; int Sim_ou_Nao = 0;

void Instrucoes(bool);
void ClearScreen();
float Descobrir_Coeficientes (float,float,float, bool);
float Calcular_Raizes(float, float, float);
float Mostrar_Raizes (float,float);
float Mostrar_Raizes_Complexas(float,float, float);
bool Repetir(bool);

void Instrucoes(bool repetir)
{
    if ( (i == 0 ) || (repetir == true))
    {
    cin.sync();
    cout << "\não digitar os coeficientes, utilize apenas números e o '.' para representar\nnúmeros decimais." << endl;
    cout << "\nNão utilize frações nem expoentes. " << endl << endl;
    cout << "Pressione qualquer tecla para continuar" << endl;
    getch();
    cout << "------------------------------------------------------------------------------" << endl;
    Descobrir_Coeficientes(a,b,c, repetir);
    }
}

void ClearScreen()
  {
  HANDLE                     hStdOut;
  CONSOLE_SCREEN_BUFFER_INFO csbi;
  DWORD                      count;
  DWORD                      cellCount;
  COORD                      homeCoords = { 0, 0 };

  hStdOut = GetStdHandle( STD_OUTPUT_HANDLE );
  if (hStdOut == INVALID_HANDLE_VALUE) return;

  /* Get the number of cells in the current buffer */
  if (!GetConsoleScreenBufferInfo( hStdOut, &csbi )) return;
  cellCount = csbi.dwSize.X *csbi.dwSize.Y;

  /* Fill the entire buffer with spaces */
  if (!FillConsoleOutputCharacter(
    hStdOut,
    (TCHAR) ' ',
    cellCount,
    homeCoords,
    &count
    )) return;

  /* Fill the entire buffer with the current colors and attributes */
  if (!FillConsoleOutputAttribute(
    hStdOut,
    csbi.wAttributes,
    cellCount,
    homeCoords,
    &count
    )) return;

  /* Move the cursor home */
  SetConsoleCursorPosition( hStdOut, homeCoords );
  }

float Descobrir_Coeficientes(float a, float b, float c, bool repetir)
{
    cin.sync();
    cout << "\nDigite o valor do coeficiente que acompanha x²:" << endl;
    cin >> a;
    cin.sync();
    if(!cin) // or if(cin.fail())
    {
    // user didn't input a number
    cin.clear(); // reset failbit
    cin.ignore(numeric_limits<streamsize>::max(), '\n'); //skip bad input
    // next, request user reinput
    cout << "O coeficiente precisa ser um número." << endl << endl;
    getch();
    ClearScreen();
    Descobrir_Coeficientes(a,b,c,repetir);
    }
    if (a == 0)
    {
        cout << "\nEsse coeficiente não pode ser nulo. Digite novamente." << endl;
        Descobrir_Coeficientes(a,b,c,repetir);
    }
    else
    {
    cin.sync();
    cout << "\nDigite o valor do coeficiente que acompanha x" << endl;
    cin >> b;
    if(!cin) // or if(cin.fail())
    {
    // user didn't input a number
    cin.clear(); // reset failbit
    cin.ignore(numeric_limits<streamsize>::max(), '\n'); //skip bad input
    // next, request user reinput
    cout << "\n\nO coeficiente precisa ser um número." << endl << endl;
    getch();
    ClearScreen();
    Descobrir_Coeficientes(a,b,c,repetir);
    }
    }
    cin.sync();
    cout << "\nDigite o valor do coeficiente do termo independente" << endl;
    cin >> c;
    if(!cin) // or if(cin.fail())
    {
    // user didn't input a number
    cin.clear(); // reset failbit
    cin.ignore(numeric_limits<streamsize>::max(), '\n'); //skip bad input
    // next, request user reinput
    cout << "\n\nO coeficiente precisa ser um número." << endl << endl;
    getch();
    ClearScreen();
    Descobrir_Coeficientes(a,b,c,repetir);
    }
    cin.sync();
    i++;
    Calcular_Raizes(a,b,c);
     return 0;
    }

float Calcular_Raizes(float a, float b,float c)
{
    double x_1 = 0; double x_2 = 0;
    Delta = pow(b,2) - 4*a*c;
    if (Delta < 0)
    {
        Mostrar_Raizes_Complexas(a,b,c);
    }
    else
    {
        x_1 = (-b + sqrt(Delta))/(2*a);
        x_2 = (-b - sqrt(Delta))/(2*a);

    x1 = x_1; x2 = x_2;

    Mostrar_Raizes(x1,x2);
    }
    return 0;
}

float Mostrar_Raizes(float x1, float x2)
{
    cout << "\nAs raízes da equação dada são " << x1 << " e " << x2 << endl;
    cout << "\nPressione qualquer tecla para continuar." << endl;
    getch();
    cout << "------------------------------------------------------------------------------" << endl;
    cin.sync();
    Repetir(repetir);
    return 0;
}

float Mostrar_Raizes_Complexas(float a,float b, float c)
{
    float Parte_Real = -b/(2*a);
    float Delta_Imaginario = abs(pow(b,2) - 4*a*c);
    float Imaginario = (sqrt(Delta_Imaginario))/(2*a);
    complex<float> x1C(Parte_Real,Imaginario) ;
    complex<float> x2C(Parte_Real,-Imaginario);

    cout << "\nAs raízes da equação dada são " << real(x1C) << "+" <<  imag(x1C) << "i" << " e " << real(x2C) <<  imag(x2C) << "i"<< endl;
    cout << "\nPressione qualquer tecla para continuar." << endl;
    getch();
    cout << "------------------------------------------------------------------------------" << endl;
    cin.sync();
    Repetir(repetir);
    return 0;
}

bool Repetir (bool repetir)
{
    cout << "\n\nDeseja usar o programa novamente?(1/2)" << endl;
    cin >> Sim_ou_Nao;
    cin.sync();
    if (Sim_ou_Nao == 1)
    {
        repetir = true;
        cin.sync();
        ClearScreen();
        Instrucoes(repetir);
    }
    else if ( Sim_ou_Nao == 2)
    {
     cout << "\nAdeus!" << endl;
    }
    else if(!cin) // or if(cin.fail())
    {
    // user didn't input a number
    cin.clear(); // reset failbit
    cin.ignore(numeric_limits<streamsize>::max(), '\n'); //skip bad input
    // next, request user reinput
        cout << "\nOpção inválida." << endl << endl;
        Repetir(repetir);
    }
    return 0;
}

int main()
{
    SetConsoleTitle("Resolvedor de Equacoes do Segundo Grau");
    setlocale(LC_ALL, "Portuguese");
    Instrucoes(repetir);
    return 0;
}

Grato pela atenção.

Att.,

Pedro

[Inserir dados em arquivo]

Se eu não me engano, para escrever no arquivo usando .write, o arquivo deve ser aberto como binário.

Att.,

Pedro

[Problemas com cout]

Ok. Se der certo me avise. Fiquei curioso. E caso esteja alocando memória dinamicamente, lembre-se de deletar a mesma depois usando o comando delete . Você chegou a testar a última opção?

Att.,

Pedro

[Problemas com cout]

Tente fazer o seguinte então. Troque o cout pelo printf que é mais rápido. Depois, tente comentar o printf e vê se funciona. Mesmo que não funcione, você ainda ganhara tempo pois o printf é mais rápido. Caso não seja o bastante, faça o seguinte:

Crie um arquivo qualquer e sempre que você tiver que usar o cout, em vez de usá-lo, passe as informações que você usaria nele para o arquivo. É bem mais rápido.

É claro que caso você realmente precise mostrar algo na tela, essa opção não servirá, no entanto, se você apenas estiver usando o cout para conferir os resultados, essa opção é perfeita.

Att.,

Pedro

[Problemas com cout]

Diogo, penso que seja algo relacionado ao mesmo erro da primeira vez. No entanto, como o erro só acontece quando você comenta os cout's, não me importaria muito. No entanto, caso você queira ir um pouco além, pode usar um debugger ou alguma ferramenta como o Valgrind, para procurar bugs no seu programa.

Att.,

Pedro

[Problemas com cout]

Diogo, quando eu rodo o programa aparecem vários resultados. Vou postar uma imagem aqui, por favor me diga se são os mesmos resultados que você obtem.

Att.,

Pedro

[Pra que servem prototipos?]

É sempre essencial declarar os protótipos das funções.

E como assim o c++ saber com o que eu estou falando?

Exatamente. Serve para que o compilador se prepare e reserve os itens necessários para a criação da função e para que possa achar a mesma sem que ele tenha visto a declaração da função por exemplo. Não vou entrar em detalhes até porque não sei a razão do compilador procurar o protótipo e não a função, mas é basicamente isso.

Segue um link com uma explicação um pouco melhor.

PROTÓTIPOS

Att.,

Pedro

[Procuro um Programador]

Você tem alguma especificação sobre o que o programador deve saber?

[Pra que servem prototipos?]

Você deve criar os dois principalmente porque caso você tenha declarado as funções antes de main, o que é mais comum, os protótipos são a forma do compilador saber do que você está falando quando você chama uma função.

Att.,

Pedro

[Problemas com cout]

Diogo, você conseguiu chegar ao valor 466.13 alguma vez? Porque o maior valor que eu cheguei usando o programa foi 511.438 (usando o cin.sync() antes de cada cout).

Att.,

Pedro

¹ Desculpe a demora em responder, não estava em casa.

² Só uma dúvida. Olhando o seu código, acho que ele foi feito em C++ certo? Se sim, qual é o motivo de você usar o modo antigo de abertura de arquivos ( C ) ao invés de usar o modo novo (C++)?

[Problema com cout]

Sim. Eu sempre uso o cin.sync() em sequências de cin, ou coisa parecida.

Abraço.

Att.,

Pedro

[Problema com cout]

Maneiro Diogo. Meu irmão está no 3º ano da faculdade de Engenharia Elétrica e está sofrendo bastante, :P.

Qualquer coisa estou aqui, :D

Att.,

Pedro

[Problema com cout]

Consegui resolver o problema colocando um cin.sync() - comando semelhante ao fflush(), que limpa o buffer e sincroniza o cin - após a linha 162. Meu palpite é que alguma das operações que você fez deixou algo no buffer e por isso os resultados estavam vindo diferentes. E acho que o motivo de o resultado certo aparecer quando você 'descomentava' a linha era que ao usar o cout em conjunto com o endl você limpava o buffer de alguma maneira.

Att.,

Pedro

¹ O código é sobre alguma coisa relacionada à Física? Vi coisas como valor de resistência e achei muito interessante, :D.

[Problema com cout]

Penso que não, mas se quiser faça o upload do arquivo para o 4shared por exemplo e eu baixo de lá e testo.

Att.,

Pedro

[Problema com cout]

Estou procurando. Tenho quase certeza que é nas opções do compilador e debugger. Poderia postar a parte do seu código que dá o erro para eu poder testar aqui em casa?

Att.,

Pedro

¹Diogo, como você pode ver na foto que vou postar em anexo nesse post, quando eu tentei compilar o um programa que acessava um índice além do limite, usando a flag -fcheck=bounds (que é a versão atual do comando que você postou), deu um erro. Veja a foto:

O erro fala que esse comando é válido para Fortran, mas não é válido para C++. Então minha sugestão é que você poste seu código aqui para que possemos lhe ajudar.

Att.,

Pedro

[ajuda com switch na calculadora]

Por padrão retorna, no entanto é de bom costume declarar como int main() (caso queira que sua função main aceite parâmetros) ou int main(void) caso contrário.

Att.,

Pedro

¹ E no caso, main() sempre retorna um inteiro porque o compilador tem como default para valores de retorno, uma integer e como nessa caso main não tem um tipo definido, ele retorna uma integer.