C Utilização de Struct e gerar arquivo TXT em C

vagabond1 · 13 de abril de 2020

Galera, sou iniciante em programação e estou completamente perdido de como da continuidade nesse exercicio. Este exercicio fala que era para buscar exemplos de como gerar arquivos TXT em C utilizando Struct pois ele não ensina e quer que a gente quebre a cabeça, pois gerar ate esta gerando o problema esta colocar essas informações no codigo utilizando Struct (Malloc, Alloc, Ponteiros e etc...). Fiz este codigo com base em pesquisas porém achei ele um pouco estranho e parece que não igual ao que esta sendo solicitado. Quem puder me ajudar ficaria grato:

#include <stdio.h>
#include <stdlib.h>
#define T 1
                              
struct cliente {
char nome [100];
int telefone;
int id;
char tipo [50];
int endereco;
int cep;
};

struct cliente ler (){
struct cliente a;
    printf("\n#Cliente\n");
    
    printf("\n----Id:---- \n");
    scanf("%d",&a.id);
    printf("----Digite seu nome:---- \n");
    fflush(stdin);
    gets(a.nome);
    printf("\n#Telefone\n");
    
    printf("\n----Id:---- \n");
    scanf("%d",&a.id);
    printf("\n----Telefone:---- \n");
    scanf("%d",&a.telefone);
    printf("\n----Tipo:---- \n");
    fflush(stdin);
    gets(a.tipo);
    printf("\n#Endereco\n");
    
    printf("\n----Id:---- \n");
    scanf("%d",&a.id);
    printf("\n----Endereco:---- \n");
    scanf("%d",&a.endereco);
    printf("\n----CEP:---- \n");
    scanf("%d",&a.cep);
    printf("\n============================\n");
return a;
}

void imprime (struct cliente a[T]){    
int x; 
for (x=0; x<T; x++) {
    printf("\t Id: %d\n",a[x].id);
    printf("\t Nome: %s\n",a[x].nome);
    printf("\t Telefone: %d\n",a[x].telefone);
    printf("\t Tipo: %s\n",a[x].tipo);
    printf("\t Endereco: %d\n",a[x].endereco);
    printf("\t CEP: %d\n",a[x].cep);
    }
}
int main () {    
int x;
char caminho[]="cliente.txt",caractere;
FILE *arquivo;arquivo = fopen (caminho,"w");
struct cliente a[T];
if (arquivo==NULL){
printf("Erro ao criar arquivo.\n");

}else{
    
for(x=0; x<T; x++) {        
a[x]= ler();
    fprintf(arquivo,"Id: %d\nNome: %s\nTelefone: %d\nTipo %s\nEndereco: %d\nCEP: %d\n ", a[x].id,a[x].nome,a[x].telefone,a[x].tipo,a[x].endereco,a[x].cep);
    printf("\tArquivo gravado com sucesso.\n");
}
fclose(arquivo);

}

    imprime(a);
    system("pause");
    return 0;
}

arfneto · 14 de abril de 2020

6 horas atrás, vagabond1 disse:

como gerar arquivos TXT em C utilizando Struct pois ele não ensina e quer que a gente quebre a cabeça, pois gerar ate esta gerando o problema esta colocar essas informações no codigo utilizando Struct (Malloc, Alloc, Ponteiros e etc...)

Seu enunciado nada diz sobre o que fazer desde que use esse conceito de gerar arquivos TXT utilizando struct. E você foi escolher justo um tipo de menu e ler do teclado, o que sempre leva um tempão e só dá problema? Fuja disso.

Nada foi dito sobre alocar memória ou ponteiros. Apenas sobre os dados e as relações e as estruturas. Sugiro apenas criar as estruturas e ler do disco. Não sei se entendo aqueles (1,1) (1,n) (n,n) e tal. Você entendeu aquilo?

Parece sugerir que

cada cliente pode ter vários telefones e endereços, ao menos 1
cada telefone tem um tipo

Sobre como gravar no disco o enunciado só fala sobre arquivos TXT. Defina o formato que for melhor. Pode por exemplo apenas criar um navegador de clientes, que passa pelos clientes e monta os valores e vai mostrando na tela um cliente por vez. Não é preciso inserir ou editar ou nada. Não está no enunciado. Apenas use as estruturas e um arquivo TXT. O arquivo não tem que ser inteligível. Pode fazer sentido só para seu programa. Desde que contenha apenas texto está ok...

vagabond1 · 14 de abril de 2020

@arfneto Obrigado pela resposta.

Esqueci de colocar o resto do enunciado, que seria: "O usuário deverá informar 'n' registros via teclado e o resultado final deverá ser salvo em um arquivo texto conforme modelo abaixo:"

As questões de (1,1), (1,n)... tem um tempo que aprendi porém não me aprofundei muito.

Mas esse codigo esta me dando uma dor de cabeça kkkk

Poderia me dizer se da pra trabalhar por cima do que estou fazendo ou preciso refazer o codigo:

adicionado 4 minutos depois

@vangodp Obrigado pela resposta.

Então amigo, este conceito ainda não aprendi, estou ficando louco tentando quebrar a cabeça com esse codigo mas não sai do lugar. Consegui realizar aqueles conceitos que postei mas não esta legal.

Tentei trabalhar por cima dessa sua base porém estou perdido, pois pediram pra gente se basear em pesquisar porém tem varios conceitos que ainda não foram ensinados, ai complica entende.

Agradeço a resposta e ajuda.

vagabond1 · 14 de abril de 2020

@vangodp Muito obrigado, realmente esta executando.

Mas me tire uma duvida por favor, ainda tem as informações de Cliente, Tipo de Telefone, Nome, CEP, Logradouro. Estes tem que ser recebido atraves do teclado e no fim ser armazenado em um arquivo TXT. Da para implementar atraves do seu codigo?

Eu ate pesquisei sobre como criar esse arquivo TXT no codigo e consegui criar o arquivo:

int main () {    
int x;
char caminho[]="cliente.txt",caractere;
FILE *arquivo;arquivo = fopen (caminho,"w");
struct cliente a[T];
if (arquivo==NULL){
printf("Erro ao criar arquivo.\n");

O problema esta sendo para implementar essas outras informações.

Mas agradeço pela ajuda!

arfneto · 14 de abril de 2020

1 hora atrás, vagabond1 disse:

Poderia me dizer se da pra trabalhar por cima do que estou fazendo ou preciso refazer o codigo

Não acho que precise refazer. Mas tire esse código que lê do teclado do seu caminho porque acho que já viu que isso atrasa muito na hora de testar.

Como eu te falei, defina o que o programa vai fazer. O enunciado é bem liberal. A menos que você tenha esquecido mais e mais coisas, claro...

Que conceito você ainda não aprendeu?

adicionado 27 minutos depois

Sobre as relações, esse é um pequeno mapa típico de E/R entidades/relacionamentos e pode ser tratado de basicamente qualquer maneria que resolva

Em bancos de dados você teria simplesmente as tabelas e as relações. Por isso os bancos de dados são chamados relacionais... No mundo de arquivos texto você poderia ter algo bem simples: um arquivo de relações ou uma lista de registros. Basta que cubra as condições do diagrama.

O cliente é a base de tudo. parece uma palestra de marketing agora

imagine que um arquivo texto tem registros simples assim com apenas 4 bytes para cada valor

            X:Y:Z

onde X é o cliente com 4 posições, Y é o telefone com 4 posições e Z é o endereço com 4 posições

E imagine isso classificado por X, o cliente. Acho que já entendeu: esse é o mapa de relacionamentos.

Aí você lê o arquivo de clientes, telefones, tipos de telefone e endereços para ficar bem de acordo com o mapa. Sem segredos: lê um a um e coloca em um vetor simples com umas dezenas deles apenas.

Para navegar pelo "banco de dados" basta você ler a tabela de relações e pegar um cliente X. Aí você lê linha a linha esse arquivo e encontra claro todas as relações de X porque ele está em ordem e porque foi você que escreveu então se estiver errado a culpa é afinal sua...

Como está em ordem de X você vai ver todos os telefones e endereços relativos ao cara e vai poder mostrar na tela, ou fazer o que quiser.

Como o enunciado é liberal e já está relativamente complicado assim, apenas navegue pelos clientes, para frente.

Note que criar novas relações é trivial: um novo telefone para o cliente 1234? Já está na tabela de telefones que está na memória do programa? Então tem um id, vamos imaginar que seja 32. Outro cliente pode ter o mesmo endereço ou telefone afinal: é a vida. Pode ser um endereço ou telefone comercial afinal. Se já tem você simplesmente grava 1234:0021:0000 no rabo do arquivo de relações. Não tem? Sem problemas: gera um novo id, digamos 1000 e gera o correspondente 1234:1000:0000 lá no arquivo. No final você chama uma função que classifica o arquivo de relações de novo e pronto.

Quer que continue funcionando em tempo real? pode ser até mais fácil: carregue a tabela de relações para a memória e trabalhe com esses valores. Bem simples: X:Y:Z.

Espero que tenha entendido. Esse é a maneira que os bancos de dados trabalham afinal, então tem que dar certo, Mas há outras.

O que importa é na sua implementação deixar bem caracterizadas as 4 entidades. E os relacionamentos. E a gente pode te ajudar a escrever.

vagabond1 · 14 de abril de 2020

@arfneto Muito bom o texto.

O que dificulta para mim seria essas relações utilizando struct, pois seria obrigatorio utilizar pelo o menos algum parametro dentro do exercicio. Como te disse, me deram meio que pra mim se virar, ai to tendo que estudar por conta propria. Obrigado pelo texto, vou ver o que consigo, se você tiver alguma luz de como começar pelo o menos já me ajudaria muito.

arfneto · 14 de abril de 2020

Você entendeu o que eu expliquei sobre os arquivos? E o lance de relacionamentos? É muito importante. Isso é um exercício básico de bancos de dados.

Você pode escrever o programa em partes, cuidando das tabelas e das estruturas. Não precisa de nada sofisticado, estruturas de dados e tal. Claro que pode usar. Mas não precisa. Pode fazer como os programas COBOL dos anos 80: lê os arquivos e faz o serviço.

Veja essas estruturas

typedef unsigned short Numero;

struct e_cli
{
    Numero Id;
    char   Nome[100];
};
typedef struct e_cli Cliente;

struct e_end
{
    Numero IdEndereco;
    char   Logradouro[500];
    char   Cep[8];
};
typedef struct e_end Endereco;

struct e_tel
{
    Numero IdTelefone;
    char   Telefone[20];
};
typedef struct e_tel Telefone;

struct e_tipo
{
    Numero IdTipoTelefone;
    Numero Tipo;
};
typedef struct e_tipo TipoTelefone;

Elas já refletem os dados e a nomenclatura

Postei no início de abril um programa completo aqui para ler e gravar playlists em disco. Lá tem duas funções que leem e gravam arquivos txt. As playlists, claro. E tem um menu. Pode ajudar. Esqueça o resto do programa. Veja essas funções.

vagabond1 · 14 de abril de 2020

@arfneto Obrigado novamente, entendi um pouco sobre os arquivos. Minha maior dificuldade é estruturar de forma correta e implementar as nomeclaturas no codigo, não sou muito da area de programação e estou aprendendo aos poucos. Gostei do exemplo que me passou mas como disse que a maior dificuldade é implementar, creio que da para usar sua base sem problemas.

arfneto · 14 de abril de 2020

1 minuto atrás, vagabond1 disse:

Minha maior dificuldade é estruturar de forma correta e implementar as nomenclaturas no codigo, não sou muito da area de programação e estou aprendendo aos poucos. Gostei do exemplo que me passou mas como disse que a maior dificuldade é implementar, creio que da para usar sua base sem problemas

A nomenclatura é aquela. Só copiei do diagrama. Os nomes e tamanhos estão certos também. Aí você pode declarar

variáveis simplesmente com os nomes do enunciado, Cliente, Telefone, Endereco e TipoTelefone

Entendeu o que eu expliquei sobre as relações? É essencial.

vagabond1 · 14 de abril de 2020

@arfneto Entendi um pouco, mas tipo, nas questões das relações que mora a dificuldade para implementar o que é pedido. Geralmente busco essas dificuldades em codigos base para poder assim realizar uma logica e fazer a arquitetura do programa. Mas colocar Struct com geração de arquivo TXT esta muito complicado para o que eu aprendi ainda. To meio que sem um rumo pra ir.

arfneto · 14 de abril de 2020

7 minutos atrás, vagabond1 disse:

Entendi um pouco, mas tipo, nas questões das relações que mora a dificuldade para implementar o que é pedido. Geralmente busco essas dificuldades em codigos base para poder assim realizar uma logica e fazer a arquitetura do programa. Mas colocar Struct com geração de arquivo TXT esta muito complicado para o que eu aprendi ainda. To meio que sem um rumo pra ir

Estou tentando te dar um rumo.

Você tem as estruturas e te mostrei um exemplo de como criar as relações. Até um exemplo do arquivo com as relações.

E te indiquei um programa completo aqui no forum mesmo que le e grava arquivos txt no disco. E descrevi uma possível lógica para escrever o programa.

Não vai achar um tal "código base" para tudo. Em geral esses problemas para estudantes são de fato muito similares, e você acaba vendo milhares de exemplos de playlists, cadastros, classificação de estruturas e tal. Mas programar um enunciado assim é algo estruturado. Se concentre em planejar e fazer o que está lá. E não tudo de uma vez. E não com menus scanf() e entrada de texto porque vai atrasar.

Qual acha que é o problema agora? O primeiro problema?

struct com geração de arquivo txt?

Se você tem as structs, e sabe quantas tem porque foi você que gerou ou leu, usa um loop tipo um for até acabarem as estruturas, e uma uma função para gravar a tal struct, tipo fwrite() para cada struct. Nada mais

vagabond1 · 14 de abril de 2020

@arfneto Exato, neste programa é o que mais se aproxima do que preciso, este foi o que eu mesmo criei com algumas bases. Pois esta pedindo para escrever com o Teclado as informações do cliente, só que esse programa executa e gera o arquivo TXT porém fica tudo meio que uma bagunça.

#include <stdio.h>
#include <stdlib.h>
#define T 2
                              
struct cliente {
char nome [100];
int telefone;
int id;
char tipo [50];
int endereco;
int cep;
};

struct cliente ler (){
struct cliente a;
    printf("\n#Cliente\n");
    
    printf("\n----Id:---- \n");
    scanf("%d",&a.id);
    printf("----Digite seu nome:---- \n");
    fflush(stdin);
    gets(a.nome);
    printf("\n#Telefone\n");
    
    printf("\n----Id:---- \n");
    scanf("%d",&a.id);
    printf("\n----Telefone:---- \n");
    scanf("%d",&a.telefone);
    printf("\n----Tipo:---- \n");
    fflush(stdin);
    gets(a.tipo);
    printf("\n#Endereco\n");
    
    printf("\n----Id:---- \n");
    scanf("%d",&a.id);
    printf("\n----Endereco:---- \n");
    scanf("%d",&a.endereco);
    printf("\n----CEP:---- \n");
    scanf("%d",&a.cep);
    printf("\n============================\n");
return a;
}

void imprime (struct cliente a[T]){    
int x; 
for (x=0; x<T; x++) {
    printf("\t Id: %d\n",a[x].id);
    printf("\t Nome: %s\n",a[x].nome);
    printf("\t Telefone: %d\n",a[x].telefone);
    printf("\t Tipo: %s\n",a[x].tipo);
    printf("\t Endereco: %d\n",a[x].endereco);
    printf("\t CEP: %d\n",a[x].cep);
    }
}
int main () {    
int x;
char caminho[]="cliente.txt",caractere;
FILE *arquivo;arquivo = fopen (caminho,"w");
struct cliente a[T];
if (arquivo==NULL){
printf("Erro ao criar arquivo.\n");

}else{
    
for(x=0; x<T; x++) {        
a[x]= ler();
    fprintf(arquivo,"Id: %d\nNome: %s\nTelefone: %d\nTipo %s\nEndereco: %d\nCEP: %d\n ", a[x].id,a[x].nome,a[x].telefone,a[x].tipo,a[x].endereco,a[x].cep);
    printf("\tArquivo gravado com sucesso.\n");
}
fclose(arquivo);

}

    imprime(a);
    system("pause");
    return 0;
}

adicionado 1 minuto depois

@arfneto E por gentileza, teria o link desse programa que citou aqui no forum?

Obrigado!

arfneto · 14 de abril de 2020

1 hora atrás, vagabond1 disse:

Exato, neste programa é o que mais se aproxima do que preciso, este foi o que eu mesmo criei com algumas bases. Pois esta pedindo para escrever com o Teclado as informações do cliente, só que esse programa executa e gera o arquivo TXT porém fica tudo meio que uma bagunça

Você leu o programa de que te falei?

Eu te disse: não leia nada do teclado enquanto não tiver resolvido a lógica das coisas. Tem razão, está sim uma certa bagunça.

Repito meu palpite: não leia nada do teclado. Só vai te atrasar... Implemente a lógica e as relações.

Você entendeu o que expliquei sobre os relacionamentos? É essencial.

adicionado 25 minutos depois

1 hora atrás, vagabond1 disse:

E por gentileza, teria o link desse programa que citou aqui no forum

Não tenho, mas pode pesquisar como eu disse direto no conteúdo que eu postei... arfneto, playlist, emulador, algo assim

arfneto · 14 de abril de 2020

Vou reforçar o que já perguntei: você entendeu o que expliquei sobre a magica dos X:Y:Z? Esse é o modelo de entidades relacionamentos. O resto seriam apenas as tabelas, as 4 tabelas.

Vou te mostrar mais uma material, e juntando os dois é eu diria uns 80% da solução do seu problema, desde que você tenha entendido a questão do modelo E/R e o lance do X:Y:Z

Considere o obvio arquivo de definições que te mostrei, copiado do enunciado

typedef unsigned short Numero;

struct e_cli
{
    Numero Id;
    char   Nome[50]; // 100
};
typedef struct e_cli Cliente;

struct e_end
{
    Numero IdEndereco;
    char   Logradouro[50]; // 500
    char   Cep[8];
};
typedef struct e_end Endereco;

struct e_tel
{
    Numero IdTelefone;
    char   Telefone[20];
};
typedef struct e_tel Telefone;

struct e_tipo
{
    Numero IdTipoTelefone;
    Numero Tipo;
};
typedef struct e_tipo TipoTelefone;

e entenda que recortar e colar é básico em desenvolvimento de software, mesmo que seja um modesto exercício de programação. Você vai fazer a mesma coisa para as 4 entidades. E a gente não vai buscar nenhuma medalha por eficiência ou algo assim: basta resolver.

Entenda essa função:

Endereco f_Endereco()
{
    Endereco e;
    char cep[9];
    static int n = 1;
    e.IdEndereco = n;
    sprintf(e.Logradouro, "Rua Via%04d", n);
    sprintf(cep, "%05d000", n + 20000);
    memcpy(e.Cep, cep, 8);
    n = n + 1;
    return e;
};  // f_Endereco()

A cada vez que você chama ela devolve um registro de endereço, simples, mas numerado. Em 3 vezes teria algo assim:

0001Rua Via0001                                       20001000
0002Rua Via0002                                       20002000
0003Rua Via0003                                       20003000

E veja esse trecho de programa

    // nend enderecos 
    int   nend = 3;
    char  preparo[600]; // tem qu caber todo mundo
    int   n = 0;
    const char* fend = "enderecos.txt";
    FILE* arquivo = fopen(fend, "w");
    for (int i = 1; i <= nend; i += 1)
    {
        Endereco en = f_Endereco();
        // limpa a area
        // endereco: 4 id 500 logradouro 8 CEP: 512 por linha
        // mas so 50 no logradouro por enquanto
        memset(preparo, ' ', 520); // tudo em branco
        sprintf(preparo, "%04d", en.IdEndereco); // so Id e Nome
        memcpy(preparo + 4, en.Logradouro, strlen(en.Logradouro));
        memcpy(preparo + 54, en.Cep, strlen(en.Cep));
        preparo[62] = '\n'; // um por linha pra facilitar
        int n = fwrite(preparo, 63, 1, arquivo);
    };
    fclose(arquivo);

Pois é: ele cria o arquivo acima, com os 3 registros, ou com 12.000 registros. Para isso são os computadores. Mudei o tamanho do endereço de 500 para 50 por enquanto para ficar mais fácil de ver no editor. Cria o tal arquivo enderecos.txt com o conteúdo esperado. Como eu te disse, apenas um loop.

E para ler essa m. para ver se está certo?

Pois é: igualzinho só que ao contrário:

    printf("gravou %d caras\n", nend);
    printf("agora tenta ler de volta\n");

    // pra dar uma segurança, vamos ler uns enderecos. E igual 
    // so que ao contrario, logico

    arquivo = fopen(fend, "r");
    Endereco e;
    int l = 0;
    // enquanto nao acabar o arquivo le os caras
    // nao precisa fazer nada
    // la tem 4 id 50 logradouro 8 cep
    while (!feof(arquivo))
    {
        fgets(preparo, 130, arquivo); // le uma linha inteira
        n = strlen(preparo);
        printf("\n***** Leu %d de  'fend'\n", n);
        if (feof(arquivo)) break; // deve ter acabado
        //
        // IdEndereco que e um numero
        //
        l = l + 1; // leu uma linha
        printf("Registro %03d\n", l);
        char id_end[5];
        memcpy(id_end, preparo, 4);
        id_end[4] = 0; // temos o Id no formato certo
        printf("Id: %s\n", id_end);
        e.IdEndereco = atoi(id_end); // o simples: converte para int

        //
        // Rua com 50 [500 na verdade]
        //
        char Rua[51]; // uma string para imprimir
        Rua[50] = 0;
        memcpy(e.Logradouro, preparo + 4, 50);
        memcpy(Rua, preparo + 4, 50);
        printf("Logradouro: %s\n", Rua);

        //
        // CEP com 8 
        //
        char CEP[10]; // uma string para imprimir, com '-'
        CEP[9] = 0;
        memcpy(e.Cep, preparo + 54, 8);
        memcpy(CEP, preparo + 54, 5);
        CEP[5] = '-';
        memcpy(CEP + 6, preparo + 59, 3); // frescura, claro
        printf("CEP: %s\n", CEP);
    };  // while()
    fclose(arquivo);

Um pouco mais comprido porque eu queria que fosse também strings para mostrar na tela, além de preencher a tal struct.

Vai sair assim:

gravou 3 caras
agora tenta ler de volta

***** Leu 63 de  'fend'
Registro 001
Id: 0001
Logradouro: Rua Via0001
CEP: 20001-000

***** Leu 63 de  'fend'
Registro 002
Id: 0002
Logradouro: Rua Via0002
CEP: 20002-000

***** Leu 63 de  'fend'
Registro 003
Id: 0003
Logradouro: Rua Via0003
CEP: 20003-000

***** Leu 63 de  'fend'

É só recortar e colar, na prática. E trocar o fwrite() por fread() e ler até o fim de arquivo, o tal eof()

Eis o programa todo de teste

#define _CRT_SECURE_NO_WARNINGS

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

#include "file.h"

/*
https://www.clubedohardware.com.br/forums/topic/
1440284-utiliza%C3%A7%C3%A3o-de-struct-e-gerar-arquivo-txt-em-c/
?tab=comments#comment-7748390#include
*/

Cliente      f_Cliente(); // cria um cliente
Endereco     f_Endereco(); // cria um endereco
Telefone     f_Telefone(); // cria um telefone
TipoTelefone f_TipoTelefone(); // cria um tipo

int main(int argc, char** argv)
{
    // quantos vou gerar

    // um lugar para arrumar o registro

    // nend enderecos 
    int   nend = 3;
    char  preparo[600]; // tem qu caber todo mundo
    int   n = 0;
    const char* fend = "enderecos.txt";
    FILE* arquivo = fopen(fend, "w");
    for (int i = 1; i <= nend; i += 1)
    {
        Endereco en = f_Endereco();
        // limpa a area
        // endereco: 4 id 500 logradouro 8 CEP: 512 por linha
        // mas so 50 no logradouro por enquanto
        memset(preparo, ' ', 520); // tudo em branco
        sprintf(preparo, "%04d", en.IdEndereco); // so Id e Nome
        memcpy(preparo + 4, en.Logradouro, strlen(en.Logradouro));
        memcpy(preparo + 54, en.Cep, strlen(en.Cep));
        preparo[62] = '\n'; // um por linha pra facilitar
        int n = fwrite(preparo, 63, 1, arquivo);
    };
    fclose(arquivo);

    printf("gravou %d caras\n", nend);
    printf("agora tenta ler de volta\n");

    // pra dar uma segurança, vamos ler uns enderecos. E igual 
    // so que ao contrario, logico

    arquivo = fopen(fend, "r");
    Endereco e;
    int l = 0;
    // enquanto nao acabar o arquivo le os caras
    // nao precisa fazer nada
    // la tem 4 id 50 logradouro 8 cep
    while (!feof(arquivo))
    {
        fgets(preparo, 130, arquivo); // le uma linha inteira
        n = strlen(preparo);
        printf("\n***** Leu %d de  'fend'\n", n);
        if (feof(arquivo)) break; // deve ter acabado
        //
        // IdEndereco que e um numero
        //
        l = l + 1; // leu uma linha
        printf("Registro %03d\n", l);
        char id_end[5];
        memcpy(id_end, preparo, 4);
        id_end[4] = 0; // temos o Id no formato certo
        printf("Id: %s\n", id_end);
        e.IdEndereco = atoi(id_end); // o simples: converte para int

        //
        // Rua com 50 [500 na verdade]
        //
        char Rua[51]; // uma string para imprimir
        Rua[50] = 0;
        memcpy(e.Logradouro, preparo + 4, 50);
        memcpy(Rua, preparo + 4, 50);
        printf("Logradouro: %s\n", Rua);

        //
        // CEP com 8 
        //
        char CEP[10]; // uma string para imprimir, com '-'
        CEP[9] = 0;
        memcpy(e.Cep, preparo + 54, 8);
        memcpy(CEP, preparo + 54, 5);
        CEP[5] = '-';
        memcpy(CEP + 6, preparo + 59, 3); // frescura, claro
        printf("CEP: %s\n", CEP);
    };  // while()
    fclose(arquivo);





    return 0;
};  // main()


Cliente f_Cliente()
{
    //
    // vai criando N clientes com nome ClienteNNNN e Id N
    // a cada chamada
    //
    static int n = 1;
    Cliente cl;
    cl.Id = n;
    sprintf(cl.Nome, "Cliente%04d", n);
    n = n + 1;
    return cl;
};  // f_Cliente()


Endereco f_Endereco()
{
    Endereco e;
    char cep[9];
    static int n = 1;
    e.IdEndereco = n;
    sprintf(e.Logradouro, "Rua Via%04d", n);
    sprintf(cep, "%05d000", n + 20000);
    memcpy(e.Cep, cep, 8);
    n = n + 1;
    return e;
};  // f_Endereco()


Telefone f_Telefone()
{
    Telefone tel;
    static int n = 1;
    tel.IdTelefone = n;
    sprintf(tel.Telefone, "+55 (11) 9%04d%04d", n + 3000, n);
    n = n + 1;
    return tel;
};  // f_Telefone()


TipoTelefone f_TipoTelefone()
{
    TipoTelefone tipo;
    static int n = 1;
    tipo.IdTipoTelefone = n;
    tipo.Tipo = n;
    n = n + 1;
    return tipo;
}   // f_TipoTelefone()

Como bonus, tem as outras rotinas que criam as outras structs preenchidinhas para você usar. as 4 f_xxxx() lá no fim do programa.

Em resumo: preste atenção nesse mecanismo: ele cria as estruturas com um número qualquer de registros. E mostra como ler e gravar os arquivos texto de modo que você pode editar depois.

Falta implementar as relações e já te mostrei uma maneira.

Entendeu?

vagabond1 · 14 de abril de 2020

@arfneto Nossa ficou otimo a explicação, obrigado!

Não sei por que esse for esta dando erro, tentei de tudo para tentar resolver.

*somente implementei as relações e não alterei seu codigo para testar o mesmo, mas assim que estiver rodando vou realizar as alterações para facilitar ainda mais o entendimento.

Mas muito obrigado, já ajudou bastante.

arfneto · 14 de abril de 2020

8 minutos atrás, vagabond1 disse:

tentei de tudo para tentar resolver

Uma maneira simples seria ler a mensagem

Seu compilador está usando a versão 89 da linguagem. E 89 é sim o ano. 1989. Talvez ache um pouco antiga afinal. Lá nas opções de compilação e acrescente ...

EXATAMENTE o que está escrito na tela. use opção -std=c11 por exemplo... Está na tela. Você não leu a mensagem de erro?

Esse não é um ambiente assim muito bom para aprender C ou C++. Mas é possível.

Isso deve estar em Tools | compiler options | compiler. Pelo que me vi tem um lugar lá onde você marca

"Add the following commands when calling the compiler"

e lá acrescenta isso: -std=c11 ou talvez -std=c++11

Mais um bonus, usando recortar e colar:

#define _CRT_SECURE_NO_WARNINGS

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

#include "file.h"

/*
https://www.clubedohardware.com.br/forums/topic/
1440284-utiliza%C3%A7%C3%A3o-de-struct-e-gerar-arquivo-txt-em-c/
?tab=comments#comment-7748390#include
*/

Cliente      f_Cliente(); // cria um cliente
Endereco     f_Endereco(); // cria um endereco
Telefone     f_Telefone(); // cria um telefone
TipoTelefone f_TipoTelefone(); // cria um tipo

int main(int argc, char** argv)
{
    // quantos vou gerar de cada:
    int ncli = 30;
    int nend = 30;
    int ntel = 20;
    int ntip = 9;

    // um lugar para arrumar o registro
    char  preparo[600]; // tem qu caber todo mundo
    int n = 0;


    // ncli clientes 
    const char* fcli = "clientes.txt";
    FILE* arquivo = fopen(fcli, "w");
    for (int i = 1; i <= ncli; i += 1)
    {
        Cliente cl = f_Cliente();
        // limpa a area
        // cli: 4 id 100 nome: 104 por linha
        // mas so 50 no nome por enquanto
        memset(preparo, ' ', 120); // tudo em branco
        sprintf(preparo, "%04d", cl.Id); // so Id e Nome
        memcpy(preparo + 4, cl.Nome, strlen(cl.Nome)); // copia o nome
        preparo[54] = '\n'; // um por linha pra facilitar
        int n = fwrite(preparo, 55, 1, arquivo);
    };
    fclose(arquivo);


    // nend enderecos 
    const char* fend = "enderecos.txt";
    arquivo = fopen(fend, "w");
    for (int i = 1; i <= nend; i += 1)
    {
        Endereco en = f_Endereco();
        // limpa a area
        // endereco: 4 id 500 logradouro 8 CEP: 512 por linha
        // mas so 50 no logradouro por enquanto
        memset(preparo, ' ', 520); // tudo em branco
        sprintf(preparo, "%04d", en.IdEndereco); // so Id e Nome
        memcpy(preparo + 4, en.Logradouro, strlen(en.Logradouro));
        memcpy(preparo + 54, en.Cep, strlen(en.Cep));
        preparo[62] = '\n'; // um por linha pra facilitar
        int n = fwrite(preparo, 63, 1, arquivo);
    };
    fclose(arquivo);


    // ntel telefones 
    const char* ftel = "telefones.txt";
    arquivo = fopen(ftel, "w");
    for (int i = 1; i <= ntel; i += 1)
    {
        Telefone te = f_Telefone();
        // limpa a area
        // telefone: 4 id 20 Telefone: 24 por linha
        memset(preparo, ' ', 30); // tudo em branco
        sprintf(preparo, "%04d", te.IdTelefone);
        memcpy(preparo + 4, te.Telefone, strlen(te.Telefone));
        preparo[24] = '\n'; // um por linha pra facilitar
        int n = fwrite(preparo, 25, 1, arquivo);
    };
    fclose(arquivo);


    // ntip tipos 
    const char* ftip = "tipos.txt";
    arquivo = fopen(ftip, "w");
    for (int i = 1; i <= ntip; i += 1)
    {
        TipoTelefone tp = f_TipoTelefone();
        // limpa a area
        // tipo de telefone: 4 id 4 tipo: 8 por linha
        memset(preparo, ' ', 10); // tudo em branco
        sprintf(preparo, "%04d%04d", tp.IdTipoTelefone, tp.Tipo);
        preparo[8] = '\n'; // um por linha pra facilitar
        int n = fwrite(preparo, 9, 1, arquivo);
    };
    fclose(arquivo);


    // pra dar uma segurança, vamos ler uns enderecos. E igual 
    // so que ao contrario, logico

    arquivo = fopen(fend, "r");
    Endereco e;
    int l = 0;
    // enquanto nao acabar o arquivo le os caras
    // nao precisa fazer nada
    // la tem 4 id 50 logradouro 8 cep
    while( ! feof(arquivo))
    {
        fgets(preparo, 130, arquivo); // le uma linha inteira
        n = strlen(preparo);
        printf("Leu %d de  'fend'\n",n);
        if (feof(arquivo)) break; // deve ter acabado
        //
        // IdEndereco que e um numero
        //
        l = l + 1; // leu uma linha
        printf("\n***** %03d\n", l);
        char id_end[5];
        memcpy(id_end, preparo, 4);
        id_end[4] = 0; // temos o Id no formato certo
        printf("Id: %s\n", id_end);
        e.IdEndereco = atoi(id_end); // o simples: converte para int

        //
        // Rua com 50 [500 na verdade]
        //
        char Rua[51]; // uma string para imprimir
        Rua[50] = 0;
        memcpy(e.Logradouro, preparo + 4, 50);
        memcpy(Rua, preparo + 4, 50);
        printf("Logradouro: %s\n", Rua);

        //
        // CEP com 8 
        //
        char CEP[10]; // uma string para imprimir, com '-'
        CEP[9] = 0;
        memcpy(e.Cep, preparo + 54, 8);
        memcpy(CEP, preparo + 54, 5);
        CEP[5] = '-';
        memcpy(CEP+6, preparo + 59, 3); // frescura, claro
        printf("CEP: %s\n", CEP);
    };  // while()
    fclose(arquivo);





    return 0;
};  // main()


Cliente f_Cliente()
{
    //
    // vai criando N clientes com nome ClienteNNNN e Id N
    // a cada chamada
    //
    static int n = 1;
    Cliente cl;
    cl.Id = n;
    sprintf(cl.Nome, "Cliente%04d", n);
    n = n + 1;
    return cl;
};  // f_Cliente()


Endereco f_Endereco()
{
    Endereco e;
    char cep[9];
    static int n = 1;
    e.IdEndereco = n;
    sprintf(e.Logradouro, "Rua Via%04d", n);
    sprintf(cep, "%05d000", n+20000);
    memcpy(e.Cep, cep, 8);
    n = n + 1;
    return e;
};  // f_Endereco()


Telefone f_Telefone()
{
    Telefone tel;
    static int n = 1;
    tel.IdTelefone = n;
    sprintf(tel.Telefone, "+55 (11) 9%04d%04d", n+3000, n);
    n = n + 1;
    return tel;
};  // f_Telefone()


TipoTelefone f_TipoTelefone()
{
    TipoTelefone tipo;
    static int n = 1;
    tipo.IdTipoTelefone = n;
    tipo.Tipo = n;
    n = n + 1;
    return tipo;
}   // f_TipoTelefone()

Esse cria os 4 arquivos com um numero qualquer de elementos. Bem melhor que ficar digitando... Ou não?

clientes.txt
enderecos.txt
telefones.txt
tipos.txt

Clientes

0001Cliente0001                                       
0002Cliente0002                                       
0003Cliente0003                                       
0004Cliente0004

Enderecos

0001Rua Via0001 20001000
0002Rua Via0002 20002000
0003Rua Via0003 20003000

Telefones

0001+55 (11) 930010001  
0002+55 (11) 930020002  
0003+55 (11) 930030003  
0004+55 (11) 930040004  
0005+55 (11) 930050005  
0006+55 (11) 930060006  
0007+55 (11) 930070007  
0008+55 (11) 930080008

Tipos

E a vida continua.

É assim quando você precisa terminar para poder receber: recortar, colar, copiar, costurar....

vagabond1 · 14 de abril de 2020

@arfneto Perfeito, muito obrigado!

Agora vou trabalhar e estudar um pouco mais esses conceitos e tentar alterar um pouco do codigo para entendimento pessoal.

arfneto · 14 de abril de 2020

2 minutos atrás, vagabond1 disse:

Agora vou trabalhar e estudar um pouco mais esses conceitos e tentar alterar um pouco do codigo para entendimento pessoal

Meu palpite: parta desse código para diante e resolva o problema. Depois você volta a esses detalhes de implementação.

Leia o programa e veja se não entende algo. Algo da linguagem ou alguma das funções.

A lógica ali é bem linear: construir a massa de dados para escrever LOGO o programa

vagabond1 · 14 de abril de 2020

@arfneto Como ainda estou em faze de aprendizagem vou tentar implementar com laços mais simples como printf/scanf pois de qualqer forma preciso escrever via teclado, mas seus exemplos ficaram otimos para prendizagem.

arfneto · 14 de abril de 2020

26 minutos atrás, vagabond1 disse:

Como ainda estou em faze de aprendizagem vou tentar implementar com laços mais simples como printf/scanf pois de qualqer forma preciso escrever via teclado

Eu desisto de tentar explicar. Isso não é mais simples, "laços mais simples". Só com o que te enviei seu programa já passou disso há muito.

O que quer dizer com "laços mais simples"? cada programa que eu te mostrei tem um único loop Achou algo complicado naquilo?

Justamente por estar em fase de aprendizagem você NÃO deve seguir esse caminho. Só fica muito mais lerdo. Eu não tenho mais argumentos. Eu te mostrei como você pode começar a testar e construir seu programa. Com dados significativos. De qualquer tamanho. Sem fazer nada exceto digitar 4 números. Agora. E terminar seu programa amanhã. Tipo assim.

Acha mesmo que é esperto ficar em frente ao terminal inventando logradouros e ruas e telefones 5 minutos para cada teste?
Não é. Eu nem sei porque ensinam a programar deste modo. Não é produtivo. Não é inteligente. E estou relativamente acostumado com isso. Programo computadores desde os anos 70. E eu de fato gostaria que quando eu comecei alguém tivesse me dito as coisas que eu te expliquei...

Se você entendeu o que são os registros X:Y:Z que ligam o cliente aos telefones e endereços, esse é o caminho: os bancos de dados funcionam assim e com certeza eles não estão errados. Se você não entendeu devia ter perguntado.

vagabond1 · 14 de abril de 2020

@arfneto Amigo sendo bem sincero, não gosto de programação mas tenho que fazer isso para me formar. Não quero seguir carreira como programador, no MOMENTO desejo aprender somente o essencial, futuramente caso eu crie interesse vou fazer cursos ou algo do tipo pois faculdade o ensino de programação é um completo LIXO. Mas muito obrigado pela ajuda.

arfneto · 15 de abril de 2020

33 minutos atrás, vagabond1 disse:

aprender somente o essencial

por certo o essencial não é uma sequência de printf() e scanf() O essencial é o que resolve pra você poder seguir em frente. Implemente as relações, termine o programa. Já tem uns 80% do trabalho pronto.