C por que usar arquivos "HEADER.H"

[devair1010]

 nos estudos sobre header vi que servem para organizar o código e reduzir a quantidade de dados dentro da função principal "main.c" ,  porém notei que usando apenas o arquivo ".c" que contém as funções e sem usar um arquivo do tipo ".h" , que só contém os protótipos das funções que estão no arquivo ".c"  , o código funciona bem . como nesse pequeno código :

#include    "funcs.c" /// apenas o arquivo ponto c
                      /// que contém as funCOes 
int main(int argc, char* argv[] )
{
  printf
  (
    "valor de pi ----= %.6f\n"
    "Cubo -----------= %d  \n"
    "Quadrado -------= %d  \n"
    "Soma -----------= %d  \n"
    "Seno -----------= %f  \n"
    ,pi, Cubo(3), Quadrado(5)
    , Soma(7), Seno(167)
  );

  return   0;
}

e com essas funções no arquivo com formato ".c" :

#define     pi    3.141592
#include    <stdio.h>
#include    <stdlib.h>
#include    <string.h>
#include    <math.h>
#include    <math.h>
int Cubo(int x)
{
  return x*x*x;
}
int Quadrado(int x)
{
  return x*x;
}
int Soma(int x)
{
  return x+x;
}
float Seno(float x)
{
  return sin(x)/180+250;
}

 

[arfneto]

1 hora atrás, devair1010 disse:

 nos estudos sobre header vi que servem para organizar o código e reduzir a quantidade de dados dentro da função principal "main.c" ,  porém notei que usando apenas o arquivo ".c" que contém as funções e sem usar um arquivo do tipo ".h" , que só contém os protótipos das funções que estão no arquivo ".c"  , o código funciona bem

 

Não é por isso.

 

Imagine que você escreveu um programa que usa listas ligadas. Bem genérico. E quer claro usar toda hora que precisa de uma lista. Você não quer usar os arquivos .c. Você não quer nem ver os arquivos .c.

 

E você pode vender o código em um arquivo .lib.

 

Qualquer um que tiver esse arquivo .lib vai poder usar seu código para listas. Sem mudar nadinha. Só que você não quer que outros caras ou outras empresas leiam seu código, ou os caras vão copiar para todo o sempre e para todo mundo. C não é Python ou javascript ou Visual Basic ou algo interpretado: não precisa mais do fonte se não for mudar. E você não escreve programas para ficar mudando. Mas como vai fazer para conseguir usar o código? Precisa do .h para poder ter as funções.

 

Exemplo:

 

Esse código é para um container. Eu escrevi para usar como um simples vetor como em C++. Pode ter qualquer coisa dentro.

 

#pragma once
#include <stdio.h>
typedef struct
{
    size_t limit;          // capacity
    size_t size;           // actual size
    void** item;           // an array of pointers to items
    void* (*copy)(void*);  // copy
    void* (*destroy)(void*);          // destructor
    int (*show)(void*, const char*);  // print
} Container;                          // a collection

int        ctn_capacity(Container*);
int        ctn_clear(Container*);
Container* ctn_create(
    size_t, void* (*copy)(void*), void* (*destroy)(void*),
    int (*show)(void*, const char*));
Container* ctn_destroy(Container*);
int        ctn_empty(Container*);
int ctn_insert(void*, Container*, int(cmp)(void*, void*));
int ctn_pop_back(Container*);
int ctn_push_back(void*, Container*);
int ctn_resize(Container*, const size_t);
int ctn_show(Container*, const char*);
int ctn_sort(Container*, int(cmp)(void*, void*));
int ctn_size(Container*);

 

Se isso aí funcionar então eu posso usar em qualquer canto, sem nem pensar mais em como um tal container aloca memória ou expande o array ou apaga tudo. Não vou ler container.c

 

É o caso de usar printf por exemplo. Apenas se inclui o header, stdio.h e o linker acha o código pré-compilado e agrega ao código do programa e a vida segue. Você não recomplila printf. Não vê o fonte de printf.

 

 

 

 

[Flávio Pedroza]

Do jeito que está seu código atualmente (com <code>#include "funcs.c"</code>) TODAS as vezes que compilar o programa principal ele irá compilar as instruções contidas no funcs.c também. 

Se usar o header .h, o funcs.c é compilado apenas uma vez (ou quando fizer alguma alteração no arquivo funcs.c) - depende, é claro, das configurações e diretivas do compilador/ide, mas em geral é assim.

No caso do seu exemplo, como é pequeno, nem tem muita diferença, mas em projetos grandes, você economiza muitos minutos de compilação. 

 

[arfneto]

4 horas atrás, Flávio Pedroza disse:

Se usar o header .h, o funcs.c é compilado apenas uma vez (ou quando fizer alguma alteração no arquivo funcs.c) - depende, é claro, das configurações e diretivas do compilador/ide, mas em geral é assim.

No caso do seu exemplo, como é pequeno, nem tem muita diferença, mas em projetos grandes, você economiza muitos minutos de compilação.

 

Não deixe de considerar o que eu expliquei: o header e seu código em arquivos .lib, .a  ou .DLL, permitem que outros --- ou você --- possam usar o código SEM TER ACESSO AO PROGRAMA ORIGINAL.

 

É assim que se vende sofware, coisas como frameworks ou drivers. Considere cada #include em seu programa C  , ou coisas como a API do Windows ou a libc no Linux. Tem os headers, as funções são incluídas e todo mundo usa tais funções.

[devair1010]

@arfneto e  @Flávio Pedroza , obrigado , pela ajuda ,
usei o codeblocks para acessar o código da biblioteca "stdio.h" e nela tem apenas os protótipos das funções e muitos define's , e DLLs ,  e então tentei encontrar o arquivo ".c" dessa biblioteca , porém não localizei em nenhuma pasta do local onde está instalado o compilador / IDE ,   e então se o código está em uma dessas dll , teria como saber em qual delas está o "stdio.c"

[arfneto]

13 minutos atrás, devair1010 disse:

usei o codeblocks para acessar o código da biblioteca "stdio.h" e nela tem apenas os protótipos das funções e muitos define's

 

Isso é o que tem em um header. É o esperado. Raramente tem código. Talvez a principal razão de usar um header file é não ter que enviar o fonte para todo mundo que usa o header... 

 

15 minutos atrás, devair1010 disse:

e então se o código está em uma dessas dll , teria como saber em qual delas está o "stdio.c"

 

Mais fácil encontrar a fonte do lado do Linux. (Extra oficial) pode ver nesse endereço algo https://github.com/bminor/glibc ou em https://github.com/lattera/glibc

 

Mas a ideia é justamente o contrário: usar o header e as funções e escrever seus programas a partir dessas ferramentas.

 

 

 

[Ansi C]

@devair1010 organização e compartilhamento.

 

Organização

Aos iniciantes, quase sempre, inspira-se depositar declarações neste tipo. Vê-se, pelo menos, assim um para:

 

Declaração de tipos

                  ... macros

                 ... funções

  ... variáveis globais

 

coisas comuns com compartilhamento no projeto.