arfneto

Olá Espero que tenha progredido com o programa Vou te mostrar um exemplo aqui que pode ajudar a entender o comportamento de scanf(). Essa função, como o nome diz, tem essa característica de "scan" e é um inferno muitas vezes porque é usada com um propósito diferente, E ela come caracteres, dá problemas com fim de linha e não retorna e tal Exemplo: Como no seu programa, ler dois números, mas de um modo civilizado E usando scanf(). Em muitos casos se lê a linha todinha como string e trata no programa, mas mudar a técnica não é exatamente uma solução então vou te mostrar uma possibilidade mantendo scanf(). O que se pode fazer é ler o primeiro número, um caracter, o segundo número e outro caracter. Assim scanf() consome o que tiver no caminho e você pode testar o que tinha lá. Por simplicidade vamos chamar os dois char de meio e fim e ler assim n = scanf("%lf%c%lf%c", &valor1, &meio, &valor2, &fim); Note que scanf() devolve o número de ítens lidos e esperamos claro ler 4. Teste 1 Entre com os dois valores separados por espaco ou TAB . Tecle ENTER ao terminar Valores: 1a2.1y scanf() leu 4 itens scanf() valor1 = 1.000000 no meio veio algo com codigo 97 = 'a' scanf() valor2 = 2.100000 no final veio algo com codigo 121 = 'y' scanf() foi escrita com esse propósito, scan, e ela então le o 'a' como separador meio e o y como separador fim e pega os valores certinho Teste 2 Entre com os dois valores separados por espaco ou TAB . Tecle ENTER ao terminar Valores: 1.23 -2.8 scanf() leu 4 itens scanf() valor1 = 1.230000 no meio foi um TAB scanf() valor2 = -2.800000 no final foi um fim de linha \n Esse mais parecido com o seu problema, usei 1.23 depois um TAB e o -2.8 e teclei ENTER. scanf() leu o meio como TAB e o final como \n como esperado Teste 3 Entre com os dois valores separados por espaco ou TAB . Tecle ENTER ao terminar Valores: -1,-2 scanf() leu 4 itens scanf() valor1 = -1.000000 no meio veio algo com codigo 44 = ',' scanf() valor2 = -2.000000 no final foi um fim de linha \n Esse caso é legal: você pode separar os valores por vírgula e teclar ENTER no fim e lê certinho Espero que tenha ajudado a entender. Eis o programa. Rode em sua maquina e pense nisso. Essa função é legal mas o comportamento dela em geral não é explicado direito: o lado scan de scanf(). Minha opinião claro. Espero que ajude mais do que o que eu te expliquei ontem O Programa #define _CRT_SECURE_NO_WARNINGS #include "stdio.h" int main(int artgc, char** argv) { int n; char meio, fim; // os dois delimitadores double valor1, valor2; // os dois numeros printf("Entre com os dois valores separados por espaco ou TAB . Tecle ENTER ao terminar\n"); printf("\nValores: "); n = scanf("%lf%c%lf%c", &valor1, &meio, &valor2, &fim); // o que leu? printf("scanf() leu %d itens\n", n); // o primeiro printf("scanf() valor1 = %lf\n", valor1); // o que tinha entre oa dois switch (meio) { case '\t': printf("no meio foi um TAB\n"); break; case ' ': printf("no meio foi um espaco\n"); break; default: printf("no meio veio algo com codigo %d = '%c'\n", meio, meio); break; } // switch // o segundo printf("scanf() valor2 = %lf\n", valor2); // como terminou switch (fim) { case EOF: printf("fim de arquivo no final\n"); break; case '\t': printf("no final foi um TAB\n"); break; case '\n': printf("no final foi um fim de linha \\n \n"); break; case ' ': printf("no final foi um espaco\n"); break; default: printf("no final veio algo com codigo %d = '%c'\n", fim, fim); break; } // switch } // main

Mais tarde eu te mostro se precisar. Estou chegando na cidade e estou a toa mas só vou ter algum computador mais tarde Entendeu que são dois loops um dentro do outro? E o segundo tem um if dentro para ver se a sequência Está aumentando. Só isso

Tem um loop pra let cada linha. Vai usar aquilo apenas quando encontrar uma sequência desordenada. Ou seja, dentro do loop que le as linhas tem um loop que processa as linhas lendo até o fim da linha ou até descobrir que está fora de ordem. É nesse caso usa aquele comando pra desprezar o resto da linha

Quando precisar desprezar a linha use aquele comando

Ainda falta algo. Tem que continuar lendo na linha até 1) ela acabar ou 2) encontrar algo fora de ordem Teste primeiro com o que te mostrei

Poder escrever em uma linha só char c; do { c = fgetc(stdin);} while ( c!!='\n') ; adicionado 0 minutos depois Ou usar um #define

Em C fgetc() que é uma função, lê um carácter de um arquivo, como o teclado. Então um loop chamando fgetc() até ler um \N le até o fim da linha... adicionado 4 minutos depois Do { Char c = fgetc(stdin) ; } while (c! ='\n') ; Serve

Então... Com um valor só está ordenada por definição, certo? Sai duas linhas Sem funções vai ter que repetir o código. Mas é só um loop e só vai usar duas vezes adicionado 0 minutos depois Funções são blocos de código que você chama por um nome adicionado 2 minutos depois Pra não ter que escrever toda hora a mesma coisa. Tipo le_ate_fim_da_linha()

Escreva uma função pra ler da entrada até achar um \N. Vai precisar dela de todo modo para quando precisar desprezar o resto de uma linha desordenada Aí você chama essa função após ler o primeiro valor, o número de linhas. Isso é chato mesmo adicionado 2 minutos depois Então... Com um valor só está ordenada por definição, certo? Sai duas linhas

Algo assim 2 -1234.5678 1234.5678

Sei Aí o primeiro é negativo e seu programa já era Teste antes de tudo con duas línhas de um número só... Assim saberá que o loop está ok

Mas tem que continuar lendo até : acabar a linha ou achar um elemento menor E n2 tem que começar bem pequeno ou leia o primeiro da linha fora do loop

Imprimiu os valores conforme lê pra conferir se está lendo certo? adicionado 1 minuto depois Porque le dos valores inicialmente? adicionado 2 minutos depois :D lli errado. Esqueça

Olá Não precisa de vetor nem nada. Apenas marque ao iniciar cada linha: Enquanto estiver aumentando o valor lido tudo certo, pode ser que esteja ORDENADA Ao ler um fim de linha então está ORDENADA e tenta ler outra Mas se encontrou na linha um valor menor que o anterior, imprime DESORDENADA e continua lendo e desprezando o que tiver até o fim da linha. E tenta ler outra

Olá Leia as dimensões X e Y, use um loop externo para a linha Y, um interno para X e leia o caracter correspondente à posição. (X,Y)

A teoria por detrás das duas e a mesma, mas na pratica uma não tem nada a ver com a outra. Esse não é mesmo um forum sobre estrutura de dados, mas mesmo em se falando da implementação em alguma linguagem que não tenha suporte embutido, o conhecimento mínimo para implementar uma estrutura de árvore nada tem a ver com o necessário para implementar uma lista encadeada. Lembro que se usar um Heap para implementar uma árvore sequer usará ponteiros. Nem a teoria é a mesma: uma árvore tem um conceito bem distinto. Existe a noção de raiz, a noção de pai e a noção de níveis. E existe o mecanismo de rotação de nós. Uma lista é só isso: uma lista com acesso ao próximo e ao anterior elemento na estrutura. E um endereço de início.

Olá! Acho que deve procurar o simples: no início do programa abre um possível arquivo de cadastro já existente e carrega em uma estrutura de dados direto na memória. Processa tudo a partir dessa estrutura e ao final grava um novo arquivo em disco. Muda o nome do antigo para .back ou algo assim. E renomeia o novo para o nome oficial. Assim tem acesso ao menos a um arquivo anterior e tem menos problemas com os dados. Conhece alguma estrutura de dados, tipo lista, arvore, fila de prioridade, heap? uma simples lista de ponteiros talvez?

E aí? Progresso com o programa? Estive pensando nisso agora e recomendo gravar os números ao contrário no vetor, o dígito menos significativo primeiro pra facilitar as operações aí usa acho que um loop só e menos contas de índices.

Como eu te disse, isso é absolutamente comum. Como sabe que está errado? @marechalmelo você entendeu o que falei sobre esse troço de packing? uEu acho que não ficou claro porque você não respondeu e por outro lado @KXSY achou que eu estava recomendando um compilador. Vou explicar melhor e mostrar um exemplo. Tenha paciência Preciso perguntar o que fez pra ter certeza que seu problema é gravar. O que está fazendo para ler? Se tem um erro na leitura pode achar que gravou errado... De qualquer forma, use fread() para ler e fwrite() para gravar e estará bem. Nem me passou pela cabeça recomendar um compilador porque não tem nada a ver com a discussão; E por outro lado escolher um compilador ou a linguagem muitas vezes não é afinal nossa opção. Patrões e clientes não costumam dar essa opção, escolas também não. Muitas universidades usam Python para cursos de introdução e para análise de dados, mas outras preferem R. Cursos de estruturas de dados são em geral voltados a linguagem que a escola prefere, seja C++, C ou java ou Pascal ou sei lá. Meus primeiros cursos de análise numérica eram voltados a FORTRAN e ponto final, por exemplo. De volta ao tópico Escrevi um programa para ajudar a entender do que estou falando Veja sua estrutura criar_Hotel: typedef struct criar_Hotel { // declara todas as variaveis do cadastro dos dados do hotel // char PRINCIPIO; char nome_social[100]; char razao_social[100]; char inscricao_estadual[100]; float cnpj; char endereco[100]; char MEIO; float telefone; char email[100]; char nome_dono[100]; float telefone_dono; float horario_chegar; float horario_sair; float lucro_produtos_vendidos; char FIM; // } criar_Hotel; Eu inseri 3 caracteres, PRINCIPIO, MEIO e FIM como pode ver. E vou gravar isso em disco e ler depois pra você entender. Isso está além do que se usa nesses exercícios de curso, mas é o dia a dia quando você precisa criar ou ler arquivos que foram gerados em outro lugar por outros sistemas. Imagino que já tenha olhado isso, mas se olhar sua estrutura vai ver que tem 6 vetores de 100 bytes 6 float que podem ter 4 ou 8, e eu coloquei 3 char de um byte provavelmente. Isso soma 624 bytes mais os 3 que inventei, 627. Vou gravar esses 3 caracteres [|] no inicio no meio e no fim de cada struct porque assim podemos conferir na leitura se permanece alinhado. Sim, é um teste besta Esse é o programa de teste int main(int argc, char** argv) { printf("sizeof(criar_Hotel) = %d sizeof(float) = %d\n", sizeof(criar_Hotel), sizeof(float)); cria("hoteis.xyz", 2); cria("hoteis.xyz", 4); le("hoteis.xyz"); cria("mais-hoteis.xyz", 10); le("mais-hoteis.xyz"); return 0; } E uso essas funções: int cria(char*, int); criar_Hotel* fabrica(); int le(char*); cria() faz o simples: abre o arquivo em modo "a" e grava n structs cria_Hotel bem bonitinhas, numeradas para a gente poder ver se algo se perdeu. E com aqueles delimitadores [ e ] no inicio e no fim e o | la pelo meio le() abre o arquivo e le de volta todas as structs e ve se os delimitadores estão no lugar. Eis o que ela mostra para esse trecho de main() com hoteis.txt vazio inicialmente: cria("hoteis.xyz", 2); cria("hoteis.xyz", 4); le("hoteis.xyz"); Mostra le(hoteis.xyz) Arquivo de entrada com 3816 bytes, ao menos 6 structs 1: Leu 'Nome Social 001', [|] = '[' '|' ']' 2: Leu 'Nome Social 002', [|] = '[' '|' ']' 3: Leu 'Nome Social 003', [|] = '[' '|' ']' 4: Leu 'Nome Social 004', [|] = '[' '|' ']' 5: Leu 'Nome Social 005', [|] = '[' '|' ']' 6: Leu 'Nome Social 006', [|] = '[' '|' ']' todos os delimitadores OK! Como funciona? Antes de tudo, vê o tamanho do arquivo e divide pelo tamanho da struct, porque assim você pode ter uma ideia de quantas alocar no início de seu programa. Recomendo usar uma outra estutura de dados e não um vetor, mas é seu programa e seria outra discussão. Como vê essa está ok: inserimos 2 e depois 4 e o tamanho está ok. e ao ler cada registro testamos os 3 caracteres [|] pra ver se estão lá. no final a função confirma se todos estavam ok, começando por '[' terminando por ']' e tal. As structs são geras com nomes fixos,mas numerados por exemplo "Nome Social NNN" porque assim fica óbvio algum problema: Elas são numeradas, tem um começo [ e um fim ] determinados e ninguém precisa ficar digitando p#$$@ nenhuma. Pode chamar cria("muitoshoteis.abc", 999) e testar um bom número. Como grava as struct{} for (int i = 0; i < q; i += 1) { criar_Hotel* hotel = fabrica(); n = fwrite(hotel, size, 1, hoteis); free(hotel); } Onde q é o parâmetro de quantidade. fwrite() grava uma por vez. E a função fabrica() faz a gentileza de alocar um registro preenchido certinho a cada chamada assim o loop fica mais legível. E as contas com o tamanho? stat(arquivo, &info); printf("Arquivo %s fechado com %d bytes, ao menos %d structs\n", arquivo, info.st_size, info.st_size/size); Simples: Vê o tamanho do arquivo divide pelo tamanho da estrutura e mostra. E essa fabrica() é assim criar_Hotel* fabrica() { static int id = 0; criar_Hotel* h = (criar_Hotel*)malloc(sizeof(criar_Hotel)); if (h == NULL) return NULL; id += 1; h->PRINCIPIO = '['; h->MEIO = '|'; h->FIM = ']'; sprintf(h->nome_social, "Nome Social %03d", id); sprintf(h->razao_social, "Razao Social %03d", id); sprintf(h->inscricao_estadual, "Inscricao Estadual %03d", id); h->cnpj = (float)id; h->endereco[0] = 0; h->telefone = (float)id; h->email[0] = 0; h->nome_dono[0] = 0; h->telefone_dono = (float)id; h->horario_chegar = (float)id; h->horario_sair = (float)id; h->lucro_produtos_vendidos = (float)id; return h; } // end fabrica() Coloca os delimitadores, gera o registro todo preenchido e retorna. Bem melhor que ficar 5 minutos na tela do programa pra digitar 5 hoteís. Rodando esse main() e tentando chegar a alguma conclusão. Eis a saída: sizeof(criar_Hotel) = 636 sizeof(float) = 4 cria(hoteis.xyz,2) Arquivo hoteis.xyz fechado com 1272 bytes, ao menos 2 structs cria(hoteis.xyz,4) Arquivo hoteis.xyz fechado com 3816 bytes, ao menos 6 structs le(hoteis.xyz) Arquivo de entrada com 3816 bytes, ao menos 6 structs 1: Leu 'Nome Social 001', [|] = '[' '|' ']' 2: Leu 'Nome Social 002', [|] = '[' '|' ']' 3: Leu 'Nome Social 003', [|] = '[' '|' ']' 4: Leu 'Nome Social 004', [|] = '[' '|' ']' 5: Leu 'Nome Social 005', [|] = '[' '|' ']' 6: Leu 'Nome Social 006', [|] = '[' '|' ']' todos os delimitadores OK! cria(mais-hoteis.xyz,10) Arquivo mais-hoteis.xyz fechado com 6360 bytes, ao menos 10 structs le(mais-hoteis.xyz) Arquivo de entrada com 6360 bytes, ao menos 10 structs 1: Leu 'Nome Social 007', [|] = '[' '|' ']' 2: Leu 'Nome Social 008', [|] = '[' '|' ']' 3: Leu 'Nome Social 009', [|] = '[' '|' ']' 4: Leu 'Nome Social 010', [|] = '[' '|' ']' 5: Leu 'Nome Social 011', [|] = '[' '|' ']' 6: Leu 'Nome Social 012', [|] = '[' '|' ']' 7: Leu 'Nome Social 013', [|] = '[' '|' ']' 8: Leu 'Nome Social 014', [|] = '[' '|' ']' 9: Leu 'Nome Social 015', [|] = '[' '|' ']' 10: Leu 'Nome Social 016', [|] = '[' '|' ']' todos os delimitadores OK! Note que o sistema reporta 636 como tamanho da struct... E era pra ter 600 + 24 + 3 = 627 se não errei na conta... Acho que afinal entendeu o problema. E porque expliquei sobre o padding ou packing ou alinhamento ou sei lá como chamam isso em seu sistema. E foi por isso que perguntei sobre o compilador e tal. E mostrei a diretiva #pragma pack() com exemplo, e não fui muito claro, a ponto de @KXSY achar que eu estava recomendando o compilador que eu uso. Se você gravar em um sistema e tentar ler em outro vai ter claro problemas. Eis o programa todo: #define _CRT_SECURE_NO_WARNINGS #define MODO_DE_GRAVACAO "a" #include <stdio.h> #include <stdlib.h> #include <string.h> #include "sys/stat.h" typedef struct criar_Hotel { // declara todas as variaveis do cadastro dos dados do hotel // char PRINCIPIO; char nome_social[100]; char razao_social[100]; char inscricao_estadual[100]; float cnpj; char endereco[100]; char MEIO; float telefone; char email[100]; char nome_dono[100]; float telefone_dono; float horario_chegar; float horario_sair; float lucro_produtos_vendidos; char FIM; // } criar_Hotel; int cria(char*, int); criar_Hotel* fabrica(); int le(char*); int main(int argc, char** argv) { printf("sizeof(criar_Hotel) = %d sizeof(float) = %d\n", sizeof(criar_Hotel), sizeof(float)); cria("hoteis.xyz", 2); cria("hoteis.xyz", 4); le("hoteis.xyz"); cria("mais-hoteis.xyz", 10); le("mais-hoteis.xyz"); return 0; } int cria(char* arquivo, int q) { FILE* hoteis = fopen(arquivo, MODO_DE_GRAVACAO); struct stat info; int n; const int size = sizeof(criar_Hotel); printf("cria(%s,%d)\n", arquivo, q); for (int i = 0; i < q; i += 1) { criar_Hotel* hotel = fabrica(); n = fwrite(hotel, size, 1, hoteis); free(hotel); } fclose(hoteis); stat(arquivo, &info); printf("Arquivo %s fechado com %d bytes, ao menos %d structs\n", arquivo, info.st_size, info.st_size / size); return 0; } // end cria() criar_Hotel* fabrica() { static int id = 0; criar_Hotel* h = (criar_Hotel*)malloc(sizeof(criar_Hotel)); if (h == NULL) return NULL; id += 1; h->PRINCIPIO = '['; h->MEIO = '|'; h->FIM = ']'; sprintf(h->nome_social, "Nome Social %03d", id); sprintf(h->razao_social, "Razao Social %03d", id); sprintf(h->inscricao_estadual, "Inscricao Estadual %03d", id); h->cnpj = (float)id; h->endereco[0] = 0; h->telefone = (float)id; h->email[0] = 0; h->nome_dono[0] = 0; h->telefone_dono = (float)id; h->horario_chegar = (float)id; h->horario_sair = (float)id; h->lucro_produtos_vendidos = (float)id; return h; } // end fabrica() int le(char* arquivo) { FILE* hoteis = fopen(arquivo, "r"); criar_Hotel hotel; struct stat info; int n; int ok = 0; int seq = 0; const int size = sizeof(criar_Hotel); stat(arquivo, &info); printf("\n\nle(%s)\nArquivo de entrada com %d bytes, ao menos %d structs\n", arquivo, info.st_size, info.st_size / size); while (1) { seq += 1; n = fread(&hotel, size, 1, hoteis); if (n <= 0) break; printf("%4d: Leu '%s', [|] = '%c' '%c' '%c'\n", seq, hotel.nome_social, hotel.PRINCIPIO, hotel.MEIO, hotel.FIM); if (hotel.PRINCIPIO != '[' || hotel.MEIO != '|' || hotel.FIM != ']') ok = 1; } // end while if (ok == 1) printf("PROBLEMA com alinhamento\n"); else printf("todos os delimitadores OK!\n"); fclose(hoteis); return 0; } // end le() E agora? Na mesma maquina não deve ter problema, mas o certo é fazer o que eu disse e identificar o comando que define o padding como 1 byte. Isso existe por uma questão de eficiência. De todo modo o que está nesse programa e nessa discussão resolve o seu problema. Escreva de volta e mostre seu programa como ficou! Muda algo com pack = 1 mesmo? Pois é: veja a mesma execução definindo pack para 1 sizeof(criar_Hotel) = 627 sizeof(float) = 4 cria(hoteis.xyz,2) Arquivo hoteis.xyz fechado com 1254 bytes, ao menos 2 structs cria(hoteis.xyz,4) Arquivo hoteis.xyz fechado com 3762 bytes, ao menos 6 structs

Olá O termo para o que você quer fazer é serialização --- serialization --- e é muito muito comum. Em maior ou menor alcance quase todos os programas tem que fazer algo assim. Nem que seja apenas para buscar informações de configuração, última posição na tela, dados de usuário ou o último arquivo aberto. Não descreveu os problemas que está tendo com sua solução. Mas o problema mais comum está no fato do sistema inserir bytes de alinhamento --- packing --- na gravação da estrutura e depois na hora de ler pode e fica desalinhado e portanto inútil. Você não disse o compilador que está usando. O que eu geralmente uso --- Microsoft Visual Studio --- tem uma instrução #pragma que resolve isso. Não sei se é igual em outros compiladores, faz tempo que não uso C ou C++ em outro ambiente. Você precisa se certificar que esse recurso, packing, está desativado e que vai gravar a struct byte a byte. Ou então saber o padrão de sua máquina --- par, ímpar, múltiplo de algo --- para gravar de acordo. No caso da Microsoft você usa #pragma pack(push, 1) e aí ele passa a gravar byte a byte e depois #pragma pack(pop) para voltar ao que estava antes. Sim, é usada uma estrutura tipo pilha --- stack. Em geral é isso que causa problemas. Recomendo esquecer esse lance de seek() porque é outro pesadelo. Pense como nase classes em C++: você cria um construtor para suas struct e um destrutor: No inicio do processamento das structs você abre o arquivo, lê todo mundo e carrega sua estrutura de dados No final você cria um arquivo novo e grava tudo Depois que terminou e deu tudo certo você renomeia o antigo para algo como .back ou põe um ponto na frente do nome no caso de Unix e derivados Depois você finalmente muda o nome do arquivo novo para o nome original, já com tudo garantido Trabalhar ao vivo com o arquivo de dados e em especial atualizar o arquivo na execução não vale o risco Se o volume de dados é muito grande para carregar na estrutura na memória meu primeiro palpite seria o que todo mundo faz: usar um banco de dados. E não por acaso SQLite é provavelmente o programa de computador mais usado no mundo, dentre todas as categorias: grátis, sólido, continuamente atualizado e rápido pra *****. E funciona em qualquer sistema e em qualquer linguagem. Não perca tempo testando isso no meio de seu programa. Faça um pequeno programa que cria umas estruturas, grava e tenta ler de volta, e poste aqui os resultados

Talvez pudesse postar o teu programa como está agora e uma descrição do que está saindo errado

Como está aí: a ideia é simples: um vetor de 1000 dígitos, que você pode representar de qualquer maneira. E cria uma função para somar e outra para mostrar e tal. Naturalmente nenhum tipo primitivo daria uma representação precisa para 1000 dígitos. Um byte vai até 255 por exemplo, nem 3 dígitos.Pode ver os limites em <climits> ou limits.h Em resumo O que se faz é só fazer as contas como se faz no papel, mas com até 1000 dígitos e armazenando os resultados no vetor. Soma, quando passa de 10 "vai um" e passa pro próximo dígito e tal. Como no primário Esses são os primeiros 6 números da sequência 1, 1, 2, 3, 5, 8. Para calcular o sétimo 05 08 + 13 Sem pensar muito, com vetores char P1[1000]; char P2[1000]; char T [1000]; pode simular as operações. Vai somando dígito a dígito a partir da direita como faz no papel. Só isso. Quando chegar no primeiro zero a esquerda pode parar claro: 5 + 8 = 13 então T[999] = 3 e T[998] = 1. E por aí vai. Pode ir gravando a partir do índice zero também claro. Escolha a lógica que te parecer melhor. Na hora de imprimir mostra os dígitos grudadinhos e pronto. Eu agruparia tipo 40 ou 50 dígitos por linha pra ficar mais organizado e não como no programa que mostrou Isso eu não entendo. A entrada era pra ser um número entre 1 e 1000 para mostrar o valor de Fib(n)

@emanuelrichard Considerando esse enunciado bem objetivo e que eu não tinha lido... Imagino que o instrutor esperava ver algo assim: VALOR 0 1 0 1 1 0 0 1 bit 7 6 5 4 3 2 1 0 decimal 128 64 32 16 8 4 2 1 64 + 16 + 8 + 1 = 89 E então mostraria isso 0 1 0 1 1 0 0 1 89 Esse programa minimalista em C++ #include <iostream> int main(int argc, char** argv) { int b7, b6, b5, b4, b3, b2, b1, b0; std::cin >> b7 >> b6 >> b5 >> b4 >> b3 >> b2 >> b1 >> b0; b0 = (b7<<7) + (b6<<6) + (b5<<5) + (b4<<4) + (b3<<3) + (b2<<2) + (b1<<1) + b0; std::cout << b0 << std::endl; return 0; } Ou este em C #include "stdio.h" int main(int argc, char** argv){ int b7, b6, b5, b4, b3, b2, b1, b0; scanf("%d %d %d %d %d %d %d %d", &b7, &b6, &b5, &b4, &b3, &b2, &b1, &b0); b0 = (b7 << 7) + (b6 << 6) + (b5 << 5) + (b4 << 4) + (b3 << 3) + (b2 << 2) + (b1 << 1) + b0; printf("%d\n", b0); } Usando as variáveis com os nomes óbvios das posições dos bits e os operadores de deslocamento dos bits para colocar os valores nas posições corretas. E então somando. Veja que em C++ justamente esses operadores << e >> foram redefinidos para a classe stream como operadores de inserção, e isso dá ao programa em C++ um aspecto curioso para dizer o mínimo. Os mesmos operadores em cin e cout tem outro uso

Olá! Já fez algo para testar seu cabo e a conexão serial?

Olá Está certo de usar nome sexo e endereço com uma única letra? char é isso.