isrnick

@Mauro Britivaldo Sua solução é meio complicada, atualizando uma variável static para saber onde está, e também fazendo várias cópias para mover os caracteres para a direita... Segue minha solução para preencher um vetor de char com a string do número binário: #include <string.h> char *binarystr(char *bin, long long int n){ unsigned long long int b = (unsigned long long int)n; static int notzero = 0; char c[] = {'\0','\0'}; if (b){ notzero = 1; c[0] = (b & 1) ? '1' : '0'; binarystr(bin, b >> 1); strcat(bin, c); } else if(notzero) { *bin = '\0'; } else { bin[0] = '0'; bin[1] = '\0'; } notzero = 0; return bin; } E um exemplo de programa utilizando a função: #include <stdio.h> #include <limits.h> #include <string.h> char *binarystr(char *bin, long long int n){ unsigned long long int b = (unsigned long long int)n; static int notzero = 0; char c[] = {'\0','\0'}; if (b){ notzero = 1; c[0] = (b & 1) ? '1' : '0'; binarystr(bin, b >> 1); strcat(bin, c); } else if(notzero) { *bin = '\0'; } else { bin[0] = '0'; bin[1] = '\0'; } notzero = 0; return bin; } int main() { long long int n; char s[1 + 8*sizeof n]; printf(" Decimal -> Binario\n"); n = 12; printf("%20lld -> %s\n", n, binarystr(s, n)); n = 1; printf("%20lld -> %s\n", n, binarystr(s, n)); n = -1; printf("%20lld -> %s\n", n, binarystr(s, n)); n = LLONG_MAX; printf("%20lld -> %s\n", n, binarystr(s, n)); n = LLONG_MIN; printf("%20lld -> %s\n", n, binarystr(s, n)); return 0; }

Onde está o enunciado? De qualquer maneira se é estritamente n > 0 então deveria ser unsigned long int n , mas ainda assim não dá pra retornar todos os valores possíveis de long int n para n > 0 como uma representação decimal do número binário, visto que mesmo para o tipo short só cabe no tipo long long int . Nesse caso seria melhor fazer uma função que imprime o binário ao invés de retornar um número decimal que representa o binário, pois assim poderia converter corretamente qualquer tamanho de número binário, nesse caso a função ficaria assim (também fiz funcionar para números negativos): #include <stdio.h> #include <limits.h> void printbinary(int a){ unsigned int b = (unsigned int)a; static int notzero = 0; if (b){ notzero = 1; printbinary(b >> 1); printf("%d", b & 1); } else if (notzero){ notzero = 0; } else { printf("0"); } } int main() { long int n; printf(" Decimal -> Binario\n"); n = 12; printf("%20ld -> ", n); printbinary(n); n = 1; printf("\n%20ld -> ", n); printbinary(n); n = LONG_MAX; printf("\n%20ld -> ", n); printbinary(n); return 0; } Ou então teria que fazer uma função que recebe um vetor de char como parâmetro e o preenche com uma string que compõe o número binário, mas aí teria que passar 2 parâmetros para a função recursiva: o vetor e o número a ser convertido.

Nenhuma das funções apresentadas até agora funcionam para números negativos (números grandes também seria um problema). Segue uma solução que funciona para números negativos: #include <stdio.h> #include <limits.h> unsigned long long int binary(short a){ unsigned short b = (unsigned short)a; if (b){ return (unsigned long long int) binary(b >> 1) * 10LLU + (b & 1); } return 0LLU; } int main() { short n = 12; printf("Decimal -> Binario\n"); printf(" %6hd -> %16llu\n", n, binary(n)); n = -12; printf(" %6hd -> %16llu\n", n, binary(n)); n = 1; printf(" %6hd -> %16llu\n", n, binary(n)); n = -1; printf(" %6hd -> %16llu\n", n, binary(n)); n = SHRT_MAX; printf(" %6hd -> %16llu\n", n, binary(n)); n = SHRT_MIN; printf(" %6hd -> %16llu\n", n, binary(n)); return 0; } Note que o parâmetro da função precisa ser do tipo short (para limitar a 16 bits) e que o retorno da função precisa ter tipo unsigned long long int para caber o número decimal com 16 casas que representa o número binário no valor retornado.

Não, strcmp() não ignora espaços. Precisa remover os espaços da string também.

@userpc_2020 @AdrianoSiqueira Nenhum dos 2 programas atendem aos requisitos do enunciado, pois de acordo com o enunciado o programa deve ser capaz de ler frases inteiras, e analisar se são palíndromos eliminando os espaçamentos e pontuação antes de inverter e checar se é igual ao sentido normal. Outro problema é que os programas não consideram que pode ter letras maiúsculas e letras minúsculas na frase, e por isso ele pode acusar que não é palíndromo quando realmente é palíndromo, pois em C o caractere de uma letra maiúscula não é considerado igual ao caractere dessa mesma letra minúscula. Eu e o @Mauro Britivaldo postamos soluções mais completas para esse problema nesse tópico: Esse é um exercício comum, segue outro tópico com o mesmo problema:

Segue uma lista do que tem que corrigir no código original postado no tópico: 1 - Incluir as bibliotecas stdio.h e math.h 2 - Mudar o tipo da função calcularhipotenusa para double para retornar um número double 3 - Mudar os tipos dos parâmetros da função c1 e c2 para double ao invés de int 4 - Corrigir a equação para calcular a hipotenusa corretamente usando c1 e c2 5 - Corrigir o tipo da função main trocando o tipo de void para int 6 - Corrigir o especificador de tipo nas funções scanf para usar o especificador correto para o tipo double ( %lf ) 7 - Corrigir o último comando da função main para retornar 0 (zero) ao invés de retornar a função calcularhipotenusa

if(nota > maior){ nota = maior; } else if(nota < menor){ nota = menor; } Estão errados, não é nota que deve receber maior (ou menor), é o contrário, maior (ou menor) deve receber o valor da nota. adicionado 5 minutos depois Não faz sentido usar valores máximos e mínimos do tipo int para variáveis float, se vai usar esse método é melhor usar os valores máximo e mínimo do tipo float. @kampa896 De qualquer maneira recomendo usar a primeira nota digitada como valores maior e menor iniciais.

@devair1010 É que ele chama "alterar um vetor recebido por um ponteiro parâmetro da função" de "retornar através do parâmetro". Retornar não está se referindo a usar a palavra chave return nesse caso.

@XIXX posta o que você tentou fazer e não deu certo.

Sim, nesse caso poderia ler diretamente para o aux, mas deixei separado para deixar claro no código o ponto que eu mencionei de assumir o primeiro número como o máximo inicial. O objetivo era ensinar a lógica não fazer o código mais eficiente possível. Entendendo a lógica fica mais fácil adaptar para casos parecidos com alguma diferença, como no caso em que guardaria todos números digitados em um vetor para serem usados posteriormente no código, nesse caso seria melhor não guardar o número diretamente na variável aux, mas sim colocar no vetor primeiro. Não faz diferença na prática, mas pode sim ser mais fácil de entender para quem está lendo o enunciado e analisando o código. Exato. É bom o programador C saber que os tipos da linguagem são limitados, e aprender sobre as constantes da biblioteca limits.h . Mas essa solução colocando o menor valor int possível como número fixo inicial não é ideal, pois matematicamente isso teria o mesmo problema de colocar o número 0 como valor fixo inicial. É sempre melhor fazer de modo que dependa apenas de comparar os números sendo analisados.

Faça dois vetores um com 5 posições para armazenar o número mínimo para cada linha respectivamente, e outro com 7 posições para armazenar o máximo de cada coluna respectivamente. Aí faz 2 loops aninhados para comparar cada mínimo de linha com todos os máximos das colunas, se encontrar um mínimo na linha e máximo na coluna iguais então checa se a posição da matriz com nessa linha e coluna é a posição que tem esse valor, se for então é sela.

Não precisa saber qual é o menor número possível para o tipo, até porque o tamanho do tipo int varia, pois o int deve ter tamanho de no mínimo 2 bytes, então nesse caso o número menor possível seria −32768, e não -2147483648 (= menor valor possível quando int tem 4 bytes). O melhor método de fazer isso é assumir o primeiro número digitado como o valor máximo inicial, e aí ir comparando os próximos números com o máximo atual e substituir se aparecer um número maior: #include <iostream> #include <locale> using namespace std; int main(){ setlocale(LC_ALL, ""); int num, i, aux; cout << "\nDigite o número 1:"; cin >> num; aux = num; for(i = 2; i < 16; i++){ cout << "\nDigite o número " << i << ":"; cin >> num; if(num > aux){ aux = num; } } cout << "O maior número da lista é: " << aux << "."; return 0; }

Não, não tem o mesmo efeito, o segundo nem pode ser feito. Esse asterisco está no lugar errado, e provavelmente geraria erro. Um ponteiro é declarado assim: int *vari; E o seu problema parece ser que você ainda não aprendeu o que são ponteiros e como usá-los. Tentar dar uma explicação completa sobre ponteiros em C aqui no fórum seria complicado, mas você deve achar explicações pesquisando online. Então vou apenas passar alguns conceitos básicos. Um ponteiro é um tipo de variável que serve apenas para armazenar endereços de memória, e dizemos que "um ponteiro aponta para o local do endereço de memória guardado nele". Para obter o endereço de memória de uma variável usamos o operador & (operador "endereço de") antes do nome da variável, e então esse endereço pode ser guardado num ponteiro. int a = 10; int *ponteiro; ponterio = &a; Note que você já usa o operador & frequentemente na função scanf, ou seja você está passando o endereço da variável para a função scanf, e na função esse endereço é guardado num ponteiro. Uma vez que o ponteiro aponta para um local da memória podemos usar o operador * (operador de indireção ou operador de desreferenciamento) para acessar o valor do local para onde o ponteiro aponta. Então no exemplo acima acessar o local fazendo *ponteiro vai retornar o valor guardado na variável a, ou seja 10, e se alterar o valor deste local da memória fazendo uma atribuição como *ponteiro = 5; vai alterar o valor da variável a para 5 pois esse lugar da memória é onde é guardado o valor de a. Então numa função como scanf, ela pode alterar dentro da função o valor do local do endereço de memória da variável que foi passado para ela, e quando sair da função esta variável vai estar com o novo valor. O tipo do ponteiro indica como os dados guardados no local da memória para onde ele aponta devem ser interpretados, e também qual o tamanho em bytes deste tipo de dado, afinal na memória tanto um valor int quanto um float (ou qualquer outro tipo de dado) são guardados como agrupamentos (bytes) de 0s e 1s indicando estado binário de 1 bit da memória (1 byte = 8bits). Um cast como (float *) serve para converter um endereço de memória de outro tipo em um endereço de memória do tipo float. E esse tipo de cast só deve ser usado para converter endereços de memória. Você tem que usar esse botão para postar códigos no fórum:

Está faltando um argumento ao chamar a função getBaseAdress, você não passou o valor do parâmetro pid . Obs: Address se escreve com 2 Ds.

Isso não faz sentido. O que estaria tentando fazer aqui? Converter um valor inteiro para um ponteiro e armazenar o endereço de memória em uma variável inteira? (float *) é um cast para converter um endereço de memória que aponta para valores de outro tipo, em um endereço de memória que aponta para valores float. Ou seja, ao dar cast de um endereço de memória usando (float *) basicamente está dizendo: Transforme o endereço de memória a seguir em um endereço de memória que quando for desreferenciado (com o operador *) o valor para o qual o ponteiro aponta seja interpretado como um número do tipo float. malloc retorna um ponteiro do tipo void * , em C esse tipo de ponteiro pode ser automaticamente convertido para qualquer outro tipo automaticamente, na verdade possibilitar conversão automática para outro ponteiro é o motivo pelo qual ele existe, logo dar cast no malloc em C é besteira (isso pode até atrapalhar pois tem situações que gerariam warning durante a compilação te avisando que existe algo errado, mas que não vão ser detectados se você tiver usado cast no retorno de malloc).

ponteiro-> é um jeito mais curto de escrever de (*ponteiro). , é uma abreviação mais legível. Na função operacao_lista por exemplo você recebe um ponteiro l para uma struct lista como parâmetro: struct lista* l Então para acessar a struct para a qual o ponteiro l aponta seria necessário desreferenciar o ponteiro fazendo *l , e aí pode acessar campos da struct usando o operador de acesso ponto ( . ) desse jeito: (*l).inicio Mas isso não é algo prático de digitar, e dependendo se isso estiver dentro de outros parênteses ou expressões pode afetar a legibilidade do código. Então criaram um operador com outra simbologia para fazer a mesma coisa, que é a seta -> . Logo, o mesmo campo da struct apontada pelo ponteiro l também pode ser acessado assim: l->inicio

Dá pra usar as lógicas de algoritmos de ordenação, veja os códigos usando o 3 algoritmos de ordenação mais simples: > Insertion Sort: #include <stdio.h> int main() { int num1, num2, num3, menor, inter, maior; printf("DIGITE UM NUMERO: "); scanf("%d", &num1); printf("DIGITE UM SEGUNDO NUMERO: "); scanf("%d", &num2); printf("DIGITE UM TERCEIRO NUMERO: "); scanf("%d", &num3); printf("\n"); if ((num1 == num2) || num1 == num3 || num2 == num3){ printf("DIGITE NUMEROS DISTINTOS!!"); return 0; } else { //INSERTION SORT: //Deve inserir cada novo numero na lista tal que mantem a lista ordenada, //movendo os numeros ja na lista para frente caso necessario, para abrir //espaco para inserir o numero na posicao correta. //Insere o primeiro numero na lista ordenada menor = num1; //Insere o segundo numero na lista ordenada if(menor > num2){ inter = menor; menor = num2; } else { inter = num2; } //Insere o terceiro numero na lista ordenada if(inter > num3){ maior = inter; if (menor > num3){ inter = menor; menor = num3; } else { inter = num3; } } else{ maior = num3; } } printf("MENOR = %d \n", menor); printf("INTERMEDIARIO = %d \n", inter); printf("MAIOR = %d \n", maior); return 0; } > Bubble Sort: #include <stdio.h> int main() { int num1, num2, num3, menor, inter, maior, temp; printf("DIGITE UM NUMERO: "); scanf("%d", &num1); printf("DIGITE UM SEGUNDO NUMERO: "); scanf("%d", &num2); printf("DIGITE UM TERCEIRO NUMERO: "); scanf("%d", &num3); printf("\n"); if ((num1 == num2) || num1 == num3 || num2 == num3){ printf("DIGITE NUMEROS DISTINTOS!!"); return 0; } else { //BUBBLE SORT: //Vai comparando cada 2 posições consecutivas e trocando caso os numeros //estejam fora de ordem, quando chega ao fim das posições volta para //comparar as 2 primeiras posições. //Poe os numeros na lista desornados menor = num1; inter = num2; maior = num3; //Compara primeiras 2 posições consecutivas e troca se tiver fora de ordem if(menor > inter){ temp = menor; menor = inter; inter = temp; } //Compara proximas 2 posições consecutivas e troca se tiver fora de ordem if(inter > maior){ temp = inter; inter = maior; maior = temp; } //O maior dos 3 ja foi movido para o local correto, agora so falta //ordenar as 2 primeiras posições. //Compara primeiras 2 posições consecutivas e troca se tiver fora de ordem if(menor > inter){ temp = menor; menor = inter; inter = temp; } } printf("MENOR = %d \n", menor); printf("INTERMEDIARIO = %d \n", inter); printf("MAIOR = %d \n", maior); return 0; } > Selection Sort: #include <stdio.h> int main() { int num1, num2, num3, menor, inter, maior, temp; printf("DIGITE UM NUMERO: "); scanf("%d", &num1); printf("DIGITE UM SEGUNDO NUMERO: "); scanf("%d", &num2); printf("DIGITE UM TERCEIRO NUMERO: "); scanf("%d", &num3); printf("\n"); if ((num1 == num2) || num1 == num3 || num2 == num3){ printf("DIGITE NUMEROS DISTINTOS!!"); return 0; } else { //SElECTION SORT: //Vai para cada posicao procura e seleciona o menor dos valores ainda //nao ordenados e poe nessa posicao. //Poe os numeros na lista desornados menor = num1; inter = num2; maior = num3; //Deve selecionar o menor dos valores desordados para colocar no menor. //Se o valor intermediario for menor que menor atual faz a troca if(menor > inter){ temp = menor; menor = inter; inter = temp; } //Se o valor maior for menor que menor atual faz a troca if(menor > maior){ temp = menor; menor = maior; maior = temp; } //O menor dos 3 ja foi selecionado e movido para o local correto, agora //so falta selecionar o menor entre os 2 numeros que ainda nao foram //ordenados e por como valor intermediario. //Se o valor maior for menor que intermediario atual faz a troca if(inter > maior){ temp = inter; inter = maior; maior = temp; } } printf("MENOR = %d \n", menor); printf("INTERMEDIARIO = %d \n", inter); printf("MAIOR = %d \n", maior); return 0; }

Aqui, eu fui no embalo e já fiz uma função para converter os 4 bytes = 32 bits do float IBM para IEEE754: #include <stdio.h> #include <stdint.h> #include <math.h> float IBMfloattoIEEE754 (uint32_t n){ int sig = (n >> 31) ? -1 : 1; uint32_t pot = (n & 0x7F000000) >> 24; double frac = (double) (n & 0x00FFFFFF) / 0x01000000; return (float) (sig * frac * pow(16.0, pot-64.0)); } int isBigEndian() { int test = 1; char *p = (char*)&test; return p[0] == 0; } uint32_t litEndianUint32_t(uint32_t value){ uint32_t copy = value; if( isBigEndian() ){ copy = ((copy >> 24) & 0xFF) | ((copy >> 8) & 0xFF00) | ((copy & 0xFF00) << 8) | (copy << 24); } return copy; } int main() { uint32_t n = 0x45AFC050; float num = IBMfloattoIEEE754(n); printf("Numero decimal: %f\n" " Hex IEEE754: %X\n" " Hex IBM float: %X\n" "Int do Hex IBM: %u\n", num, litEndianUint32_t(*(uint32_t *)&num), n, n); return 0; }

@gellox Não sei se tem biblioteca que faz isso facilmente disponível. Vou explicar a conversão desse exemplo, e você vê se consegue entender para fazer o algoritmo, ou se te ajuda a entender algum algoritmo pronto que você possa aplicar para o seu caso: O código hexadecimal é: 45AFC050 Ou separando cada byte: 45 AF C0 50 Que em binário fica com 32 bits fica: 01000101 10101111 11000000 01010000 Segundo a especificação IBM temos 1 bit para o sinal, 7 bits para o expoente, e 24 bits para a parte fracionária. Sendo que o número é representado como: (-1)sinal x 0.fração x 16(expoente-64) Então separando os bits no formato 1 - 7 - 24 temos: 0 1000101 101011111100000001010000 Logo: Sinal = 0 = 0 hex Expoente = 1000101 = 45 hex Fração = 10101111 11000000 01010000 = AF C0 50 hex Converter o expoente para decimal é simples: 45hex = (4dec x 161dec) + (5dec x 160dec) = 69 dec Já o número hexadecimal com parte fracionária é mais complicado: 0.AFC050hex = (0decx160dec) + (10decx16-1dec) + (15decx16-2dec) + (12decx16-3dec) + (0decx16-4dec) + (5decx16-5dec) + (0decx16-6dec) = = 0.68652820587158203125dec Logo o número é: (-1)0 x 0.68652820587158203125 x 16(69-64) = (-1)0 x 0.68652820587158203125 x 165 = 719877

@gellox Em geral o formato IEEE754 é o formato usado para armazenar números com parte inteira e fracionária na forma binária, o formato IBM de números com ponto flutuante só é usado em mainframes IBM (e mesmo neles IEEE754 também é usado). O software que você está usando está interpretando o conteúdo do arquivo usando o formato IBM (pela imagem aparentemente pode configurar para usar outro formato), usando este formato os bytes usados como exemplo quando convertidos para um número decimal resultarão no número 719877, mas usando o formato IEEE754 resultariam em outro número na forma decimal. A questão é se você está usando o formato correto ao interpretar esse arquivo. Os números foram armazenados no arquivo usando o formato IBM? Se sim você vai ter que implementar o código para fazer a conversão nesse formato.

Porque deve receber um endereço de memória, no caso deve ser o endereço da primeira posição de um vetor de char contendo uma string. E é isso que você está passando quando passa uma string ou o nome de um vetor ao chamar essas funções. Pois usar o nome de um vetor é o mesmo que pegar o endereço de memória da primeira posição desse vetor. Ou seja, para um vetor criado como: int vetor[10]; Temos que usar o nome vetor é igual a usar &vetor[0]. vetor == &vetor[0] FILE é um tipo definido na biblioteca stdio.h que é capaz de armazenar todas as informações necessárias para controlar uma stream de entrada ou saída, usamos um ponteiro de FILE para lidar com arquivos no disco rígido ou SSD. Tem que ser const char * pois está dizendo que não deve fazer alterações no valor armazenado no local apontado por este ponteiro, ou seja o valor é constante. Dentro da função se tentasse alterar este valor daria erro ao tentar compilar. No protótipo da função o const também serve para te informar que a função não é destrutiva, ou seja a string passada como argumento não será alterada pela função.

@devair1010 Claro, basta usar o especificador certo (%[^\n]), do mesmo modo que o scanf.

- INTRODUÇÃO DA FUNÇÃO nscanf (N.o.o.b's scanf): Iniciantes na linguagem C tipicamente não entendem como a função scanf funciona e acabam cometendo erros que levam ao mal funcionamento do programa. Dois erros comuns são: - Não considerar que no fim da leitura do scanf normalmente sobra o caractere nova linha '\n' na entrada padrão stdin, e que isso deve ser tratado, ou seja o caractere deve ser lido para que não fique sobrando na stdin correndo o risco de afetar as próximas leituras. - Não considerar que o usuário pode não se comportar, ou seja não digitar aquilo que o programa solicitou e espera que ele digite. Por exemplo, pode digitar um texto quando se espera que digite um número, ou digitar um número com ponto flutuante (float ou double) quando se espera um número inteiro, ou não digitar nada, ou até mesmo digitar o que é esperado mas também continuar digitando coisas além disso na mesma linha, entre outros casos. Então, tendo em vista isto eu fiz esta função nscanf (N.o.o.b's scanf) que se comporta como os iniciantes em C esperam que a função scanf funcione: #include <stdio.h> #include <stdlib.h> char *__readline(void){ static char linebuffer[16384]; if(fgets(linebuffer, sizeof linebuffer, stdin) == NULL) linebuffer[0] = '\0'; return linebuffer; } #define nscanf(...) sscanf(__readline(), __VA_ARGS__) - COMO USAR: A função nscanf pode ser usada exatamente do mesmo modo que a função scanf , mas diferente da função scanf não ficará sobrando caracteres na entrada padrão em nenhuma situação, mesmo que o usuário não se comporte e a leitura falhe, na próxima leitura stdin já estará totalmente limpa permitindo usar nscanf novamente sem preocupações. #include <stdio.h> #include <stdlib.h> char *__readline(void){ static char linebuffer[16384]; if(fgets(linebuffer, sizeof linebuffer, stdin) == NULL) linebuffer[0] = '\0'; return linebuffer; } #define nscanf(...) sscanf(__readline(), __VA_ARGS__) int main() { int a; char b; printf("Numero: "); nscanf("%d", &a); printf("Letra: "); nscanf("%c", &b); printf("%d\n%c\n", a, b); return 0; } - COMO FUNCIONA: O funcionamento da função nscanf é simples, primeiro faz a leitura de todo o conteúdo da stdin com a função __readline , que usa fgets com um vetor/array de char "bem grande" para ler todo tudo que for digitado, e então a passa a string obtida como argumento da função sscanf para ser processada de acordo com os especificadores fornecidos na string de especificadores de formatação da função. O vetor usado na função __readline é declarado como static o que faz com que a memória fique reservada durante toda a execução do programa, não apenas durante a execução da função, permitindo retornar o ponteiro que aponta para o vetor que será usado pela função sscanf , e já que a memória é reservada permanentemente ela também pode ser reutilizada toda vez que usar a função nscanf . - DESVANTAGEM: A desvantagem óbvia de usar a função nscanf é o fato de deixar de aprender a usar a função scanf corretamente, isso pode ser um problema principalmente para alguém que é um aluno pois provavelmente vai ter que usar a função scanf durante provas e avaliações, então deve aprender como usar scanf. Então se for usar nscanf, eu recomendo que ainda assim aprenda a usar scanf , e o porquê ela pode não se comportar como você espera em certas situações, mas use nscanf para não precisar lidar com estas situações. Mas vendo isto por outro lado nscanf pode ajudar quem estiver estudando a focar em aprender a programar, ao invés de focar em aprender os comportamentos específicos de funções da linguagem C e como lidar com eles. - SOBRE AS FALHAS NA FUNÇÃO PARA PROGRAMADORES EXPERIENTES: Os programadores experientes aqui do fórum certamente vão notar que existe um problema na função __readline , pois como o vetor usado como buffer tem um tamanho fixo existe a possibilidade de que em um caso extremo seja lida uma quantidade de caracteres maior do que este tamanho, e isso causaria uma falha no funcionamento da função, e por outro lado essa pode ser uma quantidade de memória excessiva pois na grande maioria dos casos apenas uma pequena parte desse vetor será usado. Sobre este problema digo que esta versão da função __readline é propositalmente simples, pois é algo que poderia ser usado facilmente por um iniciante, bastando copiar um pequeno código, e adicionar um n aos scanfs usados no programa para poder usar, e é algo que um iniciante pode aprender exatamente como funciona sem muitas dificuldades. Se tiverem interesse em usar uma versão totalmente confiável da função nscanf , com uma função __readline que usa malloc para alocar a quantidade necessária de memória, eu também fiz uma versão assim, e posso postar aqui se desejarem. Espero ler seus comentários e criticas sobre a função nscanf... Existem problemas que eu não detectei? Situações que a tornariam pior do que a função scanf?

@Jorge Curvelo Basta não usar inicializadores designados... #include <windows.h> int main() { /*Mover mouse para o centro da tela*/ MOUSEINPUT m1; m1.dx=32768; m1.dy=32768; m1.mouseData=0; m1.dwFlags=MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE; m1.time=0; /*Clicar com o botão direito do mouse*/ MOUSEINPUT m2; m2.dwFlags=MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_RIGHTUP; m2.time=0; /*Vetor de entradas para juntar as ações do mouse:*/ INPUT in[2]; in[0].type=INPUT_MOUSE; in[0].mi=m1; in[1].type=INPUT_MOUSE; in[1].mi=m2; /*Realiza as ações de entrada do mouse:*/ SendInput(2, in, sizeof *in); return 0; } Tá usando qual IDE? Que compilador? No GCC só to conseguindo gerar esse tipo de warning se eu configurar para compilar seguindo o bem antigo padrão C90 da linguagem.

@Jorge Curvelo #include <windows.h> int main() { //Mover mouse para o centro da tela MOUSEINPUT m1 = (MOUSEINPUT){.dx=32768, .dy=32768, .mouseData=0, .dwFlags=MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE, .time=0}; //Clicar com o botão direito do mouse MOUSEINPUT m2; m2.dwFlags=MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_RIGHTUP; m2.time=0; //Vetor de entradas para juntar as ações do mouse: INPUT in[2]; in[0]=(INPUT){.type=INPUT_MOUSE, .mi=m1}; in[1].type=INPUT_MOUSE; in[1].mi=m2; //Realiza as ações de entrada do mouse: SendInput(2, in, sizeof *in); return 0; } Foram usados: SendInput() INPUT MOUSEINPUT