Newsgroup: it.comp.lang.c
Titolo: creare libreria

Ciao,
non so se è una domanda da FAQ ma non ho trovato informazioni semplici 
per quello che cerco (forse perchè non so bene cosa cercare...).
Ho scritto alcune funzioni C che uso regolarmente nei miei codici. 
Vorrei evitare di riportarle ogni volta nel file principale e mi 
piacerebbe creare una libreria. Scrivere cioè #include <myfunc.h> e 
utilizzare le mie funzioni contenute.
Come posso fare?
Suggerimenti o indicazioni a post/pagine web sono graditi!
Marco / iw2nzm

 Come posso fare?
Scusate, come non detto... ho risolto!
Bastava salvarle con estensione *.h e includere il file nel sorgente.
Marco / iw2nzm

Marco Trapanese ha scritto:

No, sbagli. Quello che fai causa solo problemi anche se sembra 
funzionare. So che molti manuali scadenti chiamano i file da includere 
"librerie", ma non lo sono. I file .h o in generale i file da includere 
sono file header, che contengono (e devono contenere, nel caso che sia 
tu a crearli) le dichiarazioni delle funzioni delle libreria con cui 
vengono distribuiti, le strutture, le costanti, le macro, ecc.. ma non 
il codice delle funzioni (tranne che per le inline del c99 che ci 
possono stare). La libreria e' un file che invece contiene solo il 
codice delle funzioni, gia' compilato, quindi in un formato 
comprensibile dal processore. Su win hanno estensione .lib (di solito), 
mentre su linux hanno estensione .o (di solito) e non vengono mai 
incluse. Al massimo puoi dire al compilatore, sempre che non ci pensi 
gia' da solo, quali librerie linkare al tuo eseguibile. Infatti quando 
compili il tuo compilatore lascia un riferimento ogni volta che trova la 
chiamata a una funzione. Poi sara' il linker a unire al tuo eseguibile 
la libreria che contiene quella funzione e ad adattare il riferimento 
(ricorda che sto parlando solo di linking statico), mentre il file .h 
che hai incluso serve solo per avere le costanti, i tipi e le 
dichiarazioni delle funzioni in modo da conoscere il tipo di ritorno e i 
parametri e quindi evitare errori da parte tua.
Se vuoi realizzare una libreria vera e propria fatta bene devi 
documentarti sul tuo compilatore, perche' ognuno ha il suo modo. Con gcc 
per esempio devi scrivere un file sorgente che contiene le funzioni 
(main non serve) e poi lo compili con 'gcc sorgente.c -c -o libreria'. 
Il file .h e' quello che hai usato per sorgente.c, non cambia.
Esempio:
---libreria.h---
#define MAX_VALUE 100
struct zoid{
	int a;
	char b;
};
int doppio(int);
int piudue(int);
struct zoid prova(float);
----------------
---libreria.c---
#include "libreria.h"
int doppio(int a)
{
return a*2;
}
int piudue(int x)
{
if(x<MAX_VALUE)
	return x+2;
return 0;
}
struct zoid prova(float u)
{
struct zoid zz;
return zz;
}
----------------
Alla fine compili con 'gcc libreria.c -c -o libreria.o -Wall' e se tutto 
va bene nella tua directory troverai (oltre al resto) la tua libreria 
col nome libreria.o
Quando vorrai usare le sue funzioni in un programma dovrai includere il 
file header libreria.h per i motivi gia' spiegati e in piu' dovrai dire 
al compilatore che il codice delle funzioni risiede nel file libreria.o 
(la *vera* libreria).
--programma.c--
#include "libreria.c"
int main()
{
doppio(5);  /*<-- la dich. sta in libreria.c, il codice in libreria.o*/
return 0;
}
---------------
gcc programma.c libreria.o -o prog_eseguibile -Wall
Questo e' solo un esempio ridicolo, sta a te adattarlo a quello che ti 
serve e al tuo sistema operativo. Spero che sia tutto giusto...
-- 
Devaraja (Xdevaraja87^gmail^c0mX)
Linux Registerd User #338167
http://counter.li.org

 }
-- 
quando il sospiro di vento nasconde 
in un custode di neve 
assenza d'autunno

 
Ops.. e' vero :-)


Marco Trapanese ha scritto:


Esempio:

---libreria.c---
#include "libreria.h"




--programma.c--
#include "libreria.h"
int main()
{
doppio(5);  /*<-- la dich. sta in libreria.h, il codice in libreria.o*/
return 0;
}
---------------
gcc programma.c libreria.o -o prog_eseguibile -Wall
Questo e' solo un esempio ridicolo, sta a te adattarlo a quello che ti 
serve e al tuo sistema operativo. Spero che sia tutto giusto...


 
Ecco, ora dovrebbe essere tutto a posto. Ho tolto il messaggio con gli 
errori e l'ho rimpiazzato con la seconda versione. Speriamo bene, ma 
proprio non ho tempo per rimetterlo giu' meglio.


 serve e al tuo sistema operativo. Spero che sia tutto giusto...
Se non vuoi creare la libreria e` piu` semplice:
$ cc programma.c libreria.c -o mioprogramma
Al compilatore puoi dare piu` file .c per generare un solo eseguibile.
PS:	in ambiente unix serebbe meglio imparare ad usare make


 per linking statico oppure .dll per linking dinamico
[cut]
Mi aggancio qui.
Non ho specificato prima, lo faccio ora, il codice che scrivo gira su un 
microcontrollore PIC e il compilatore che uso è della CSS, con funzioni 
dedicate ai uC. Quello che avete scritto immagino sia valido ugualmente 
facendo attenzione alle caratteristiche del compilatore.
A questo punto credo che manderò una mail a quelli della CCS così chiedo 
loro se è possibile compilare file per usarli poi come librerie.
A voi domando per cortesia di spiegarmi come mai includere un file *.h 
(o *.c) non sia una buona scelta. Inotlre, il compilatore include nel 
file esegubile solo le funzioni chiamate nel codice, vero?
Grazie a tutti,
Marco / iw2nzm

 Marco / iw2nzm
You're welcome.


 non richiamato altrove.
Questo non lo sapevo!
Scusa ma se io ho un unico file *.c (dove c'è il main) e scrivo funzioni 
non chiamate, il compilatore non le include nel file eseguibile se ben 
ricordo! Perchè dovrebbe farlo su file esterni? Se così fosse, quale è 
il motivo per cui fa questa cosa?
Ciao!
Marco / iw2nzm

Giovanni ha scritto:

Incredibile... per tutto questo tempo l'ho sempre saputo sbagliato.. e 
non l'avrei mai scoperto, perche' funzionava. Questa e' la prova che non 
si devono usare mai manuali di seconda scelta (del tipo "il c in 4 
minuti") perche' sembrano piu' veloci: i danni che fanno li paghi per 
molto tempo. Io me ne sono accorto dopo poche settimane e sono passato 
subito al k&r, ma qualche cazzata l'avevo gia' imparata :-( Non parliamo 
poi dei testi scolastici...


 il motivo per cui fa questa cosa?
Credo proprio che sbagli.  O quel compilatore e` una cosa speciale, 
diverso da tutti gli altri e contrario a tutti gli standard.
Ma con quel compilatore non puoi fare un programma suddiviso in piu` 
file .c?  Come fa il compilatore a sapere che una funzione non venga 
richiamata da funzioni definite in un altro file?
Rivedi bene la documentazione che forse ti sta sfuggendo qualche cosa.


 chiamate nel codice, vero?
Il compilatore non crea un eseguibile, ma dei file oggetto. Dentro i file 
oggetto finiscono tutte le funzioni che hai dichiarato, tranne, in 
alcuni casi, le funzioni static che non usi mai.
Il linker crea un eseguibile, e mette assieme quel che serve, a partire
dai file oggetto e dalle librerie. Il linker della GNU, per quel che ho
capito io, non spezza mai i file oggetto, ma e' capace di attaccare un
solo file oggetto preso da una libreria statica che ne contenga anche
altri. Per le librerie dinamiche il problema non si pone: nell'eseguibile
ci va solo un riferimento alla libreria, non il codice binario delle
funzioni.
 Ciao
 Federico