Fiz uma lista dinamica e quero salvar em um arquivo bin mais n estou conseguindo

48rneves15 · 13 de maio de 2016

///---------------------------estrutura de cadastro de funcionarios--------------
struct Cad_funcionario{
int codigo;
char nome[50];
int idade;
char sexo;
char endereco[50];
char cidade[50];
char estado[50];
int cep;
char cargo[50];
float salario;
char email[50];
int fone;

struct Cad_funcionario *prox;

};
typedef struct Cad_funcionario cadastro;

///-------------Declarando o arquivo e seu ponteiro-----------
FILE *cad_arq;

///-------------Obs função contém erros--------
///---------Função salvar no arquivo "dados.bin"------------
void salvar_arq(cadastro *cad_fun){

cad_arq=fopen("dados.bin","ab");
if(cad_arq==NULL){
printf("Destino do arquivo inexistente!\n");
getche();
system("cls");
menu();
}

while(cad_fun){
fwrite(&cad_fun,sizeof(cadastro),1,cad_arq);///grava o arquivo
}
fclose(cad_arq);///fecha o arquivo

}
///------------Obs função contém erros---------------
///--------------Função ler o arquivo "dados.bin"-------------
void ler_arq(cadastro *cad_fun){
cad_arq=fopen("dados.bin","ab");
if(cad_arq==NULL){
printf("Destino do arquivo inexistente!\n");
getche();
system("cls");
menu();
}
if(!cad_fun){
printf("Sem arquivo!\n");
return ;
}
cadastro *tmp;
while(!feof(cad_arq)){ ///ler ate o ultimo elemento do arquivo
fread(&cad_fun,sizeof(cadastro),1,cad_arq);
printf("\t\tCÓDIGO: %d\n",tmp->codigo);
printf("Nome: %s\n",tmp->nome);
printf("Idade: %d\n",tmp->idade);
printf("Sexo: %c\n",tmp->sexo);
printf("Endereço: %s\n",tmp->endereco);
printf("Cidade: %s\n",tmp->cidade);
// if(1!=fread(cad_fun,sizeof(cadastro),1,cad_arq)){

// }
}
fclose(cad_arq);
}

///-------------função alocação de novo elemento na memória "INSERIR"------------
void inserir_novo(cadastro *cad_fun){
cadastro *novo_cad=(cadastro *)malloc(sizeof(cadastro));
if(!novo_cad){
printf("Sem memória disponível!\n");
getche();
exit(1);
}else{
printf(" \n Entre com os dados do funcionário\n");
printf(" \n\t\tCÓDIGO: ");
scanf("%d",&novo_cad->codigo);fflush(stdin);
puts("\nNome: ");
gets(novo_cad->nome);fflush(stdin);
puts("Idade: ");
scanf("%d",&novo_cad->idade);fflush(stdin);
puts("Sexo [M/F]: ");
scanf("%c",&novo_cad->sexo);fflush(stdin);
puts("Endereço: ");
gets(novo_cad->endereco);fflush(stdin);
puts("Cidade: ");
gets(novo_cad->cidade);fflush(stdin);
puts("Estado: ");
gets(novo_cad->estado);fflush(stdin);
puts("Cep: ");
scanf("%d",&novo_cad->cep);fflush(stdin);
puts("Cargo: ");
gets(novo_cad->cargo);fflush(stdin);
puts("Salário: ");
scanf("%f",&novo_cad->salario);fflush(stdin);
puts("E-mail: ");
gets(novo_cad->email);fflush(stdin);
puts("Celular: ");
scanf("%d",&novo_cad->fone);fflush(stdin);

///-------------------aqui abaixo está a função de salvar no arquivo----------
salvar_arq(cad_fun);///----------------chama função salvar no arquivo-----

system("cls");
puts("\n\t\tSalvo com Sucesso!\n\n");
getchar();

cadastro *aux=cad_fun->prox;

cad_fun->prox=novo_cad;
novo_cad->prox=aux;
}
}

///-----------------------função exibe lista completa-----------------
void exibe_cad(cadastro *cad_fun){

if(vazia(cad_fun)){
printf("\n\tNENHUM FUNCIONÁRIO CADASTRADO!\n\n");
getchar();
system("cls");
return ;
}

cadastro *tmp;///----------deefinindo um ponteiro temporário do tipo nó
tmp=cad_fun->prox;
printf("\n\t Listando Todos os Cadastros \n\n");
while(tmp!=NULL){///verifica se o ptr do tipo nó é diferente de nulo
///------------Exibe lista com todos os elementos cadastrados
printf("\n----------------------------------- ");
printf("\t\tCÓDIGO: %d\n",tmp->codigo);
printf("Nome: %s\n",tmp->nome);
printf("Idade: %d\n",tmp->idade);
printf("Sexo: %c\n",tmp->sexo);
printf("Endereço: %s\n",tmp->endereco);
printf("Cidade: %s\n",tmp->cidade);
printf("Estado: %s\n",tmp->estado);
printf("CEP: %d\n",tmp->cep);
printf("Cargo: %s\n",tmp->cargo);
printf("Salário: %.2f\n",tmp->salario);
printf("E-Mail: %s\n",tmp->email);
printf("Celular: %d\n",tmp->fone);
printf("\n------------------------------------\n");
tmp=tmp->prox;///Avança para o proximo elemento da lista

}
ler_arq(cad_fun);///-------Função para ler os arquivos salvos
getchar();

}

Tenho um trabalho da faculdade para entregar e nao estou conseguindo salvar os dados em um arquivo binario.

alguem puder me ajudar eu agradeço!

vangodp · 13 de maio de 2016

Não sei como você quer ajuda postando metade do código mas vamos lá...

na função inserir_novo logo ao principio você cria um nove cadastro (cadastro *novo_cad), posteriormente você faz a leitura do tal cadastro usando novo_cad. Como é que você então ato seguido faz salvar_arq ( cad_fun ); si esse cadastro ainda não faz parte da lista? A lista teria que ser salva após esse novo cadastro estivesse inserido na lista, isso deve ocorrer justo antes de chamar a salvar_arq ( cad_fun ); e não depois.

48rneves15 · 22 de maio de 2016

Porque foi so atá aqui que fiz, estou fazendo em partes, agora estou conseguindo salvar em um arquivo, mais não estou conseguindo ler o arquivo salvo, esse é um trabalho da faculdade e são varios os requisitos pedidos pelo prof.

São eles: Criar lista com alocação dinâmica, salvar e ler em arquivo, busca sequencial e binaria*, Ultilizar pelo menos 3 métodos de ordenação, uma função recursiva. eu prefiro ir por partes para ficar melhor verificar os erros ao longo do desenvolvimento, para não gerar um monte de erros no fim, no meu ponto de vista dar mais trabalho.

Bom eu consegui colocar pra salvar em um arquivo, não sei se o modo em que eu estou fazendo é certo mais deu.

Postando o Código do programinha em C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>
#include <windows.h>

struct Cad_funcionario{
int codigo;
char nome[50];
int idade;
char sexo;
char endereco[50];
char cidade[50];
char estado[50];
int cep;
char cargo[50];
float salario;
char email[50];
int fone;

struct Cad_funcionario *prox;

};
typedef struct Cad_funcionario cadastro;

int tam;

///-------------------------Função inicio do programa----------------------
void inicio(){
cadastro *cad_fun=(cadastro *)malloc(sizeof(cadastro));
if(!cad_fun){
printf("MEMÓRIA INSUFICIENTE!\n");
exit(1);///----------------------------------------fecha o programa
}else{
inicia(cad_fun);
int opt;
do{
opt=menu();
opcao(cad_fun,opt);
}while(opt);

free(cad_fun);

return 0;
}
}///-----fim da função inicio---------

///-------------funçao inicia lista----------------------------
void inicia(cadastro *cad_fun){///--------ponteiro cad aponta para struct cadastro
cad_fun->prox=NULL; ///--------------ponteiro aponta prox recebe nulo
tam=0; ///-----------------------------------tamanho recebe zero
} ///------fim da função inicia------

///--------------funcao menu da lista-----------------
int menu(void){
system("cls");
int opt;
dados_empresa();
puts("\n\n");
puts("\t 1 -> Cadastrar novo funcionário");
puts("\t 2 -> Exibir todos funcionários");
puts("\t 3 -> Remover funcionário");
puts("\t 4 -> Apagar tudo");
puts("\t 5 -> Ordenar");
puts("\t 6 -> Pesquisar");
puts("\t 0 -> Sair\n");

puts("Escolha uma opção: ");
scanf("%d",&opt);fflush(stdin);///------------limpar o buffer do teclado

return opt;
}///-------------fim da função menu------------

///--------------funçao opcao do menu------------
void opcao(cadastro *cad_fun,int op){
switch(op){
case 1: ///-------------------------inserir elemento
system("cls"); ///--------------limpa tela
inserir_novo(cad_fun); ///------chama função
system("cls"); ///------------- limpa tela
break;
case 2: ///------------------------listar todos
system("cls");
exibe_cad(cad_fun);
system("cls");
break;
case 3: ///------------------------Remover Elemento (OBS: So atá esta função que fiz.)
system("cls");
remover_cad(cad_fun);
system("cls");
break;

}
}///---fim da função opcao---------------

///-------------Função vazia------------------
int vazia(cadastro *cad_fun){
if(cad_fun->prox==NULL){///------------se struct for aponta para nulo
return 1;///-----------------------retorna valor verdadeiro vazia
}else{
return 0;///-----------------------retorna valor falso e sai da função
}
}/// -------------------fim da função vazia---------------

///-------------------Declarando Arquivo e ponteiro------------
FILE *fcadastro; /// ----------ponteiro do arquivo

/** --------------------funcao linhas --------------*/
void nlinhas(){
int n;
for(n=0;n<135;n++){
printf("=");
}
}///---------------Fim da Função Linha

/**----------- Dados de uma empresa fictícia------------*/
void dados_empresa(){
char nome[]="NR MARKETING & LOGÍSTICA LTDA - ME";
char endereco[]="Av. josé Costa nº 23, BAIRRO: Aparecida";
char cidade[]="Juazeiro - PE";
int fone=32416897;
char cnpj[]="CNPJ 0706985378/0001-32";
char IE[]="IE 1517.391.110.12";
char email[]="E-mail: [email protected]";
printf("\n");
nlinhas();
printf("\n\t\t\t\t\t\t %s\n",nome);
printf("\t\t\t\t\t%s, %s\n",endereco,cidade);
printf("\t\t\t\t\t %s, %s\n",cnpj,IE);
printf("\t\t\t\t\tTelefone %d, ",fone);
printf("%s\n",email);
nlinhas();

}/// ------------- fim dados ficticios-----------------

///-------------------------função "INSERIR" -----------------------------
void inserir_novo(cadastro *cad_fun){
system("color 4f");

fcadastro=fopen("DADOs.bin","a+b");
if(fcadastro==NULL){
printf("ERRRO!\n");
exit(1);
}
int valor_byte;

cadastro *novo_cad=(cadastro *)malloc(sizeof(cadastro));
if(!novo_cad){
printf("Sem memória disponível!\n");
getche();
exit(1);

}else{
///------etiqueta descrição da empresa------
dados_empresa();///-----------------Nome fictício da empresa

///-------Recebendo dados de um novo funcionario-----
printf(" \n Entre com os dados do funcionário\n");
printf(f," \nCÓDIGO: %i",novo_cad->codigo);
scanf("%d",&novo_cad->codigo);fflush(stdin);
puts("\nNome: ");
gets(&novo_cad->nome);setbuf(stdin,NULL);
puts("Idade: ");
scanf("%d",&novo_cad->idade);fflush(stdin);
puts("Sexo [M/F]: ");
scanf("%c",&novo_cad->sexo);fflush(stdin);
puts("Endereço: ");
gets(novo_cad->endereco);fflush(stdin);
puts("Cidade: ");
gets(novo_cad->cidade);fflush(stdin);
puts("Estado: ");
gets(novo_cad->estado);fflush(stdin);
puts("Cep: ");
scanf("%d",&novo_cad->cep);fflush(stdin);
puts("Cargo: ");
gets(novo_cad->cargo);fflush(stdin);
puts("Salário: ");
scanf("%f",&novo_cad->salario);fflush(stdin);
puts("E-mail: ");
gets(novo_cad->email);fflush(stdin);
puts("Celular: ");
scanf("%d",&novo_cad->fone);fflush(stdin);

// fseek(stdin,0,SEEK_END);
// fseek(f,0,SEEK_END);
///---------aqui abaixo está a função de salvar no arquivo---------------
valor_byte=fwrite(novo_cad,sizeof(cadastro),1,fcadastro);
fclose(fcadastro);
system("cls");
Sleep(1000);
printf("\n\t\t Salvando... \n");
system("cls");
if(valor_byte==1){
puts("\n\t\tSalvo com Sucesso!\n\n");
printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\t\tTecle ENTER para retornar. \n");
getchar();
}else{
printf("\n\t\tERRO: Não foi possível salvar!\n\n");
}

cadastro *aux=cad_fun->prox;

cad_fun->prox=novo_cad;
novo_cad->prox=aux;
}
}///--------------------fim da função inserir------------------------

///-------------------função exibe lista completa------------------
void exibe_cad(cadastro *cad_fun){
int i=0;
fcadastro=fopen("DADOs.bin","rb");
if(fcadastro==NULL){
printf("Arquivo nao existe\n");
exit(1);
}

if(vazia(cad_fun)){
printf("\n\tNENHUM FUNCIONÁRIO CADASTRADO!\n\n");
printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\t\tTecle ENTER para retornar.\n");
getchar();
system("cls");
return ;
}

dados_empresa();
cadastro *tmp;
tmp=cad_fun->prox;
printf("\n\t Listando Todos os Cadastros \n\n");
while(tmp!=NULL){
int valor=0;

valor = fread(&tmp,sizeof(cadastro),1,fcadastro);

if(valor==1){
do{

///---------------Exibe lista com todos os elementos cadastrados-------------
printf("\n----------------------------------- ");
printf("\t\tCÓDIGO: %d\n",tmp->codigo);
printf("Nome: %s\n",tmp->nome);
printf("Idade: %d\n",tmp->idade);
printf("Sexo: %c\n",tmp->sexo);
printf("Endereço: %s\n",tmp->endereco);
printf("Cidade: %s\n",tmp->cidade);
printf("Estado: %s\n",tmp->estado);
printf("CEP: %d\n",tmp->cep);
printf("Cargo: %s\n",tmp->cargo);
printf("Salário: %.2f\n",tmp->salario);
printf("E-Mail: %s\n",tmp->email);
printf("Celular: %d\n",tmp->fone);
}while(!feof(fcadastro));
printf("\n------------------------------------\n");
tmp=tmp->prox;
}else{
printf("\nNenhum arquivo encontrado!\n");
}
}

getchar();

} /// --------------------fim da função exibir---------------------

///--------------Função apagar-"Remover"--------------------------
void remover_cad(cadastro *cad_fun){
int j=0;
char busca[30];///-------------------------------------------------string q recebe o nome a ser buscado para apagar
if(vazia(cad_fun)){
printf("\n\t Nenhum cadastro encontrado! \n\n");
getchar();
system("cls");
menu();///------------------------------------------------------se tiver vazio retorna ao menu
}else{
dados_empresa();///-------------------nome da empresa fictíco
printf("\n\tAPAGAR UM CADASTRO\n");
printf("Nome: ");gets(busca);fflush(stdin);///---------recebe o nome de busca
printf("\n\n\t\tBuscando...\n");
Sleep(1000);
system("cls");
cadastro *aux=cad_fun;
///------------------compara os nomes se são idênticos--------------------
while(!(aux==NULL)&&!(strcmp(aux->nome,busca)==0)){
aux=aux->prox;
j++;
}
if(aux==NULL){
dados_empresa();///-------------------------------------nome da empresa ficticia
printf("\n\t CADASTRO NÂO ENCONTRADO!!! \n\n");
getchar();
system("cls");
}else{
char op;
dados_empresa();

printf("\n\n\t\tCADASTRO ENCONTRADO\n");

printf("\n\n\tDeseja realmente apagar? [S/N]\n");
scanf("%c",&op);fflush(stdin);

system("cls");
if(op=='s'||op=='S'){
cadastro *atual=cad_fun->prox,
*anterior=cad_fun;
while(atual->prox!=NULL){
anterior=atual;
atual=atual->prox;
}
system("cls");
dados_empresa();
printf("\n\n\t\tApagando...\n");
Sleep(1000);
system("cls");
dados_empresa();
printf("\n\t\tCADASTRO REMOVIDO\n");
atual=anterior->prox;
printf("\n----------------------------------- ");
printf("\t\tCÓDIGO: %d\n",atual->codigo);
printf("Nome: %s\n",atual->nome);
printf("Idade: %d\n",atual->idade);
printf("Sexo: %c\n",atual->sexo);
printf("Endereço: %s\n",atual->endereco);
printf("Cidade: %s\n",atual->cidade);
printf("Estado: %s\n",atual->estado);
printf("CEP: %d\n",atual->cep);
printf("Cargo: %s\n",atual->cargo);
printf("Salário: %.2f\n",atual->salario);
printf("E-Mail: %s\n",atual->email);
printf("Celular: %d\n",atual->fone);
printf("\n------------------------------------\n");

printf("\n\t\tTecle ENTER para retornar.\n");
getchar();

anterior->prox=atual->prox;
tam--;
return atual;
}else{
system("cls");
printf("\n\n\tretornando ao menu...");
Sleep(1000);
system("cls");
menu();
}
}
}
}------------------------- fim da função remover---------------------

///OBS: As funções feitas até o momento só foram essas.

///---------------------função main--------------------------

int main(void){
system("color 3f");
setlocale(LC_ALL,"portuguese");

int tecla;

dados_empresa();///----------------dados da empresa fictícia

printf("\n\n\n\n\n\n\t\t\t\t\t\t\t\tBEM VINDO\n");
printf("\t\t\t\t\t\estão PROGRAMA DE CADASTRO DE FUNCIONÁRIOS\n\n\n\n\n\n");
printf("\n\n\n\n\t\t\t\t\t\t Precione <ENTER> para iniciar!\n");

tecla=getchar();
if(tecla){
inicio();
}

return 0;
}-----------------------fim do main-----------------------------------

Espero que agora de para compreender melhor o que estou tentando fazer, quem poder me dar uma ajudinha agradeço.

vangodp · 22 de maio de 2016

ok.... seu problema é unicamente escrever isso em um arquivo binário. Correto? porém vou lhe dar uns conselhos.... escute se quiser.

1º Nunca use getch. A função getch faz seu código menos portável. Imaginou o que aconteceria se depois de 400.000 linhas de código seu chefe falar para você rodar o programa em Linux? XD Para isso você tem getchar que faz parte do padrão.

2º Essa parte é longa. Já ouviu falar sobre Byte aligne e space pading? Se a resposta é não então entre aqui faça a leitura do tema e logo depois volte aqui para continuar: https://0xc0de.wordpress.com/2008/10/31/alinhamento-alignment-e-preenchimento-padding/

Bem... se você leu o que eu falei você se estará perguntando o que tem a ver isso com seu programa, dai eu lhe responderei MUITO!

Imagine o exemplo lá dessa pagina.... dai você quer escrever um arquivo binário certo? Pois saiba que dependendo como escrever um arquivo binário você pode escrever ele de duas formas, a primeira será um arquivo no qual contenha puros chars, se você escrever 12900 nesse arquivo por exemplo, você terá "12900", um string, ou seja 5 bytes, porém em determinadas ocasiões dependendo de como você programar isso, o que será enviado ao arquivo será um int e o numero suportado será o mesmo que aguente um inteiro, essa é a segunda forma. Quer ver exemplos? vamos lá...

Na primeiro forma vamos escrever 3 inteiros em um arquivo, a saída será um string e o tamanho do arquivo será a quantidade de números que tiver nos inteiros... exemplo, se eu tiver 3000, 44000 e 785544 sendo os 3 inteiros, a saída será 15 bytes, "300044000785544". Dai o problema como você vai fazer o processo inverso? Isso é um string e quando isso se guardar no arquivo, você ja não saberá 3000 pertencia ao primeiro int, nem que 44000 pertencia ao segundo etc

#include <stdio.h>
#include <stdlib.h>

FILE* fileOpen( char* name, char* mode){
    FILE* file = fopen( name, mode);
    if ( file == NULL ){
        perror("Erro: ");
        exit(1);
    }
    return file;
}

int main(){
    int n1 = 3000;
    int n2 = 44000;
    int n3 = 785544;
    
    FILE * file = fileOpen("prova1.bin", "w+b");
    
    fprintf(file, "%d%d%d", n1, n2, n3);
    
    fclose(file);
    return 0; 
}

Veja o arquivo prova1.bin e veja seu tamanho depois de executar esse programa, abra com o bloco de notas e veja se vê algo como 300044000785544. Pois bem, agora você pode separar esse string colocando um espaço entre %d e %d lá no fprintf ficando tal como fprintf(file, "%d %d %d", n1, n2, n3);, agora você poderia ler esses 3 strings e jogar eles em 3 inteiros, porém sempre tendo cuidado com o tamanho que cabe em um inteiro.

Agora vamos ver como independentemente esses 3 inteiros podem ir ao binário como inteiros(sem converter a string)

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int n1;
    int n2;
    int n3;    
}dados;

FILE* fileOpen( char* name, char* mode){
    FILE* file = fopen( name, mode);
    if ( file == NULL ){
        perror("Erro: ");
        exit(1);
    }
    return file;
}

int main(){
    FILE * file = fileOpen("prova2.bin", "w+b");
    
    dados d;
    d.n1 = 3000;
    d.n2 = 44000;
    d.n3 = 785544;
    
    fwrite( &d, sizeof(dados), 1, file );
    
    fclose(file);
    return 0; 
}

Se executou o programa e abriu o prova2.txt você vai ver que não poderá ver esses números, porém se comprovar o arquivo ele vai ter o tamanho de 3 inteiros, isso é 4 bytes no meu pc, 3X4 14, o bom disso é que seja o numero que for vai ocupar 4 bytes, que é a capacidade de um inteiro. Isso aconteceu por que enviei a estrutura completa para a memória tal como ela está na memória do computador e foi declarada na estrutura dados.

Isso é tudo confuso por que você se estará ainda se perguntando que tem tudo isso a ver com seu problema, bom... como eu falei antes são apenas conselhos mas ja pensou o que acontece se você envia sua estrutura para o arquivo, e ela se escreve como string e dai você quer recuperar ela porém ela foi enviada com padings(preenchimentos), quando tentar ler esse arquivo você pode ler tudo fora de alinhamento, dai o nome "Byte Align" ou alinhamento dos bytes.

Sabe o que é mais engraçado ainda? que você pode levar seu código que você fez no codeblocks para seu professor e hipoteticamente falando imagine que ele usa visual studio ou qualquer outro programa. Como o alinhamento é algo que cada compilador pode interpretar de uma maneira, o fato é que sem aparente motivo o programa tão bonito que você gerou de noite na sua casa e tudo foi bem, lá na uni te da um vexame e o pior é que você nem se vai ligar por isso... certamente seu professor também não.>_<

Solução ao byte align!
você pode serializar os dados. Consiste em gravar um por um os dados da estrutura, e fazer o mesmo processo inverso. O problema não existiria por que você não usaria o sizeof(dados) si não o sizeof de cada uma das variáveis por separado, isso faria com que o tamanho seria correto para cada variável, pois si fizer o sizeof de uma por uma não aconteceria o tal problema.

Ao menos sempre que trabalhar com estruturas e arquivos você deveria ter presente que esse problema é vero e real.

3º Usar fflush(stdin); é horrível XD. Leia aqui o por quê: http://forum.imasters.com.br/topic/336835-tutorial-systempause-e-fflushstdin/ ...incluindo as respostas dos usuários.

4º Tudo bem que trata-se de um trabalho para a universidade, porém system("cls"); é outro problema de portabilidade, em Linux isso não funciona, porém o linguagem C não provê nada no padrão para solucionar esse problema, mas certamente existem soluções bem mais elegantes como esta:

#include <stdio.h>
#include <stdlib.h>

#ifdef WIN32
void limpartela(){
    system("cls");
}
#endif
#ifdef __linux__
void limpartela(){
    //Aqui o código para limpar a tela no linux
}
#endif
void pause(){
    printf("\nPulse uma tecla");
    getchar();
}

int main (){
    printf("Hola baby");
    pause();    
    limpartela();
    printf("chau baby");
    pause();
    return 0;
}

Esse pequeno código fará com que o problema de limpar a tela seja inexistente seja o sistema que for. =)

Certamente tem alguns probleminhas mais porém vou deixar por aqui si não o texto vai ficar do tamanho da china. >_<

Eu acho que com tudo isso ja respondi sua pergunta de como guardar em arquivos binários não? Estude isso e nunca mais haverá problemas com isso.

Fui!