cyer

@Mauro Britivaldo hoje em dia uso de funções inline é extremamente desnecessário, até porque o próprio compilador quando achar que é uma boa ideia deixar essa função como inline ele mesmo define ela como inline sem nem você colocar o inline, se o compilador achar que não compensa(não estou dizendo que nesse exemplo seu está errado ou algo do tipo) ele não deixa a função ser inlinearizada mesmo que você tenha colocado a inline(embora tenha como você forçar essa inlinearização usando a __forceinline em vez de inline), ele simplesmente ignora isso. Quando eu digo que é desnecessário é porque o custo de chamada de uma função é minimo, para o processador isso ai seria o mesmo de somar 1 + 0, para você ter uma ideia quando você faz uma chamada de função, o processador vai demorar menos de 1 milissegundo para chamar essa função. Nesse caso como é uma função extremamente pequena e simples o compilador automaticamente vai colocar o inline na frente embora você não consiga ver. A dica que eu do é que apenas deixe o compilador escolher se a função vai ser inline ou não pois é muito difícil um programador saber mais que o compilador quando é uma boa ideia uma função ser inlinearizada ou não. Nem mesmo na maioria das vezes um programador super experiente consegue saber mais que o compilador nesse quesito.

@Simon Viegas não tinha percebido esse erro, código com o erro corrigido: #include <stdio.h> #include <Windows.h> int maior(int v1, int v2, int v3) { return (v1 >= v2 && v1 > v3) ? v1 : (v2 > v1 && v2 > v3) ? v2 : v3; } int main() { int v1, v2, v3; printf("informe o valor das notas: \n"); scanf("%d", &v1); scanf("%d", &v2); scanf("%d", &v3); printf("%d\n", maior(v1, v2, v3)); system("pause"); return 0; } Saída primeiro teste: informe o valor das notas: 5 5 3 5 Pressione qualquer tecla para continuar. . . Saída segundo teste: informe o valor das notas: 5 7 7 7 Saída terceiro teste: informe o valor das notas: 7 8 9 9 Pressione qualquer tecla para continuar. . .

@Priscila Ramos apenas sugiro que use o seguinte código abaixo, com isso você não precisaria criar nada ou usar algum outro método. Não esqueça de colocar o nome do arquivo dentro das "\\" É necessário que o seu arquivo esteja na mesma pasta que o aplicativo. NÃO REMOVA AS \\. Exemplo: strcat(caminhoarquivo, "\\meuarquivo.txt"); int main(int argc, char* argv[]){ /* if(argc != 2){ std::cout << "Argumento invalido." << std::endl; return 0; } ler_dados(argv[1]); */ char caminhoarquivo[MAX_PATH] = { 0 }; GetCurrentDirectoryA(MAX_PATH, caminhoarquivo); // Apenas coloque o nome do seu arquivo e o tipo do seu aquivo na linha baixo dentro das "\\" // Exemplo: "\\meuarquivo.txt" strcat(caminhoarquivo, "\\"); // Não remova as \\ é necessario coloque o nome do arquivo e o tipo depois das \\ ler_dados(caminhoarquivo); std::cout << "\n== geração de colunas ==============\n" << std::endl; //criar os subproblemas std::vector<Subproblema*> Sub; for(auto i=0; i<N_ITENS; i++){ Subproblema* sub = new Subproblema(i); sub->setStreamOff(); Sub.push_back(sub); } //criar o mestre Mestre mestre; mestre.setStreamOff(); mestre.criar_colunas_artificiais(); //algoritmo de geração de colunas const double EPS = 1.0e-5; std::vector<double> custoSub(N_ITENS, 0.0); int novaColuna = 0; int iter = 0; do{ iter++; std::cout << "Iteracao " << iter << std::endl; mestre.solve(); std::cout << std::setprecision(10) << "mestre = " << mestre.getObjective() << std::endl; novaColuna = 0; for(auto i=0; i<N_ITENS; i++){ Sub[i]->update_objective(&mestre); Sub[i]->solve(); // std::cout << "status = " << Sub[i]->getStatus() << std::endl; custoSub[i] = std::min(Sub[i]->getObjective(), 0.0); // std::cout << std::setprecision(10) << "sub[" << i << "]= " << custoSub[i] << std::endl; } for(auto i=0; i<N_ITENS; i++){ if(custoSub[i] < -EPS){ mestre.adicionar_coluna(Sub[i]); novaColuna++; // std::cout << std::setprecision(10) << "sub[" << i << "]= " << custoSub[i] << std::endl; } } std::cout << std::endl; }while(novaColuna > 0); double gc = mestre.getObjective(); std::cout << std::setprecision(10) << "GC = " << gc << std::endl; for(auto i=0; i<N_ITENS; i++){ delete Sub[i]; } return 0; }

Uma sugestão, essa função maior poderia ser feita usando apenas uma linha com o uso de dois operadores ternários: int maior(int v1, int v2, int v3) { return (v1 > v2 && v1 > v3) ? v1 : (v2 > v1 && v2 > v3) ? v2 : v3; }

O problema nesse código está sendo porque você apenas está abrindo a aplicação sem passar nada no main, no seu caso, o argv precisa ser passado alguma informação antes de ser aberto, no caso você precisa passar o caminho do arquivo antes de abrir, poderia usar o cmd do Windows para isso ou terminal se você usar Linux, ou poderia criar uma outra aplicação que executaria o seu programa passando o caminho do arquivo usando a função system, existe varias formas de se fazer isso.

Essa função é um pouco complexa, pois não envolve apenas a linguagem C, envolve também um pouco da linguagem Assembly, pois ela vai modificar diretamente na memória da aplicação usando instruções assembly(0xE9 = Número do byte equivalente a instrução jmp em x86 Assembly, 0x90 = Número do byte equivalente a instrução nop em x86 Assembly). Basicamente o que essa função faz é modificar a memória da função que vai ser passada por argumento através do endereço(Primeiro argumento, src) para fazer um salto(0xE9 - jmp) para a o endereço de memória da nova função passada pelo segundo argumento(dst) e depois preenche os bytes que sobraram por 0x90(se sobrar obviamente). Esse 0x90 é apenas um nop(No operation, de uma forma traduzida bem simples, apenas não faz nada, seria apenas para preencher os bytes que sobraram para evitar bytes inválidos apos modificados). Está função é bastante usada para fazer cheaters(trapaças/hackers) para jogos online/offline, também é bastante utilizado por Anti Cheats/Anti Hacks(Programas usados por empresas de jogos onlines para bloquear o uso de trapaças em seus jogos onlines), extremamente usado por malwares(No caso um malware poderia usar para desviar uma função de algum antivirus, por exemplo, a função de escaneamente do antivírus poderia ser facilmente desviada para não detectar o malware), também é usado por programas legítimos como: Fraps, OBS Studio, Overlays(Steam, Origin), programas de gravação. Vou ter que fugir um pouco da linguagem C para explicar de uma forma mais clara como ela funciona(Obvio que não vou poder explicar tudo, pois é muita coisa isso você vai ter que pesquisar por conta própria). Considere a seguinte instrução Assembly da função Sleep(Localizada no endereço de memória da dll KERNEL32): Na imagem abaixo temos a função antes de ser desviada, ela apenas pula para a função Sleep da KERNELBASE.DLL Apos o uso da função DetourCreate(DetourCreate((BYTE*)Sleep, (BYTE*)meuSleep, 6)) vai ficar da seguinte forma: Ou seja, como você pode ver nas imagens, ele apenas modifica os bytes da função passada pelo argumento, para fazer um salto para o endereço de memória da sua função. Primeiro argumento: Endereço de memória da função que deseja desviar Segundo argumento: Nova função que vai ser trocando quando a função Sleep for chamada. Terceiro argumento: Número de bytes da função que vai ser modificado, o número de bytes na maioria das vezes muda dependendo da função e do sistema operacional. Vou deixar um código bem parecido com esse para caso você queira testar na pratica(Vai ficar bem melhor pra você entender do que eu apenas explicando, recomendo que compile e teste) O código foi modificado para ficar de forma mais clara, e com um pouco mais de segurança, ainda não está 100% seguro, mas está um pouco mais seguro. #include <stdio.h> #include <Windows.h> // Prototipo da função typedef VOID(WINAPI* __Sleep)(_In_ DWORD dwMilliseconds); // Instancia da função __Sleep SleepOriginal = NULL; void* Desvio(const void* Endereco, const void* NovaFuncao, const size_t Tamanho) { // Verificação se os argumentos foram passados são validos, se não for retorna 0 // É necessario que o tamanho(numero de bytes) seja maior ou igual 5 if (IsBadCodePtr((FARPROC)Endereco) || IsBadCodePtr((FARPROC)NovaFuncao) || Tamanho < 5) return NULL; DWORD ProtecaoAntiga = NULL; // Muda a proteção de memória para PAGE_EXECUTE_READWRITE, por padrão a proteção de memória é PAGE_EXECUTE_READ // Se for READ apenas, não é possível modificar, então por isso usamos a função VirtualProtect // Se retorna 0 é porque falhou ao modificar a proteção de memória para PAGE_EXECUTE_READWRITE // Então saimos da função retornando 0 se falhar, não podemos arriscar continuar sem ter certeza que é possível escrever na memória if (!VirtualProtect((void*)Endereco, Tamanho, PAGE_EXECUTE_READWRITE, &ProtecaoAntiga)) return NULL; // Aloca memória na aplicação para poder salvar os bytes que vamos sobreescrever nele // Funcionaria da mesma forma que o malloc, porém para fazer Desvio é melhor a VirtualAlloc pois algumas vezes a malloc falha // Esse + 5 é o tamanho de um jmp em x86 Assembly, jmp onde vai ser usado para ir para a função depois de executar os bytes que modificamos void* InstrucoesAntigas = VirtualAlloc(NULL, Tamanho + 5, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE); // Verificação se foi possível alocar memória para salvar as instruções antigas da função Sleep // Caso retorne TRUE, é porque não foi possível alocar memória para a função // Saimos da função se falhar retornando 0 if (IsBadCodePtr((FARPROC)InstrucoesAntigas)) return NULL; // Tenta copiar os bytes para o endereço de memória que foi alocado(InstrucoesAntigas) // Se retornar 0 é porque falhou, então saimos da função retornando 0 if (!memcpy(InstrucoesAntigas, Endereco, Tamanho)) return NULL; // Muda o byte da memória alocada + Tamanho para 0xE9 *(BYTE*)((DWORD_PTR)InstrucoesAntigas + Tamanho) = 0xE9; // jmp // Calcula o endereço de destino do jmp *(DWORD_PTR*)((DWORD_PTR)InstrucoesAntigas + Tamanho + 1) = ((DWORD_PTR)Endereco + Tamanho - (DWORD_PTR)InstrucoesAntigas) - 5; // Agora vamos modificar os bytes da função que queremos desviar *(BYTE*)((DWORD_PTR)Endereco + 0) = 0xE9; // jmp // Calcula o destino do jmp e depois coloca o endereço de destino no jmp da função que queremos desviar *(DWORD_PTR*)((DWORD_PTR)Endereco + 1) = ((DWORD_PTR)NovaFuncao - (DWORD_PTR)Endereco) - 5; // Preenche os bytes que sobraram com bytes que não fazem a diferença(nop) para evitar que sobre bytes, deixando a função invalida for (size_t i = 5; i < Tamanho; i++) *(BYTE*)((DWORD_PTR)Endereco + i) = 0x90; // Restaura para a proteção antiga de memória apos escrever os novos bytes VirtualProtect((void*)Endereco, Tamanho, ProtecaoAntiga, &ProtecaoAntiga); // Retorna o endereço de memória das instruções antigas return InstrucoesAntigas; } VOID WINAPI meuSleep(_In_ DWORD dwMilliseconds) { printf("A funcao Sleep foi chamada e foi desviada para essa funcao!\n"); Beep(150, 150); // Para dar um Beep sempre que ela for chamada // Chama a função do Sleep que foi salva naquela memória que alocamos para que o Sleep seja executado SleepOriginal(dwMilliseconds); // Poderia mudar o tempo(dwMiliseconds) para o tanto que eu quisesse ou poderia não fazer nada } int main() { // Instala o Desvio no endereço da função Sleep e salva na variável SleepOriginal a função antiga SleepOriginal = (__Sleep)Desvio(Sleep, meuSleep, 6); // Esse número pode mudar em alguns sistemas, por isso eu disse que o código está mal feito, mas tem como pegar esse número usando uma outra função while (true) { Sleep(150); // Chama a função Sleep } return 0; }

#include <iostream> // std::cout, std::cin, std::endl #include <string> // std::string #include <conio.h> // getchar int main() { // Como tipo double pois pode ser números grandes, como o número que o exercicio pede: 1.000.000 double numAdeptos = 0.0; std::string tipoClube; std::cout << "Informe quantos adeptos tem no seu clube: "; // Pega quantos adeptos tem no clube std::cin >> numAdeptos; // Verifica se os valores é grande(> 1000000) ou pequeno(< 10000) ou se não for nenhuma das 2 vai salvar o nome "Médio" if (numAdeptos > 1000000) tipoClube = "Grande"; else if (numAdeptos < 10000) tipoClube = "Pequeno"; else tipoClube = "Medio"; // Imprime o valor da variável tipoClube std::cout << "Tipo de clube: " << tipoClube << std::endl; getchar(); return 0; } Está de forma que o exercício pede.

@Fabio M. Nascimento fiz usando fgets em vez de gets/scanf para evitar que o usuário digite mas de 700 caracteres assim ficando da forma que o exercício pediu: "Crie um programa que deverá solicitar a digitação de um texto de até 700 caracteres". A função gets/scanf não é possível limitar isso, podendo ocorrer até estouros de memória se escrever uma palavra com caracteres maior que 700. Podendo ocasionar resultados imprevisíveis. #include <stdio.h> // printf #include <stdlib.h> // fgets, system #include <ctype.h> // tolower #include <conio.h> // getchar #define MAX_LETRAS 700 /// <summary> /// Verifica se o caractere passado no argumento c é uma vogal. /// </summary> /// </param name ="c"> /// Caractere que deseja verificar. /// </param> /// <returns> /// Retorna true se for uma vogal ou false caso contrário. /// </returns> bool ehVogal(char c) { c = tolower(c); // Uso de tolower para poder verificar com letras minúsculas já que a linguagem C é uma linguagem case sensitive return (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u'); // Retorna true se for igual a uma das seguintes vogais: a e i o u } /// <summary> /// Verifica se o caractere passado no argumento c é uma consonte. /// </summary> /// </param name ="c"> /// Caractere que deseja verificar. /// </param> /// <returns> /// Retorna true se for uma consoante ou false caso contrário. /// </returns> bool ehConsoante(char c) { c = tolower(c); // Uso de tolower para poder verificar com letras minusculas já que a linguagem C é uma linguagem case sensitive return (c >= 'a' && c <= 'z' && !ehVogal(c)); // Retorna true se for igual a alguma letra do alfabeto minúsculo e se não for uma vogal } int main() { char frase[MAX_LETRAS] = { 0 }, vogais[MAX_LETRAS] = { 0 }, consoantes[MAX_LETRAS] = { 0 }; int numVogais = 0, numConsoantes = 0; printf("Insira a frase: "); // Pega até 700 caracteres(MAX_LETRAS) ou até encontrar um \n fgets(frase, MAX_LETRAS, stdin); // Limpa a a tela system("cls"); // Verifica caractere por caractere do array frase se é uma vogal ou consoante for (int i = 0; frase[i] != 0; i++) { if (ehVogal(frase[i])) // Verifica se é uma vogal vogais[numVogais++] = frase[i]; // Adiciona para o array vogais e incrementa o número de vogais(numVogais) em + 1 else if (ehConsoante(frase[i])) // Verifica se é uma consoante consoantes[numConsoantes++] = frase[i]; // Adiciona para o array consoantes e incrementa o número de consoantes(numConsoantes) em + 1 } printf("Mostrando todas as vogais: "); // Mostra todas as vogais que foram salva no array vogais for (int i = 0; i < numVogais; i++) printf("%c ", vogais[i]); // Escreve o caractere atual na saida // Escreve uma nova linha na tela para dar uma organizada na saida printf("\n"); printf("Mostrando todas as consoantes: "); // Mostra todas as consoantes que foram salva no array consoantes for (int i = 0; i < numConsoantes; i++) printf("%c ", consoantes[i]); // Escreve o caractere atual na saida // Escreve uma nova linha na tela para dar uma organizada na saida printf("\n"); getchar(); return 0; }

int main() { int valor_inteiro = 0; inicio: cout << "Informe um valor inteiro: "; cin >> valor_inteiro; if (!cin.good()) { cout << "voce inseriu um valor nao inteiro.\n"; // Limpa a entrada do usuário cin.clear(); cin.ignore(INT_MAX, '\n'); // Espera 2.5 segundos para dar tempo do usuário ler a mensagem Sleep(2500); // Limpa a tela system("cls"); // Volta para o inicio goto inicio; } cin.get(); return EXIT_SUCCESS; }

#include <iostream> // std::cout, std::cin #include <Windows.h> // Sleep #include <string> // std::string #include <map> // std::map #include <list> // std::list #include <locale> // setlocale #include <algorithm> // std::find enum Dias { Segunda = 1, Terca, Quarta, Quinta, Sexta, sábado, Domingo }; std::map<std::string, bool> comodoEnergia; /// <summary> /// Pega o dia da semana conforme o valor passado no argumento da funcao /// </summary> /// <param name="dia"> /// Codigo do dia da semana, comecando do zero, para ver o codigo equivalente de cada dia olhe na enum "Dias" /// </param> /// <returns> /// Retorna o nome do dia da semana /// </returns> std::string pegarNomeDoDia(int dia) { switch (dia) { case Segunda: return "Segunda feira"; case Terca: return "Terça feira"; case Quarta: return "Quarta feira"; case Quinta: return "Quinta feira"; case Sexta: return "Sexta feira"; case sábado: return "Sábado"; case Domingo: return "Domingo"; default: return "Dia informado é invalido"; } } /// <summary> /// Verifica se o dia passado no argumento "idDia" existe na lista que foi passada no argumento "l" /// </summary> /// <param name="l"> /// Lista para verificar se existe /// </param> /// <param name="idDia"> /// Código do dia para verificar, para ver o código dos dias veja na enum "Dias" /// </param> /// <returns> /// Retorna true se já foi usado ou false caso nao foi usado ainda /// </returns> bool diaJaFoiUsado(std::list<int>& l, int idDia) { for (std::list<int>::iterator it = l.begin(); it != l.end(); ++it) { std::cout << "It: " << *it << std::endl; if (*it == idDia) return true; } return false; } /// <summary> /// Verifica se a lista "l" que foi passada no argumento possui todos os dias da semana /// </summary> /// <param name="l"> /// Lista para verificar se existe /// </param> /// <returns> /// Retorna true se a lista "l" possui todos os dias da semana ou false caso contrario /// </returns> bool todosOsDiasForamUsados(std::list<int>& l) { for (int dias = 1; dias <= 7; dias++) { std::list<int>::iterator existIterator = std::find(l.begin(), l.end(), dias); if (existIterator == l.end()) return false; } return true; } /// <summary> /// Verifica se o dia que foi passado pelo argumento "dia" do usuario é válido para evitar problemas no código /// </summary> /// <param name="dia"> /// Código do dia para verificar se é válido, veja o código do dia na enum "Dias" /// </param> /// <returns> /// Retorna true se o dia que foi passado pelo usuario é valido ou false caso contrario /// </returns> bool diaPassadoEhValido(int dia) { return (dia >= 1 && dia <= 7); } /// <summary> /// Mostra as informações do comodo atraves do nome /// </summary> /// <param name="nome"> /// Nome do comodo para mostrar as informações /// </param> void mostraComodo(std::string nome) { std::cout << "Comodo: " << nome << std::endl; std::cout << "Energia ligada: " << comodoEnergia[nome] << std::endl; } int main() { setlocale(LC_ALL, "Portuguese"); int dia = 0; std::list<int> diasUsados; while (true) { system("cls"); // Loop onde vai escrever os dias da semana na tela for (int i = 1; i <= 7; i++) std::cout << i << "." << pegarNomeDoDia(i) << std::endl; std::cout << "Informe o dia da semana: "; // Pega o dia std::cin >> dia; // Verifica se o dia que foi passado pelo usuario é valido if (!diaPassadoEhValido(dia)) { std::cout << "O dia que você informou não existe, retornando para o inicio." << std::endl; // Pausa de 2 segundos para o usuário ler antes de voltar para o inicio do loop Sleep(2000); // Quebra o loop atual, voltando para o inicio do loop continue; } // Verifica se todos os dias já foram usados, se for, reseta a lista if (todosOsDiasForamUsados(diasUsados)) { std::cout << "Todos os dias foram usados, resetando a lista de dias usados.\n"; diasUsados.clear(); } // Verifica se o dia foi usado, se nao foi usado, adiciona na lista e volta para o inicio do loop if (diaJaFoiUsado(diasUsados, dia)) { diasUsados.push_back(dia); continue; } switch (dia) { case Segunda: // Se o dia da semana for segunda desliga a energia do Jardim comodoEnergia["Jardim"] = false; comodoEnergia["Quarto 1"] = true; comodoEnergia["Quarto 2"] = true; comodoEnergia["Quarto 3"] = true; comodoEnergia["Quarto 4"] = true; comodoEnergia["Sala de visita"] = true; comodoEnergia["Cozinha"] = true; comodoEnergia["Banheiro"] = true; break; case Terca: // Se o dia da semana for terca desliga a energia da sala de visita comodoEnergia["Sala de visita"] = false; comodoEnergia["Quarto 1"] = true; comodoEnergia["Quarto 2"] = true; comodoEnergia["Quarto 3"] = true; comodoEnergia["Quarto 4"] = true; comodoEnergia["Jardim"] = true; comodoEnergia["Cozinha"] = true; comodoEnergia["Banheiro"] = true; break; case Quarta: // Se o dia da semana for quarta desliga a energia da sala da cozinha comodoEnergia["Cozinha"] = false; comodoEnergia["Quarto 1"] = true; comodoEnergia["Quarto 2"] = true; comodoEnergia["Quarto 3"] = true; comodoEnergia["Quarto 4"] = true; comodoEnergia["Sala de visita"] = true; comodoEnergia["Jardim"] = true; comodoEnergia["Banheiro"] = true; break; case Quinta: comodoEnergia["Banheiro"] = false; comodoEnergia["Quarto 1"] = true; comodoEnergia["Quarto 2"] = true; comodoEnergia["Quarto 3"] = true; comodoEnergia["Quarto 4"] = true; comodoEnergia["Sala de visita"] = true; comodoEnergia["Jardim"] = true; comodoEnergia["Cozinha"] = true; break; case Domingo: // Se o dia da semana for domingo desliga a energia de todos os quartos comodoEnergia["Quarto 1"] = false; comodoEnergia["Quarto 2"] = false; comodoEnergia["Quarto 3"] = false; comodoEnergia["Quarto 4"] = false; comodoEnergia["Jardim"] = true; comodoEnergia["Sala de visita"] = true; comodoEnergia["Cozinha"] = true; comodoEnergia["Banheiro"] = true; break; } // Mostra as informações de todos os comodos mostraComodo("Quarto 1"); mostraComodo("Quarto 2"); mostraComodo("Quarto 3"); mostraComodo("Quarto 4"); mostraComodo("Jardim"); mostraComodo("Sala de visita"); mostraComodo("Cozinha"); mostraComodo("Banheiro"); // Faz um pause 4.5 segundos para o usuário ler as informações Sleep(4500); } return 0; } Já tinha feito algo parecido, apenas mudei algumas coisas. Não sei se é em C++ que você quer, talvez até seja pelo fato de muita gente usar funções do C mesmo em C++. Sei que o código tá um pouco complexo para quem é iniciante, então qualquer duvida diga a onde que eu respondo.

Você pode usar a função good, um pequeno exemplo: int main() { int valor_inteiro = 0; cout << "Informe um valor inteiro: "; cin >> valor_inteiro; if (!cin.good()) cout << "voce inseriu um valor nao inteiro."; return 0; }

Hoje em dia não é mais preciso isso, se você estiver usando a classe string, mesmo que seja um char* você pode usar o operador == ou != sem problema algum, a classe string possui uma função de sobrecarga de operadores para os operadores ==, != e vários outros como o + por exemplo, são varias sobrecargas, tanto para string como para char*/const char*. Agora se for uma comparação entre char* e char* você vai ter que usar a função da linguagem C: strcmp. @GiovanniDosSantosReale está acontecendo esse problema porque você está incrementando o c em + 1, com isso a condição que você está fazendo dentro do while não vai funcionar pois o próximo nome ainda não foi inserido, você precisa comparar dentro do while se o nome inserido é igual a fim. int main() { string nome[15]; float nota[15], media = 0; int c = 0; cout<<"Digite um nome, caso não haja nenhum, digite fim: "; cin>>nome[c]; cout<<"Digite a nota do aluno: "; cin>>nota[c]; c++ while (nome[c] != "fim" && c < 3) { cout<<"Digite um nome, casO não Haja nenhum, digite fim: "; cin>>nome[c]; // Se o nome inserido for igual a fim quebra o loop if (nome[c] == "fim") break; cout<<"Digite a nota do aluno: "; cin>>nota[c]; media = media + nota[c]; c++; } media = media/3; //E esse for simplesmente não entra for(int d = 0; d == c; d++) { cout<<"teste"; if(nota[d] < 7) { cout<<nome[d]<<" não passo, ele eh um bostinha :3 sua nota foi de: "<<nota[d]; } else { cout<<nome[d]<<"\n passooooo, ele eh fodaum, com sua nota de: "<<nota[d]; } } cout<<"\nA media foi de :"<<media; } Uma sugestão: se quer que o código seja executado pelo menos uma vez, utilize "do while" em vez do "while".

Você devia dar mais informações, alguns dados, com essa pouca de informação fica bem complicado mesmo

Isso vai ser um pouco complexo. a) Você precisa verificar se existe pessoas no jardim, se existir, você pode usar um pouco de matématica para fazer isso, por exemplo, você pode definir uma posição em duas dimensões para o sistema de irrigação e distância que você considere perto da irrigação do Jardim. Exemplo(Considere em coordenadas 2D, x e y): Posição da irrigação do jardim: (201, 200) Posição da pessoa que está no jardim: (202, 199) Obviamente você vai precisar pegar a coordenada da posição da pessoa que está no jardim, depois você poderia calcular a distância entre os 2 pontos(Posição da irrigação do jardim e Posição da pessoa) e se essa distância for digamos que menor que 2, então a irrigação é pra ser desligada, pois a pessoa está a 2 metros do sistema de irrigação. Você pode fazer assim: Semana 1: Você gera um número aleatório de 1 a 7 ou 0 a 6, com isso você cria um vector para armazenar o dia em que foi desligado a luz, e na próxima semana você faz a mesma coisa, porém você verifica se esse numero que você gerou já existe no vector. Depois que todos os números forem usados, você limpa o vector e reinicia o loop novamente. E também você deve verificar se o comodo atual é um quarto ou não. Lembrando que isso só deve ser feito uma vez por semana. c) Você vai ter que primeiramente verificar o horário local(Pode usar APIs do C++ mesmo para fazer isso), se for as 17 horas em diante, você liga o sistema de irrigação e inicia um contador, quando o contador chegar a 120 minutos(2 horas) você desliga o sistema. Sobre a chuva o que eu tenho em mente é a informação de algum site para saber se está ou não chovendo na cidade ou se choveu nesse dia, essa é a parte um pouco complexa de se fazer. d) 1 Sugestão: Sempre que desligado a energia pelo sistema e pessoa ir no comodo e acender e depois sair do comodo, deve dar um tempo de pelo menos 10 ou 15 minutos para desligar novamente a energia do comodo, caso a pessoa volte, essa contagem é zerada. 2 Sugestão: Se isso for um exercício de faculdade, mande o seu professor tomar naquele canto.

#include <stdio.h> #include <stdlib.h> #include <string.h> struct Aluno { char Nome[100]; float Notas[4]; }; // Calcula a média das notas float media(Aluno al) { return (al.Notas[0] + al.Notas[1] + al.Notas[2] + al.Notas[3]) / 4; } int main() { Aluno al; printf("Insira o nome do aluno: "); // Pega o nome do aluno fgets(al.Nome, 100, stdin); // Para limpar o \n do nome, já que a função fgets captura o \n strtok(al.Nome, "\n"); // Pega as quatros notas dos alunos for (int i = 0; i < 4; i++) { printf("Insira a nota %i do aluno: ", i + 1); scanf("%f", &al.Notas[i]); } // Chama a função media para calcular a media das quatro notas do aluno float med = media(al); // Se o aluno atingiu a média vai mostrar APROVADO, caso contrario reprovado e mostra a média que o aluno obteve printf("Aluno %s foi %s com uma media de: %.2f\n", al.Nome, (med >= 7.0f) ? "APROVADO" : "REPROVADO", med); return 0; } Exercício da faculdade que eu tinha feito, bem parecido com esse seu exercício, também calcula a média e mostra o nome do aluno em uma estrutura, você pode usar como exemplo. a unica diferença é que ele usa estrutura(que acho que é o que você está tentando fazer e que também não tem o semestre, mas você pode adicionar, é bem fácil)

Primeiramente um nome não é do tipo float, é um conjunto de caracteres(vetor de um char). Exemplo: char nome[30];

Não entendi muito bem, você quer transformar os vetores nota para ficar armazenado em um vetor de estrutura? Talvez seja isso? #include <stdio.h> #include <stdlib.h> struct Notas { float nota; }notas[4]; float media (int n, Notas* nts); //Declarando a função media int main (void) { int semestre; float media_notas; int i; for (i = 0; i < 4; i++) //Leitura das medias { printf("Digite os valores das notas: "); scanf("%f", &notas[i].nota); } printf("Digite o ano de ingresso para saber em que semestre o aluno esta:\n"); scanf("%d", &semestre); if (semestre < 2017) { printf("error 404\n"); printf("Semestre inserido invalido\n"); } switch (semestre) { case 2017 : printf("O aluno esta no Segundo semestre\n"); break; case 2018 : printf("O aluno esta no Primeiro semestre\n"); break; } //Chamada da função media_notas = media(4, notas); printf("\nMedia = %.1f\n", media_notas); // Se a media for maior que 7, imprime que o aluno esta aprovado if(media_notas >=7) { printf("Aluno Aprovado\n"); printf("O aluno pode prosseguir para o proximo semestre\n"); } else // Se a media for menor que 7, imprime que o aluno esta repovado { printf("Aluno Reprovado\n"); printf("O aluno deve refazer a materia ou fazer a resolucao\n\n"); } system("pause"); return 0; } /*Função para cálculo da média Parâmetros: Recebe a quantidade de elementos n Recebe o endereço inicial do vetor notas em *vnotas Retorno: Retorna a media na variavel m */ float media (int n, Notas* nts) { int i; //Realiza a soma das notas float m = 0, soma = 0; for (i = 0; i < n; i++) soma = soma + nts[i].nota; //Realiza a divisão das notas pelo numero de elementos m = soma / n; //Retorna a media return m; }

Está atualizado na ultima versão possível, meu navegador está do jeito que eu instalei quando formatei hoje, sem extensões ou scripts, isso acontece em todos os navegadores.

Estou a 2 dias com esse problema, já inclusive troquei o cabo de rede para vários outros cabos. Placa-mãe: GA-H110M-H Modem: Dlink DSL-2740E Internet: VIVO 15 MB Sistema operacional: Windows 10 Home Single Uma coisa que eu acho estranho é que nos jogos onlines continua funcionando normalmente, enquanto no navegador do computador simplesmente fica carregando a pagina e depois de um minuto ela carrega. O que podemos descartar: Vírus(Passei vários antivírus e inclusive formatei o computador) Problemas na velocidade da conexão(Até porque no wifi não fica lento quando cai a internet do computador) Cabo de rede(Usei 3 tipos diferentes de cabos de rede e o problema continua) Problema no navegador(até pelo fato que formatei o computador e testei com vários navegadores: Google Chrome, Firefox, Opera, Edge) DNS(Fiz a troca do servidor DNS para vários outros, como do Google por exemplo)

#include <stdio.h> #include <windows.h> #include <time.h> #include <locale> struct InfoLinha { char nome[1024]; }; int main() { setlocale(LC_ALL, "Portuguese"); srand(time(NULL)); FILE* arquivo = fopen("lista.txt", "r"); // Verifica se o arquivo foi aberto com sucesso if (arquivo == NULL) { printf("Falha ao abrir o arquivo. Código do erro: %d\n", GetLastError()); getchar(); return 1; } size_t numLinhas = 0, tamanhoEstruturaArray = 10; // Aloca na memória inicialmente 10 posições(tamanhoEstruturaArray) para a estrutura que vai armazenar os nomes InfoLinha* linha = (InfoLinha*)malloc(tamanhoEstruturaArray); char nomePalavraAtual[1024] = { 0 }; while (fscanf(arquivo, "%s", nomePalavraAtual) != EOF) { // Para caso de ter mais de 10 linhas, é necessário realocar, para evitar problemas de estouros de memória if (numLinhas > tamanhoEstruturaArray - 1) { tamanhoEstruturaArray *= 2; linha = (InfoLinha*)realloc(linha, tamanhoEstruturaArray); } // Copia o nome da linha atual para a posição atual da estrutura linha strcpy(linha[numLinhas].nome, nomePalavraAtual); // Incrementa o número de linhas numLinhas++; } printf("Número de linhas: %d\n", numLinhas); // Sorteando o número da linha de forma aleatória size_t numSorteado = rand() % numLinhas; printf("Palavra sorteada: %s\n", linha[numSorteado].nome); // Libera a memória que foi alocada para a estrutura free(linha); // Fecha o arquivo fclose(arquivo); return 0; } É um pouco parecida com a lógica do @vangodp, a cada vez que chegar no final da linha(\n) vai incrementar o número de linhas em + 1.

class Date { private: int mes, dia, ano; public: Date() : dia(0), mes(0), ano(0) { } Date(int _dia, int _mes, int _ano) : dia(_dia), mes(_mes), ano(_ano) { } const int getDia() const { return this->dia; } const int getMes() const { return this->mes; } const int getAno() const { return this->ano; } void setDia(int _dia) { this->dia = _dia; } void setMes(int _mes) { this->mes = _mes; } void setAno(int _ano) { this->ano = _ano; } void displayDate() { std::cout << this->dia << "/" << this->mes << "/" << this->ano << std::endl; } }; int main() { Date exdate1; int dia = 0, mes = 0, ano = 0; std::cout << "Digite o dia: "; std::cin >> dia; std::cout << "Digite o mes: "; std::cin >> mes; std::cout << "Digite o ano: "; std::cin >> ano; exdate1.setDia(dia); exdate1.setMes(mes); exdate1.setAno(ano); std::cout << "Dia: " << exdate1.getDia() << std::endl; std::cout << "Mes: " << exdate1.getMes() << std::endl; std::cout << "Ano: " << exdate1.getAno() << std::endl; exdate1.displayDate(); // Exemplo 2: Inicializando diretamente a classe pelo construtor: Date exdate2(10, 2, 1920); std::cout << "Dia: " << exdate2.getDia() << std::endl; std::cout << "Mes: " << exdate2.getMes() << std::endl; std::cout << "Ano: " << exdate2.getAno() << std::endl; exdate2.displayDate(); return 0; }

Acho que você devia dizer onde estava o problema e o que fez para solucionar, para ajudar alguém que tenha um problema parecido com o seu.

@EIGHT RxXD poderia me dizer como você quer fazer para calcular os 2 últimos dígitos? Pelo código ficou bem confuso esse seu calculo. PS: Eu testei seu código aqui e não gerou números grandes, gerou apenas zeros em todos os dígitos. Umas sugestões: 1 - Quando declarar uma variável sempre inicialize ela com algum valor, por exemplo 0, assim vai evitar que ela seja inicializada com lixo de memória, essa sugestão em alguns raros casos não é para ser aplicada, por exemplo, se você está criando uma aplicação que precisa do máximo de performance possível e que até um ganho de poucos nanosegundos já seja grande coisa na sua aplicação, ai nesse caso você deve ignorar essa sugestão. 2 - Procure deixa o seu código mais legível, por exemplo, no caso das variáveis defina o nome dela como o que exatamente ela vai fazer ou receber(nome de pessoas e e idades nesse exemplo), por exemplo: // Forma que dificulta a legibilidade do código: char np[300]; int i; // Forma correta(ainda faltou inicializar com 0) char nome_pessoa[300]; int idade; 3 - Como já foi dito acima, se você está programando em C++, evite usar as sintaxes do C, como por exemplo: char CPF[12]; int cpf[11]; Prefira usar: string CPF; // Não é necessario inicializar com algum valor, já que é uma classe e com certeza tem um construtor dentro dela que já inicializa os valores com 0. vector<int> cpf; // Não é necessario inicializar com algum valor, já que é uma classe e com certeza tem um construtor dentro dela que já inicializa os valores com 0. Essa sugestão assim como a primeira, não se aplica se você estiver desenvolvendo uma aplicação que necessite do máximo de desempenho possível, mas fique sabendo que a diferença no desempenho da string e do vector do C++ para o da linguagem C não é grande coisa, a diferença é de uns milissegundos a mais na velocidade de um para o outro, o que em 99% dos casos não causa perda de desempenho na aplicação.

Poste o código completo, assim fica bem difícil de saber onde está o erro, o que exatamente é o n e com qual valor ele foi inicializado?

Não está funcionando porque você não está limpando o buffer do teclado. Apenas adicione as 2 linhas abaixo dos cin para limpar o buffer: cin.clear(); cin.ignore(INT_MAX,'\n'); Existe varias forma de limpar o buffer do teclado, essa é a unica que me recordo no momento.