Newsgroup: it.comp.lang.c
Titolo: Come si "aggancia" una propria libreria ad un file intestazione?

Salve a tutti.
Sono un neofita che, tra le tante cose, non riesce a capire come fare ad 
agganciare un file intestazione ad una libreria personalizzata.
Cioe':
ho tre mie funzioni in un file che ho compilato come oggetto, questo 
perche' mi piacerebbe avere a disposizione una libreria che 
all'occorrenza possa venire agganciata-inglobata in questo o in 
quell'altro progetto C.
Ora, se non ho capito male, quando in un sorgente C si vuole importare il 
codice di una qualche libreria, bisogna mettere l'include con il file 
d'intestazione corrispondente (.h) che contiene i prototipi delle mie tre 
funzioni inserite nella libreria.
Pero', praticamente come funziona? Come fa a sapere il file 
d'intestazione che deve andare a pescare proprio una certa libreria che 
ha un certo nome?
Forse al file d'intestazione bisogna dare lo stesso nome dato alla 
libreria?
Chi mi da per favore una mano?
Ciao e grazie.
marco

 Chi mi da per favore una mano?
HTH
C:\>iao Angelo
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it


per quanto ne so io (molto poco, in verità...) basta che ti crei un file
chiamato che so, mioheader.h, e ci scrivi dentro tutte le tue funzioni, così
come le scriveresti in un normale programma (dichiari le funzioni prima, poi
scrivi le scrivi dopo...). quando poi devi usarle in un programma, basta che
fai
#include <mioheader.h>
e chiami la funzione che ti serve.
forse ho dimenticato qualcosa, perchè non so quali sono le parti essenziali
di un header, ma cmq il concetto è questo...
Raffaele

 :-)
Ci ho gia' provato a leggere quel fottuto manuale  :), ma, se ho capito 
il meccanismo dei prototipi e della suddivisione dei grossi progetti, mi 
e' abbastanza oscuro il discorso librerie gia' compilate e corrispondenti 
file intestazione (.h) che non facciano gia' parte dell'ambiente ma che 
debbano essre creati da zero dall'utente (come nel mio caso).
Dal tuo intervento pero' mi e' gia' piu' chiara qualcosina.
Cioe', ho capito che nel momento in cui voglio creare un eseguibile da un 
file sorgente e da eventuali file oggetto (librerie incluse), basta che 
lo indichi chiaramente al compilatore con gli appositi switch.
I dubbi rimanenti pero', a parte quelli summenzionati, sono del tipo:
-Come fa il linker a sapere quali funzioni "prendere" dalla libreria gia' 
compilata? Mettiamo che nella libreria ci siano compilate 10 funzioni, ma 
io nel mio progetto ne ho utilizzate 4, chi informa il linker quali 
prendere e come trattarle (nel caso tu mi dica che non serve il file 
intestazione con i prototipi delle funzioni usate)?
Ueee, grazie a te e a Raffaele per gli aiuti-suggerimenti  :)
Ciao, marco

 libreria?
Grande confusione...
I file header contengono semplicemente le dichiarazioni delle funzioni.
Eventualmente anche quelle implementate nella tua libreria.
Le dichiarazioni servono al compilatore, in pratica per controllare che 
le funzioni vengano utilizzate esattamente per come sono dichiarate.
Per il compilatore questo è sufficiente. Infatti, un sorgente che 
utilizza le funzioni della tua libreria viene regolarmente compilato 
anche in *assenza* della libreria, basta che le funzioni siano 
dichiarate. 
La libreria serve al linker nella fase successiva. Il linker è un 
aggeggio che prende tutti gli oggetti compilati, le librerie, controlla 
che tutte di tutte le funzioni *usate* (non dichiarate!) ci sia 
l'implementazione, mette tutto insieme e crea l'eseguibile.
La tua libreria la devi semplicemente specificare al linker.
-- 
---
In silenzio anche un idiota sembra intelligente. Ma non c'è problema,
l'idiota vuol sempre dire la sua.

 ha scritto nel messaggio
news:MPG.180fa7f3f...@News.CIS.DFN.DE...

Uhff... mettiamo un po' d'ordine in questo thread di messaggi... non mai
sentito tante "sciocchezze" tutte in una volta [lo so... lo so... i newbie
fanno questo e altro ma se NON le faccessero non si chiamerebbero cosě :-)].
Mettiamo in chiaro alcuni punti salienti:
1) Un file header NON si aggancia ad una libreria (č un file di testo NON un
modulo oggetto!).
2) Il link delle funzioni viene fatto da un qualcosa che si chiama linker.
Che in, un ambiente di sviluppo integrato (IDE) per C/C++, viene chiamato
dopo che i file sono stati dati in "pasto" al preprocessore e al compilatore
(in ambienti non IDE si usa MAKE ma questo č un altro discorso).
La funzione principale del linker č quella di risolvere i simboli che sono
sparsi nei vari moduli oggetto, generati dal compilatore, del progetto e di
inserire il codice di start-up per la funzione "main()" o "WinMain()".
3) I file "header" servono a condividere le intestazioni o prototipi delle
funzioni tra i vari file sorgenti con estensione ".C".
4) Nei file "header" possibilmente NON vanno MAI implementate le funzioni
(quest'ultime vanno implementate nei file .C); a meno che non le si voglia
rendere "inline".
5) Esistono librerie a collegamento statico e a collegamento dinamico cioč,
per farla breve, librerie che vengono inglobate direttamente nell'eseguibile
e librerie che vengono caricarte al tempo d'esecuzione (run-time).
Per creare queste librerie di funzioni bisogna far riferimento al manuale (o
l'help) del compilatore che si ha sottomano. Perchč la procedura varia da
compilatore a compilatore.
In linea di massima la cosa funziona cosi...
/* amodule.h */
#ifndef AMODULE_H
  #define AMODULE_H
  int aFunction(int aParameter);
#endif
/* amodule.c */
#include "amodule.h"
int aFunction(int aParameter) {
  aVar = -1;
  if (aParameter > 0) aVar = 1;
  return aVar;
}
/* amain.c */
#include <stdio.h>
#include "amodule.h"
void main(int argc, char* argv[]) {
  printf("Il valore di aFunction č: %i", aFunction(2));
}
Ok... quindi, dopo essere stati pre-processati e compilati vengono generati
due file oggetto:
1) amodule.obj
2) amain.obj
Quindi mettiamo il caso che vogliamo creare una libreria statica... a
seconda delle opzioni del compilatore viene generato un file con un nome,
nel nostro caso, di amodule.lib con all'interno amodule.obj.
Per produrre l'eseguibile bisogna fare il link con amain.obj piů la nostra
libreria.
Se vogliamo utilizzare questa libreria da un'altra parte dobbiamo portaci
"appresso" anche il file header relativo.
Naturamente se modifichiamo il file header aggiungendo funzioni dobbiamo
modificare anche il suo compagno ".C" e ricompilare la libreria.
Sperando di essere stato chiaro e non troppo banale...
Saluti
Rosario Ianuale
P.s.: mi scuso se ho scritto delle cose "terra-terra" ma leggendo i vostri
post non sapevo come affrontare l'argomento.

 intestazione con i prototipi delle funzioni usate)?
Io non ho detto che non serve il file di intestazione, volevo dire che
librerie e  file di  intestazione possono tranquillammente  avere nomi
diversi  (questo e'  quello che  succede  di solito),  visto che  sono
indipendenti l'uno dall'altro.
Se il prototipo di funzione di libreria lo metti nel tuo sorgente, puoi
tranquillamente fare a meno del file di include.
ATTENZIONE!  Quello  descritto  e'  un  plausibile  funzionamento  del
processo di  generazione di un  eseguibile. Il processo  reale dipende
dal compilatore usato.
