cyer

Antigamente era sim isso, hoje em dia esse pode se dizer que esse conceito mudou, C++ está praticamente superior(ou quase) que o C(no quesito de recursos, funções e projetos), ainda perde um pouco no desempenho em comparação a linguagem C, mas não é grande coisa, tanto que aplicativos que precisam do máximo desempenho possível, como jogos, a maioria hoje em dia é feita em C++. Um bom programador tem sempre que se manter atualizado para o mercado de trabalho. Se você aprende a programar em C++ você aprende a programar em qualquer linguagem Orientada a objetos(Java, C# e varias outras).

No if se você usar o operador = significa que você está igualando uma variável em vez de comparar, para comparar são ==. E depois do = você tinha que usar " " pois é uma string(pelo menos era pra ser) #include <iostream> // std::cout, std::cin #include <string> // std::string using namespace std; int main() { string oper; int x = 0, y = 0; cout << "Digite um valor para x: "; cin >> x; cout << "Digite um valor para y: "; cin >> y; cout << "Se voce for somar digite som, se for subtrair digite sub, se for dividir, digite div, se for multipicar digite mult: "; cin >> oper; if (oper == "som") cout << x + y; else if (oper == "sub") cout << x - y; else if (oper == "mult") cout << x * y; else if (oper == "div") cout << x / y; // cuidado para não passar 0 no y, se você passar 0 no y vai ocasionar problemas por tentar fazer uma divisão por zero. system("pause"); return 0; }

#include <iostream> // std::cout, std::cin #include <string> // std::string, std::to_string, std::stoi int main() { int num = 0; std::cout << "Insira um numero inteiro: "; std::cin >> num; std::string numStr = std::to_string(num), numInvertedStr; for (size_t i = numStr.size(); i--;) numInvertedStr.push_back(numStr[i]); std::cout << "Numero: " << std::stoi(numInvertedStr) << std::endl; system("pause"); return 0; } Saída primeiro teste: Saída segundo teste: Saída terceiro teste:

Como assim não está rodando? Poderia postar algo para identificar onde está o erro? Aqui rodou sem problema algum. Tente esse código: #include <stdio.h> #include <Windows.h> int main() { float alturachico = 1.50f, alturaze = 1.10f; float crescimentoanualchico = 0.2f, crescimentoanualze = 0.3f; int qntAnos = 0; // Verifica se o Chico é maior que o Zé bool Pessoa1MaiorQuePessoa2 = (alturachico > alturaze) ? true : false; while (Pessoa1MaiorQuePessoa2 ? alturaze < alturachico : alturachico < alturaze) { qntAnos++; alturachico += crescimentoanualchico; alturaze += crescimentoanualze; } if (qntAnos > 100 || qntAnos == 0) { printf("Nao eh possivel %s ser maior que %s.\n", Pessoa1MaiorQuePessoa2 ? "Ze" : "Chico", Pessoa1MaiorQuePessoa2 ? "Chico" : "Ze"); return 0; } printf("%s vai ser maior que a %s em %d anos.\n", Pessoa1MaiorQuePessoa2 ? "Ze" : "Chico", Pessoa1MaiorQuePessoa2 ? "Chico" : "Ze", qntAnos); system("pause"); return 0; }

@Marcela da Silva de Souza exatamente, e atribuir os valores. Apenas remova a linha abaixo que vai compilar: setlocale(NULL, "Portuguese");

Da linguagem C não podem retirar, mas da linguagem C++ podem retirar o goto, inclusive já fizeram algo parecido na nova versão do C++ Moderno chamada de "C++ 11", na versão mais recente do C++(C++ 17), retiraram a keyword register, é provável que nas próximas versões do C++ moderno retire algumas "keywords" que são inúteis nos dias de hoje da mesma forma que o register é. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4340 https://stackoverflow.com/questions/20618008/replacement-for-deprecated-register-keyword-c-11

#include <stdio.h> #include <locale> int main() { setlocale(NULL, "Portuguese"); float alturaPessoa1 = 0.f, alturaPessoa2 = 0.f; float crescimentoAnualPessoa1 = 0.f, crescimentoAnualPessoa2; printf("Informe a altura da primeira pessoa: "); scanf("%f", &alturaPessoa1); printf("Informe o crescimento anual da primeira pessoa: "); scanf("%f", &crescimentoAnualPessoa1); printf("Informe a altura da segunda pessoa: "); scanf("%f", &alturaPessoa2); printf("Informe o crescimento anual da segunda pessoa: "); scanf("%f", &crescimentoAnualPessoa2); int qntAnos = 0; // Verifica se a pessoa 1 é maior que pessoa 2 bool Pessoa1MaiorQuePessoa2 = (alturaPessoa1 > alturaPessoa2) ? true : false; while (Pessoa1MaiorQuePessoa2 ? alturaPessoa2 < alturaPessoa1 : alturaPessoa1 < alturaPessoa2) { qntAnos++; alturaPessoa1 += crescimentoAnualPessoa1; alturaPessoa2 += crescimentoAnualPessoa2; } if (qntAnos > 100 || qntAnos == 0) { printf("Não é possível a pessoa %d ser maior que a pessoa %d.\n", Pessoa1MaiorQuePessoa2 ? 2 : 1, Pessoa1MaiorQuePessoa2 ? 1 : 2); return 0; } printf("A pessoa %d vai ser maior que a pessoa %d em %d anos.\n", Pessoa1MaiorQuePessoa2 ? 2 : 1, Pessoa1MaiorQuePessoa2 ? 1 : 2, qntAnos); system("pause"); return 0; } Saída: PS: Usei 0.2 e 0.3 em vez de 2 e 3 porque o crescimento anual é em cm. Para poder usar como 2 e 3, basta multiplicar por 0.1: alturaPessoa1 += crescimentoAnualPessoa1 * 0.1f; alturaPessoa2 += crescimentoAnualPessoa2 * 0.1f;

Poderia informar o que a questão pede?

Você pode fazer o limite da entrada usando a função fgets, mas não é o método ideal para isso(não vou deixar um exemplo disso, mas se você quiser, eu posto um exemplo). O método correto para esse seu tipo de aplicação seria, limpar os dígitos que ultrapassa o valor máximo. Para fazer isso, você teria que pegar a quantidade de dígitos inserido pelo usuário, para fazer isso de forma simples, você pode usar a classe to_string e usar o método length. Depois você transforma para uma string e remove os caracteres que ultrapassa o limite e converte novamente para um inteiro(usando a função stoi). O exemplo abaixo faz exatamente o que você quer, no caso usei para 3 o limite máximo de digitos. #include <iostream> // std::cout, std::cin #include <string> // std::to_string, std::stoi #define MAX_NUM 3 int main() { int numero = 0; std::cout << "Insira um numero(ate 3 digitos): "; std::cin >> numero; // Pega a quantidade de números que o inteiro possui usando a classe to_string e armazena no na variável a quantidade int qntDigitos = std::to_string(numero).length(); // Verifica se a quantidade números é maior que o limite permitido(definido na constante MAX_NUM) if (qntDigitos > MAX_NUM) { // Converte o inteiro para string std::string novonum_str = std::to_string(numero); // Troca os caracteres dos números que ultrapassam o limite(definido na constante MAX_NUM) pelo caractere que representa o fim de uma string(caractere nulo) for (size_t i = MAX_NUM; i < novonum_str.length(); i++) novonum_str[i] = '\0'; // Converte a string para inteiro int novonum_int = std::stoi(novonum_str); // Mostra na saída o número corrigido std::cout << "Numero corrigido: " << novonum_int << std::endl; } return 0; } Saída do primeiro teste: Saída do segundo teste: Saída do terceiro teste: Duas sugestões: 1 - Para esse tipo de aplicação, use como string para ficar mais simples o seu código, como inteiro, se o usuário digitar um número grande, tipo, 123456789101234, vai ocasionar problemas, e um inteiro não pode receber 16 dígitos. 2 - Se você está programando em C++ use funções e recursos da linguagem C++, evite ao máximo usar funções e recursos da linguagem C.

O maior problema em usar goto, nem sempre é os erros, mas sim porque quebra completamente a lógica do código

Escrevi um exemplo simples, testei no Visual Studio e gerou esse erro por conta do "goto" e da inicialização da variável depois do goto. Esse é um exemplo que me lembro, no momento só lembro desse, mas tem vários outros problemas que são gerados pelo goto. #include <iostream> // std::cout #include <Windows.h> // OpenProcess int main() { HANDLE Processo = OpenProcess(PROCESS_ALL_ACCESS, false, 0x10); if (Processo == NULL) { std::cout << "Falha ao abrir o processo.\n"; goto final; } int erro = 0; // Essa declaração apos o goto vai ser onde vai gerar o erro na compilação, por conta de inicializar a variável apos um goto final: if (Processo) CloseHandle(Processo); std::cout << "Saindo.\n"; return EXIT_SUCCESS; }

@Alexandre Caribé não é só porque quebra a lógica do código, goto em vários casos gera alguns problemas na hora da compilação. Existe a função isalpha, você pode simplesmente fazer um for e verificar caractere por caractere com a função isalpha. #include <iostream> // std::cout, std::cin #include <iomanip> // std::boolapha #include <string> // std::string #include <cctype> // isalpha bool PossuiLetra(std::string Entrada) { for (size_t i = 0; i < Entrada.size(); i++) { if (isalpha(Entrada[i])) return true; } return false; } int main() { std::string Teste1 = "123456789A"; std::string Teste2 = "123456789"; std::string Teste3 = "----..."; std::cout << "Possui letra? " << std::boolalpha << PossuiLetra(Teste1) << std::endl; std::cout << "Possui letra? " << std::boolalpha << PossuiLetra(Teste2) << std::endl; std::cout << "Possui letra? " << std::boolalpha << PossuiLetra(Teste3) << std::endl; std::cin.clear(); std::cin.get(); return 0; } Saída: Para limitar os dígitos você pode verificar a quantidade de digitos, se for maior que 16 você limpa os outros. Exemplo: #include <iostream> #include <string> int main() { std::string entrada; std::cin >> entrada; if (entrada.size() > 16) { std::cout << "Entrada maior que 16.\n"; for (size_t i = 16; i < entrada.size(); i++) entrada[i] = '\0'; } std::cout << entrada << std::endl; return 0; } Entrada: Saída:

Apenas use string em vez da string da linguagem C, se você está programando em C++, deve evitar ao máximo o uso de de recursos e funções da linguagem C. #include <iostream> #include <string> #include <locale.h> int main() { setlocale(LC_ALL, "Portuguese"); std::string capital; std::cout << "Digite qual é a capital do Brasil: "; std::cin >> capital; if (capital == "Brasília") std::cout << "PARABÉNS" << std::endl; else std::cout << "**INCORRETO**\n\n O digitado foi " << capital << " e o correto é Brasília\n"; }

@giu_d pode sim comparar strings com o operador ==, dentro da classe string o operador == possui uma função de sobrecarga no operador == que retorna para a função compare, em outras palavras, não possui diferença usar a função compare ou o operador ==. Isso não se aplica para strings da linguagem C(comparação entre dois char* ou dois const char*). Basicamente seria isso: bool operator==(const char* str) { return (this->compare(str) == 0); } Fonte: https://stackoverflow.com/questions/9158894/differences-between-c-string-and-compare

Ambos estão certo, isso é questão de gosto, o que está errado é o código ficar completamente desalinhado dificultando a legibilidade do código, ambos estão certo, é só questão de gosto. Eu prefiro o segundo, mas tem gente que prefere o primeiro, outros tipos de pessoas preferem dar um espaço em cada expressão pois dizem que o código fica mais "elegante", enfim, isso é apenas questão de gosto, use da forma que você gosta. Respondendo a segunda pergunta: Ao meu ver a segunda é mais fácil, pois os compiladores mais moderno da atualidade como o Visual Studio, sempre que você insere um {, ele automaticamente muda o código para ficar da segunda forma. Exemplo: Quando você insere um código dessa forma no Visual Studio: int main() { } Ele muda automaticamente para essa forma apos você da enter: int main() { } Então recomendo que siga a segunda estrutura para ir se adaptando. Apenas tenha em mente, que um posicionamento de chaves, colchetes e etc não vai ser isso que vai deixar seu código errado ou sujo, você só não pode deixar as chaves toda desorganizadas e desalinhadas pois atrapalha a legibilidade do seu código.

Primeiro apenas verifique se a pasta está vazia, se não estiver, você deleta. #include <stdio.h> #include <windows.h> bool PastaVazia(const char* Caminho) { WIN32_FIND_DATA pastaInfo = { 0 }; HANDLE Pasta = FindFirstFileA(Caminho, &pastaInfo); if (Pasta == INVALID_HANDLE_VALUE) return false; do { // Verifica se o nome alternativo do arquivo é diferente de 0, se for igual a 0 significa que não existe if (pastaInfo.cAlternateFileName && pastaInfo.cAlternateFileName[0]) { FindClose(Pasta); return false; } } while (FindNextFileA(Pasta, &pastaInfo)); FindClose(Pasta); return true; } bool ApagarTodosArquivos(const char* Caminho) { WIN32_FIND_DATA pastaInfo = { 0 }; HANDLE Pasta = FindFirstFileA(Caminho, &pastaInfo); if (Pasta == INVALID_HANDLE_VALUE) return false; // Remove o *.* do caminho char CaminhoSemTipo[MAX_PATH] = { 0 }; for (size_t i = strlen(Caminho) - 1; i--; ) { if (Caminho[i] == '\\') { strncpy_s(CaminhoSemTipo, Caminho, i + 1); break; } } do { // Verifica se é a pasta atual if (pastaInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) continue; char d[MAX_PATH] = { 0 }; // Copia o caminho sem o *.* para a d strcpy_s(d, CaminhoSemTipo); // Adiciona o nome do arquivo para o diretorio strcat_s(d, pastaInfo.cFileName); // Apaga o arquivo if (!DeleteFileA(d)) { FindClose(Pasta); return false; } } while (FindNextFileA(Pasta, &pastaInfo)); FindClose(Pasta); return true; } int main() { bool Resultado = PastaVazia("C:\\Teste\\*.*"); printf("Vazia: %i\n", Resultado); // *.* para checar todos os tipos de arquivos da pasta se existir arquivos nela if (!Resultado) ApagarTodosArquivos("C:\\Teste\\*.*"); system("pause"); return 0; }

@Gnomo Psicodélico apenas pastas vazias?

A função system não mostra a janela do cmd, e também não é a melhor opção para isso, você pode usar funções da própria linguagem C para fazer isso como a função RemoveDirectory(para pastas) e a função remove(para arquivos) ou a função DeleteFile.

@Gnomo Psicodélico por que você simplesmente não usa a função system para executar os comandos do .bat em vez de criar um arquivo .bat? system("shutdown -r -t 30"); // Apenas coloque o comando do .bat dentro das " "

Faça o que @devair1010 disse, apenas cheque se o valor retornado pelo fopen é igual a NULL(0) FILE* arquivo = fopen("meuarquivo.txt", "r"); if (arquivo == NULL) printf("Erro ao abrir o arquivo, %d\n", GetLastError()); // Mostra a mensagem de erro e o código do erro

FILE* f[100] = { 0 }; Para inicializar o vetor vai ter que usar um for ou passar a posição do vetor: for (int i = 0; i < 100; i++) { f[i] = fopen(...); } Passando o indice: f[10] = fopen(...); f[50] = fopen(...);

Está aparecendo essas mensagens porque você está passando uma valor do tipo double para um argumento que é do tipo inteiro(int), para resolver esse problema, você tem 2 opções: fazer uma conversão de tipo(cast) de double para int ou desativar o warning especifico. Primeira opção(Usando Casts): LineTo (tela, static_cast<int>(k) , static_cast<int>(w) ) ;//vai para essa posição LineTo (tela, static_cast<int>(x2), static_cast<int>(y2) ) ; LineTo (tela, static_cast<int>(k2), static_cast<int>(w2) ) ; LineTo (tela, static_cast<int>(x3), static_cast<int>(y3) ) ; LineTo (tela, static_cast<int>(k3), static_cast<int>(w3) ) ; LineTo (tela, static_cast<int>(x4), static_cast<int>(y4) ) ; LineTo (tela, static_cast<int>(k4), static_cast<int>(w4) ) ; LineTo (tela, static_cast<int>(x5), static_cast<int>(y5) ) ; LineTo (tela, static_cast<int>(k5), static_cast<int>(w5) ) ; LineTo (tela, static_cast<int>(x), static_cast<int>(y) ) ; Segunda opção(Desativando o warning do compilador): Visual Studio: #include <windows.h> #include <math.h> #include <conio.h> #pragma warning(disable: 4244) // 4244 é código do warning: warning C4244: 'argument': conversion from 'double' to 'int', possible loss of data // Restante do código... Não lembro como desativar para GCC, pois não uso GCC, mas que eu me lembre seria algo assim: #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wuninitialized" // Função que deseja desabilitar os warnings aqui, no caso vai desabilitar o warning para variáveis não inicializadas #pragma GCC diagnostic pop Sobre as linhas sumir, tenho 2 coisas em mentes: 1 - A linha ainda não foi calculada para o frame atual(i++ só vai incrementar no próximo frame), essa opção é a que eu acho mais provável. 2 - Talvez alguma lentidão no código, geralmente algorítimos de desenhos que envolve bastante cálculos assim, são extremamente lentos, visto que a GDI é extremamente lenta também tanto que os jogos preferem usar OpenGL, DirectX e outras interfaces gráficas por serem muito mais rápido que GDI, juntando com funções de cálculo da math.h(sin, cos, ...) fica mais lento ainda, e pra piorar você ainda colocou um Sleep dentro. Para detectar se a tecla esc foi pressionada você tem que verificar dentro da WM_KEYDOWN: LRESULT CALLBACK WndProc (HWND janela, UINT message, WPARAM wParam, LPARAM lParam){ HDC tela ; COLORREF color; PAINTSTRUCT ps ; int z=0; double x,y,x2,y2,x3,y3,x4,y4,x5,y5; double k,w,k2,w2,k3,w3,k4,w4,k5,w5; tela = GetDC (janela) ; switch (message){ case WM_KEYDOWN: if (wParam == VK_ESCAPE) // Verifica se a tecla que foi pressionada é a tecla ESC(VK_ESCAPE) { // Tecla ESC pressionada o que deseja fazer? } return 0; case WM_PAINT : tela = BeginPaint (janela, &ps) ; x =cos( i *3.141615/180)*200+300; y =sin( i *3.141615/180)*200+250; x2=cos((i+72 )*3.141615/180)*200+300; y2=sin((i+72 )*3.141615/180)*200+250; x3=cos((i+144)*3.141615/180)*200+300; y3=sin((i+144)*3.141615/180)*200+250; x4=cos((i+216)*3.141615/180)*200+300; y4=sin((i+216)*3.141615/180)*200+250; x5=cos((i+288)*3.141615/180)*200+300; y5=sin((i+288)*3.141615/180)*200+250; k =cos( i+36 *3.141615/180)*100+300; w =sin( i+36 *3.141615/180)*100+250; k2=cos((i+108)*3.141615/180)*100+300; w2=sin((i+108)*3.141615/180)*100+250; k3=cos((i+180)*3.141615/180)*100+300; w3=sin((i+180)*3.141615/180)*100+250; k4=cos((i+252)*3.141615/180)*100+300; w4=sin((i+252)*3.141615/180)*100+250; k5=cos((i+324)*3.141615/180)*100+300; w5=sin((i+324)*3.141615/180)*100+250; i++; MoveToEx(tela,x ,y,0) ;//posição de inicio LineTo (tela, static_cast<int>(k) , static_cast<int>(w) ) ;//vai para essa posição LineTo (tela, static_cast<int>(x2), static_cast<int>(y2) ) ; LineTo (tela, static_cast<int>(k2), static_cast<int>(w2) ) ; LineTo (tela, static_cast<int>(x3), static_cast<int>(y3) ) ; LineTo (tela, static_cast<int>(k3), static_cast<int>(w3) ) ; LineTo (tela, static_cast<int>(x4), static_cast<int>(y4) ) ; LineTo (tela, static_cast<int>(k4), static_cast<int>(w4) ) ; LineTo (tela, static_cast<int>(x5), static_cast<int>(y5) ) ; LineTo (tela, static_cast<int>(k5), static_cast<int>(w5) ) ; LineTo (tela, static_cast<int>(x), static_cast<int>(y) ) ; if(i>360)i=0; Sleep(500); InvalidateRect (janela, NULL, TRUE) ;//limpa a tela EndPaint (janela, &ps) ; return 0; case WM_DESTROY: PostQuitMessage (0) ; return 0 ; } return DefWindowProc (janela, message, wParam, lParam) ; }

Troque a linha: scanf ("&d", &resp); por essa linha: scanf ("%d", &resp);

Como você possui os minutos, você pode usar a famosa regra de 3 para calcular isso: PS: Desculpe pelo o erro de digitação, na linha "Fazendo um regra de 3" era pra ser "Fazendo uma regra de 3" #include <stdio.h> int main() { int min, horas, minutos,segundos; printf("Insira a quantidade de minutos: "); scanf("%d", &min); horas = min / 60; minutos = min % 60; segundos = min * 60; printf("Isso e igual a %dh, %dmin e %ds", horas, minutos, segundos); }

@Davi Silva Santos o problema em deixar os votos em um arquivo é que você vai perder em questão de segurança(por exemplo, se alguém quiser saber em quem cada pessoa votou, vai conseguir saber isso com uma facilidade extrema). Estou falando isso pois o voto tem que ser secreto(a não ser que esse programa seja apenas um exercício, mas se realmente for um programa para eleições, você deve levar em consideração isso). O ideal seria criar um banco de dados onde vai ficar armazenado os votos e usar uma biblioteca por fora para se comunicar com o banco de dados.