isrnick

Aqui está: /** * 17. Faça uma função que leia um número não determinado de valores positivos * e retorna a média aritmética dos mesmos. **/ #include <stdio.h> float media (float vet[], int a){ int i; float q=0; for(i=0;i<a;i++){ q+=vet[i]; } return q/(a); } int main (){ int a, i; float vet[a]; printf("Informe quantos numeros serao lidos: "); scanf("%d", &a); for(i=0;i<a;i++){ do{ printf("Numero %d: ", i); scanf("%f", &vet[i]); }while(vet[i]<0); } printf("A media da quantidade de numeros digitados e de %f.\n", media(vet, a)); return 0; } - Reorganizei o código, definindo a função na sequência clássica. - Retirei a leitura dos dados de dentro da função media, fazendo ela fazer apenas o trabalho que se espera dela, ou seja calcular a média. - int main() e return 0.

Precisa instalar o compilador e configurar o Codeblocks para usá-lo. Ou então baixar e instalar uma versão do Codeblocks que já vem com um compilador, para isso na página de downloads do Codeblocks escolha uma das opções que tem mingw no nome do arquivo, por exemplo "codeblocks-17.12mingw-setup.exe".

Sim eu vi, mas o mingw não é uma IDE, é um compilador, então o correto seria dizer: Pois o codeblocks é uma IDE, codeblocks sem IDE não é nada, não existe, é um vazio. rs

*que vem com o compilador incluso (mingw). O codeblocks é uma IDE.

A função dele é limpa linha, não limpa tela, ela faz outra coisa (o nome_limpa linha não é muito descritivo do que ela faz, eu preferiria clear_stdin ou algo assim). getch() não é função padrão da linguagem, faz parte da biblioteca não padrão conio que contém funções exclusivas para o prompt MS-DOS do Windows, portanto precisa dessa biblioteca, e o código só funcionará em sistemas Windows.

Sim, mas essa biblioteca não é padrão, é uma biblioteca de terceiros, então as pessoas tem que obter a biblioteca conio2.h para conseguir rodar o seu código.

Hahaha, mas esse tópico nem tem nada de programação! Mas não, não trabalho com isso, pelo menos não por enquanto, eu só estudo programação porque gosto de programar mesmo.

Sim, o problema está no caminho do arquivo, colocando o arquivo "Arquivo2.txt" na mesma pasta do executável o código abaixo funcionou corretamente, como esperado: #include<stdio.h> #include<stdlib.h> int main() { char x[100]; freopen("Arquivo2.txt", "r", stdin); fgets(x, 100, stdin); printf("%s", x); fclose(stdin); return 0; } Execute o código aqui: https://onlinegdb.com/S1e4piPEX Então tem que verificar o que está errado no caminho: Normalmente o nome verdadeiro da pasta é Desktop, e "Área de Trabalho" é só uma máscara, como o @Xaws indicou, e dependendo do Windows a pasta do usuário pode estar dentro da pasta Users: D:\\Users\\ContaCelestinoAlona\\Desktop\\Arquivo 2.txt Então, verifique qual é o caminho correto do arquivo no seu computador e corrija.

Como o @AnsiC falou quebra o loop, mas note que apenas 1 loop é quebrado, então se tiver 2 ou mais loops aninhados (um dentro do outro) não vai sair de todos os loops, sai apenas de 1 loop, o loop onde o break foi executado, e o(s) loop(s) mais externo(s) continua(m) rodando.

Não estou mais em casa, aqui só uso compiladores online, só a noite pra eu ver como está. Também pesquisei, e realmente é algo opcional e o compilador pode escolher não implementar e ainda assim atender ao padrão C11 sem problemas. E aparentemente o GCC não implementou... Mas eu compilei no MinGW e o programa rodou... curioso, vou ter que ver melhor o que está aconteceu.

Entendi. Eu ainda recomendaria usar um nome diferente, ser igual não seria problema se fosse uma de uma biblioteca de terceiros, pois entende-se que pode ser diferente mesmo com nome igual então tem que pesquisar como funciona, mas para algo definido no padrão da linguagem as pessoas assumem que funciona como definido no padrão.

O compilador de C da microsoft só atende ao padrão C89 da linguagem... E eles não tem interesse em atualizar pois a prioridade deles é apenas atender os padrões do C++. Pra mim isso significa que eles não tem interesse que programem em C usando o compilador deles, e ele está lá apenas para viabilizar alguns recursos do C no C++, que é o que realmente lhes interessa, logo eu diria que o compilador da Microsoft não pode ser considerado como um padrão para o que do C pode ser usado no Windows. Então as distribuições para Windows do GCC basicamente são a única opção para programar em C atual no Windows (até mesmo o Clang ainda não atende totalmente o padrão C11). E estas funções e macro são definidas no padrão C11, logo são sim padrão da linguagem.

@AnsiC Esse é o GCC (GNU Compiler Collection), tá até escrito ali versão 6.3.0. O mingw é uma versão para Windows do GCC...

@AnsiC Poderia usar scanf_s da biblioteca padrão (a partir da versão C11), se estiver disponível na implementação do compilador (o GCC tem), mas tem que definir __STDC_WANT_LIB_EXT1__ com valor 1 antes de incluir stdio.h para poder usar a função: #define __STDC_WANT_LIB_EXT1__ 1 #include <stdio.h> int main(){ char frase[15] = ""; scanf_s("%[^\n]", frase, 15); printf("%s\n", frase); return 0; } (E seria melhor usar um nome diferente para a sua função, para não ser confundido com o scanf_s da biblioteca padrão.)

%d é o especificador de número inteiro na forma decimal. %s é o especificador de string. E como % é usado em especificadores nas funções das famílias de funções scanf e printf, é preciso ter uma sequencia de escape de caractere para quando você quer usar o caractere % (ao invés de um especificador) na string de formatação dessas funções, nesse caso o usa-se %% para gerar o caractere % na string.

Tem vários problemas... Seu código está em C++ não em C# como indica o título do seu tópico. Está misturando bibliotecas do C (<stdio.h>, <stdlib.h>, <locale.h>, <ctype.h>) com bibliotecas do C++ (<iostream>), quando programa em C++ use as bibliotecas do C++ (se vai usar bibliotecas do C++ que contém funções do C use <cstdio>, <cstdlib>, <clocale>, <cctype>, etc). Mas se vai preferir usar os recursos do C poderia programar em direto em C, ao invés de C++. O arquivo é aberto mas não é fechado com fclose(), então nada é escrito de fato no arquivo. Está usando funções do C quando existem recursos do próprio C++ para fazer a mesma coisa, e de maneira mais apropriada para o C++. Por exemplo: Usou FILE * e fopen(), fgets() e fputs(), mas no C++ existe fstream e getline(); Usou gets() que jamais deve ser usado, mesmo no C, por ser uma função obsoleta que foi abandonada por não ser segura, mas poderia usar std::cin no C++. Usou vetor de char mas poderia usar string no C++. Veja o código usando os recursos do C++: #include <iostream> #include <fstream> #include <clocale> #include <string> #include <cctype> using namespace std; int main() { setlocale(LC_ALL,"portuguese"); int i = 0; string word; fstream file1; file1.open("Arquivo2.txt", fstream::in | fstream::out | fstream::app); cout << "Insira seu nome : "; getline(cin, word); while(word[i] != '\0') { if(islower(word[0])) { word[0] = toupper(word[0]); } i++; if(i != 0) { word[i] = tolower(word[i]); } } cout << "\n\nSeu nome e' : " << word << "\n\n"; file1 << word << "\n"; file1.close(); return 0; }

Eu diria que isso não é um código simples, é sim um código curto, mas não fica óbvio com uma leitura rápida o que faz, principalmente usando esse operador ternário com dupla atribuição, com uma dupla negação booleana, tudo na mesma expressão. É o tipo de situação que eu diria que seria muito melhor fazer o código um pouco mais extenso, deixando as operações explícitas, e o código seria entendido muito mais facilmente. É importante lembrar que código é escrito para programadores entenderem, não para o computador, então legibilidade é mais importante que quão compacto o código fica. Mas segue a explicação (também fiz algumas correções no código): #include <iostream> int main() { int c = 0, //faltava inicializar c com valor 0 n, max = 0; //Como 0 e' o maximo inicial numeros negativos nao serao contados //Enquanto for digitado um numero inteiro valido no terminal: while(std::cin >> n) //Conta quantas vezes o maior numero digitado se repete: max < n ? c = !!(max = n) : c += max == n; //A linha abaixo deve vir apos o while, nao antes, pois serve para descartar //o(s) caractere(s) digitado(s) que nao forma(m) um numero inteiro valido, //usado(s) para sair do while, mas que ainda esta(ao) no stream de entrada. std::cin.ignore(); //Imprime a quantas vezes o maior numero foi repetido std::cout << c; return 0; }

As variáveis não são inicializadas (com valor 0), então tá pegando o valor lixo qualquer que já estava na memória e somando sobre ele.

Tá falando o IDLE? Quer que abra direto no Editor de Texto ao invés de abrir no Shell? Se for isso, vá em Options > Configure IDLE > General, e no campo Startup Preferences mude o At Startup para Open Edit Window.

Só adicionei no código do @AnsiC para imprimir cada byte separadamente em hexadecimal: #include <stdio.h> /* ~incluir: printf */ #include <limits.h> /* ~incluir: INT_MAX */ #define str(val) #val struct sttnumero { char caractere; int inteiro; }; /** funcao main ~ principal do programa */ int main (void){ struct sttnumero me = {0, INT_MAX}; * (int *) & me.caractere = 0x04030201; printf ("SizeOf %s: %u\n", str (me), sizeof me); printf ("Inteiro %s: %d\n", str (me.caractere), * (int *) & me.caractere); printf ("Inteiro %s: %d\n", str (me.inteiro), me.inteiro); for(int i = 0; i < 4; i++){ printf ("Char %d: 0x%02hhx\n", i, *(&me.caractere + i) ); } printf ("\nPoint %s: %u\n", str (me), &me); printf ("Point %s: %u\n", str (me.caractere), &me.caractere); printf ("Point %s: %u\n", str (me.inteiro), &me.inteiro); return 0; }

Sim, como o @AnsiC falou isso está implícito, logo é calculado automaticamente usando o tamanho do tipo da variável. Se pensar bem o mesmo é feito quando usamos índices nos colchetes de vetores ( vet[1] ), de fato a indexação de vetores usa aritmética de ponteiros. Se estiver interessado veja esse exemplo que postei mostrando que ambos os métodos podem ser usados intercambiavelmente:

Ou mais precisamente na verdade tem isso: +-------+-------+-------+-------+ | numero1 | +-------+-------+-------+-------+ | numero2 | +-------+-------+-------+-------+ | letra | ? | +-------+-------+-------+-------+

Teste assim: fseek(arq, 0, SEEK_END); tamanho = ftell(arq) / sizeof(cadastro);

Primeiro, vários dos tipos básicos do C tem um tamanho mínimo necessário, mas o tamanho real depende da implementação do compilador e do sistema onde está sendo usado. Então, a norma define que o tipo int deve ter pelo menos 2 bytes de comprimento, mas na prática costuma ser implementado com 4 bytes em compiladores para computadores (mas um compilador para um sistema embarcado por exemplo poderia usar int com 2 bytes). Para saber qual o tamanho de cada tipo cuja norma só define um tamanho mínimo basta testar cada um com sizeof no seu compilador, ou pesquisar na internet. Então teoricamente sua struct teria 4 + 4 + 1 = 9 bytes. Mas acontece que num sistema de 32 bits memória é dividida em blocos de 32 bits ou 4 bytes, então a memória é alocada em múltiplos de 4 bytes. Então, sua struct precisa alocar 4 bytes para o int, 4 bytes para o float, e 4 bytes para o char (apesar do tipo char ter tamanho 1 byte), totalizando 12 bytes para a struct inteira. Do último byte alocado apenas 1 byte será utilizado de fato, para armazenar o valor do tipo char, os outros 3 bytes não são utilizados. Mas note que poderia adicionar outras variáveis char, ou até uma variável short int, no fim da struct, e essas variáveis ocupariam e usariam esses bytes que foram alocados mas não foram utilizados, e o tamanho total da struct ficaria inalterado. Isso também implica que a ordem dos itens na struct é importante, pois uma struct mal organizada pode aumentar muito o espaço ocupado pela struct. Por exemplo: //Essa struct mal organizada ocupa 16 bytes: struct est{ int a; char b; int c; short int d; } //Mas essa ocupa apenas 12 bytes: struct est2{ int a; int c; char b; short int d; } O problema na primeira struct é que 4 bytes são alocados para o char b, mas esse só usa 1 dos 4 bytes, e sobram 3 bytes, mas o int c ocupará 4 bytes, então não cabe nos 3 bytes que sobraram na alocação do char c, logo precisa ser alocado um novo grupo de 4 bytes para guardar o int c, e os 3 bytes não utilizados são desperdiçados. Já na segunda struct o char b (1 byte) e o short int d (2 bytes) cabem juntos dentro de apenas 1 grupo de 4 bytes que foi alocado, ocupando 3 bytes, e apenas 1 byte fica sobrando não utilizado.

Sobre o Windows API o @devair1010 postou esse link de um livro sobre o assunto: http://vulms.vu.edu.pk/Courses/CS410/Downloads/Charles Petzold - Programming Windows - 5th Ed.pdf