Página 2 de 2 PrimeiroPrimeiro 12
+ Responder ao Tópico



  1. Cara ainda tô meio viajando. Esse eu tô quase abandonando já, hehehe.
    Olha só até onde fiz (acredito que está completamente equivocado esse código):
    Código :
    #include <stdio.h>
    #include <stdlib.h>
     
    int main()
    {
        FILE *fp;       /* Declaração da estrutura */
        //char c;
        char byte1;
        char byte2;
        char byte3;
        char parte_byte1;
        char parte_byte2;
        char parte_byte3;
        char primeiro_base64;
        char segundo_base64;
        char terceiro_base64;
        int end_flag = 1;
        //int vetor[];
     
        fp=fopen ("origem.txt","r+");    /* o arquivo se chama origem.txt e está localizado no diretório corrente */
     
        if(!fp)
        {
            printf( "Erro na abertura do arquivo");
            exit(0);
        }
        //while((c = fgetc(fp) ) != feof)   /* Enquanto não chegar ao final do arquivo */
        //   printf("%c", c);                    /* imprime o caracter lido */
        //fclose(fp);
        //return 0;
     
        while(end_flag)
        { 
            /* Lendo Byte 1*/
            byte1 = getc(fp);
            if (byte1 == EOF)
                    end_flag = 0; 
     
            /* Lendo Byte 2*/
            if (end_flag)
            {
                byte2 = getc(fp);
                    if (byte2 == EOF)
                {
                    printf("Arquivo nao multiplo de 3.");
                    end_flag = 0; 
                }
            }
     
            /* Lendo Byte 3*/
            if (end_flag)
            {
                    byte3 = getc(fp); 
                    if (byte3 == EOF)
                {
                            printf("Arquivo nao multiplo de 3.");
                        end_flag = 0; 
                }
            }
        }
        fclose(fp);
     
        //tratamento do byte1
        parte_byte1 = byte1 & 00000011;
        primeiro_base64 = byte1 >> 2; //01111001
     
        //tratamento do byte2
        parte_byte2 = byte2 >> 4; // 00001010
        //juntando byte 1 e byte 2
        parte_byte1 = parte_byte1 << 4;
        segundo_base64 = parte_byte1 | parte_byte2;
     
         //tratamento do byte3
        parte_byte3 = byte3 >> 8; // 00000000
        //juntando byte 1 e byte 2
        parte_byte1 = parte_byte1 << 8;
        terceiro_base64 = parte_byte1 | parte_byte3;
     
        //Conversão chars -> ASCII
        if (primeiro_base64 >= 0) & (primeiro_base64 <=25)
        {
     
        }
    }

  2. Putz cara... É a primeira vez que você programa??

    Cara, ta mastigado agora...
    Código :
    #include <stdio.h>
    #include <stdlib.h>
     
    FILE *fp;
    int loop_flag = 1;
     
    char read_char(void){
        char byte;
        if (loop_flag){
            byte = getc(fp);
            if (byte == EOF){
                byte = 0;
                loop_flag = 0;
            }
        }else{
            byte = 0;
        }
     
         return byte;
    }
     
    char ascii_decode(unsigned char base64){
         if (base64 < 26){
             base64 = base64 + 65;
         }else if (base64 < 51){
             base64 = base64 - 26 + 97;
         }else if (base64 < 62){
             base64 = base64 - 52 + 48; 
         }else if (base64 == 62){
             base64 = 43;
         }else if (base64 == 63){
             base64 = 47;
         }
         return base64;
    }
     
    int main()
    {
        unsigned char byte1;
        unsigned char byte2;
        unsigned char byte3;
        unsigned char tmp1;
        unsigned char tmp2;
        unsigned char base64_1;
        unsigned char base64_2;
        unsigned char base64_3;
        unsigned char base64_4;
     
        fp=fopen ("base64.txt","r+");    /* o arquivo se chama origem.txt e está localizado no diretório corrente */
     
        if(!fp)
        {
            printf( "Erro na abertura do arquivo");
            exit(0);
        }
     
        while(loop_flag)
        { 
            /* Lendo Byte 1*/
            byte1 = read_char();
            byte2 = read_char();
            byte3 = read_char();
     
            /* Processando primeiro base64 */
            printf("Processando: %c (%i)| ", byte1, byte1); //0110 0010 (98)
            base64_1 = byte1 >> 2; // 0001 1000 (24)
     
            /* Processando segundo base64 */
            printf("%c (%i)| ", byte2, byte2); //0110 0011 (99)
            tmp1 = byte1 & 3; // 0000 0010
            tmp1 = tmp1 << 4; // 0010 0000
            tmp2 = byte2 >> 4; // 0000 0110
            base64_2 = tmp1 | tmp2; // 0010 0110 (38)
     
            /* Processando terceiro base64 */
            printf("%c (%i).\n", byte3, byte3); //0110 0100 (100)
            tmp1 = byte3 >> 6; // 0000 0001
            tmp2 = byte2 & 15; // 0110 0011 & 0000 1111
            tmp2 = tmp2 << 2; // 0000 1100
            base64_3 = tmp1 | tmp2; // 0000 1101 (13)
     
            /* Processando quarto base64 */
            base64_4 = byte3 >> 2; // 0001 1001 (25)
     
            /* Saída */
            base64_1 = ascii_decode(base64_1);
            base64_2 = ascii_decode(base64_2);
            base64_3 = ascii_decode(base64_3);
            base64_4 = ascii_decode(base64_4);
            printf("\tOutput base 64: %c | %c | %c | %c\n", base64_1, base64_2, base64_3, base64_4);
        }
    }
    Jogar essa saída pra um arquivo você consegue??

    Até mais...



  3. Tente quebrar o problema em pedaços. Depois, tente quebrar os pedaços em pedaços menores. Anote tudo na devida ordem, e tente resolver cada uma dessas partes. Tudo parecerá/será muito mais simples.

    Caso tenha dúvidas, utilize google, wikipedia, e principalmente o fórum de programação C.

    Segue minha contribuição:

    Código :
    #include <stdio.h>
    #include <string.h>
     
    #define DEBUG
    #define FILE_OUT	stdout
     
    #define SIZE_IN		3
    #define SIZE_OUT	4
     
    void fprintbits(FILE *fp, char c) {
    	int i, mask;
    	for(i=7; i>=0; i--)
    		fputc((c & (1 << i)) == 0 ? '0' : '1', fp);
    }
     
    int main(int argc, char **argv) {
    	FILE *fp;
    	int filesize, i;
    	char buffer_in[SIZE_IN];
    	char buffer_out[SIZE_OUT];
     
    	// Abre o arquivo
    	fp = fopen("origem.txt", "r");
    	if (ferror(fp)) {
    		perror("erro ao abrir arquivo\n");
    		return 2;
    	}
     
    	// Verifica o tamanho do arquivo
    	fseek(fp, 0, SEEK_END);
    	filesize = ftell(fp) - 1;
    	if (filesize % SIZE_IN) {
    		fprintf(stderr, "tamanho de arquivo invalido\n");
    		return 2;
    	}
    	rewind(fp);
     
    	// Loop de leitura do arquivo
    	while (1) {
    		// Le N bytes
    		if (fread(buffer_in, 1, SIZE_IN, fp) != SIZE_IN)
    			break;
     
    		// Processa os dados
    		// (111100|00) (1010|1010) (00|001111)
    		buffer_out[0] = buffer_in[0] >> 2;
    		buffer_out[1] = (buffer_in[0] & 0x3) << 4 | buffer_in[1] >> 4;
    		buffer_out[2] = (buffer_in[1] & 0xF) << 2 | (buffer_in[2] & 0xC0) >> 6;
    		buffer_out[3] = buffer_in[2] & 0x3F;
    #if DEBUG
    		// Mostra os dados na tela
    		fprintf(FILE_OUT, "IN:\n"); 
    		for (i=0; i<SIZE_IN; i++) {
    			fprintbits(FILE_OUT, buffer_in[i]);
    			fprintf(FILE_OUT, "\n");
    		}
    		fprintf(FILE_OUT, "OUT:\n"); 
    		for (i=0; i<SIZE_OUT; i++) {
    			fprintbits(FILE_OUT, buffer_out[i]);
    			fprintf(FILE_OUT, "\n");
    		}
    #endif
     
    		// E aqui voce processa os bytes de buffer_out…
    	}
     
    	// Fecha o arquivo
    	fclose(fp);
     
    	return 0;
    }
    Última edição por jweyrich; 09-09-2009 às 23:21.

  4. Galera, foi mal.

    Pensei que seria fácil para mim, iniciante em C, desenvolver esse programa já que a lógica é relativamente simples (o fluxo foi fácil de fazer). Mas esbarrei na minha falta de conhecimento de vários comandos e funções da linguagem.
    Por isso, vou me atentar agora a programa mais de início de linguagem mesmo, como fatoriais e médias pra me adaptar, depois tento fazer exercícios mais complexos.
    Grato a todos que ajudaram e desculpem o transtorno.
    Valeu.



  5. Não desanima não cara!! Aos poucos vc pega o jeito! Tenta começar com uma linguagem mais light. C é uma ótima linguagem, mas exige muito do programador.

    Eu começei programando em C, inclusive fazia muito tempo que não a utilizava, mas certas coisas eu fariam em outra linguagem.

    Até mais...






Tópicos Similares

  1. Duvidas Modem Speedy..?
    Por no fórum Servidores de Rede
    Respostas: 1
    Último Post: 04-09-2002, 18:34
  2. Dúvidas Path.
    Por no fórum Servidores de Rede
    Respostas: 1
    Último Post: 21-08-2002, 08:52
  3. Duvidas Ipchains / Iptables!!!
    Por no fórum Servidores de Rede
    Respostas: 2
    Último Post: 20-08-2002, 14:39
  4. Limitar o logon e outra duvida ..
    Por MarcelScan no fórum Servidores de Rede
    Respostas: 1
    Último Post: 28-07-2002, 14:35
  5. Limitar o logon e outra duvida ..
    Por MarcelScan no fórum Servidores de Rede
    Respostas: 1
    Último Post: 24-07-2002, 20:45

Visite: BR-Linux ·  VivaOLinux ·  Dicas-L