Laboratorium 2: Biblioteki statyczne i dynamiczne w języku C. mgr inż. Arkadiusz Chrobot

Transkrypt

1 Laboratorium 2: Biblioteki statyczne i dynamiczne w języku C mgr inż. Arkadiusz Chrobot 21 października 2010

2 1 Wprowadzenie Pisząc programy w języku C, szczególnie te duże, nie musimy umieszczać całości kodu źródłowego w jednym pliku. Podobnie jak w innych językach programowania możemy podzielić go na niezależne części, które mogą być kompilowane osobno i w razie konieczności włączane do innych programów. Takie pliki nazywamy bibliotekami. W języku C z bibliotekami związanie są pliki nagłówkowe, które ułatwiają korzystanie z nich. Ta instrukcja wyjaśnia w jaki sposób stworzyć własną bibliotekę statyczną lub dynamiczną i jak jej użyć w innym programie. 2 Definicje i deklaracje zmiennych oraz funkcji Aby móc użyć w programie zmiennej zdefiniowanej w innym pliku musimy posłużyć się jej deklaracją. Deklaracja zmiennej informuje kompilator, że zmienna o podanej nazwie i typie została już wcześniej w kodzie zdefiniowana. Definicja zmiennej informuje kompilator, że w miejscu jej umieszczenia trzeba przydzielić pamięć na tę zmienną i ją zainicjalizować. Każdy z plików z kodem źródłowym może zawierać osobną deklarację jednej i tej samej zmiennej nawet ten, który zawiera jej definicję (przydaje się, jeśli chcemy użyć zmiennej przed jej zdefiniowaniem). Definicja zmiennej może występować tylko w jednym pliku. Aby zadeklarować zmienną należy przed jej typem i nazwą umieścić słowo kluczowe extern. Definicja polega na podaniu typu i nazwy zmiennej. Jeśli w żadnym z plików nie zadeklarujemy zmiennej, to jej definicja stanie się równocześnie jej deklaracją. Dotychczas w programach używaliśmy właśnie takiej łącznej deklaracji i definicji. Odwrotna sytuacja, czyli podanie deklaracji zmiennej bez definicji powoduje błąd czasu kompilacji. Poniżej znajduje się przykładowy kod źródłowy, który został podzielony na dwa pliki. i n t foo ; external.c #include <s t d i o. h> prog1.c extern i n t foo ; i n t main ( void ) p r i n t f ( %d\n, foo ) ; r eturn 0 ; Czytając kod można zauważyć, że w pliku o nazwie prog1.c została użyta zmienna foo, która jest w tym pliku jest jedynie zadeklarowana. Jej definicja znajduje się w pliku external.c. Wartość początkowa tej zmiennej wynosi 0, bo jest to zmienna globalna. Jeśli chcielibyśmy w pliku external.c umieścić dodatkową zmienną, widoczną tylko w tym pliku to przed jej definicją powinniśmy umieścić słowo kluczowe static. Podobnie jak ze zmiennymi możemy postąpić z funkcjami. Aby użyć funkcji zdefiniowanej w innym pliku wystarczy umieścić jej nagłówek przed miejscem jej 1

3 wywołania, poprzedzając go słowem kluczowym extern. W nagłówku tym można pominąć nazwy argumentów, zostawiając wyłącznie typy. Oto przykład: #include <s t d i o. h> external2.c void p r i n t ( i n t v a r i a b l e ) p r i n t f ( %d\n, v a r i a b l e ) ; extern i n t foo ; extern void p r i n t ( i n t ) ; prog2.c i n t main ( void ) p r i n t ( foo ) ; r eturn 0 ; Program zapisany w pliku prog2.c korzysta również ze zmiennej foo z pliku external.c Proszę zwrócić uwagę, że tylko w pliku external2.c konieczne było włączenie pliku nagłówkowego stdio.h. Kompilacja tak napisanych programów składa się z kilku etapów. Najpierw musimy skompilować pliki, w których zdefinowane są funkcje i/lub zmienne. Tą kompilację należy wykonać tak jak pokazuje przykład 1. Opcja -c powoduje, że kompilator gcc -Wall -c library.c Przykład 1 utworzy plik obiektowy 1, o takiej samej nazwie jak plik z kodem źródłowym, ale o rozszerzeniu.o, który będzie można połączyć (ang. link) z innym plikiem. Po wykonaniu kompilacji wszystkich bibliotek możemy przystąpić do skompilowania programu głównego. Kompilację tą wykonuje się podobnie jak w kolejnym zamieszczonym przykładzie 2. Przykład 2 gcc -Wall -o program program.c library.o library2.o 3 Pliki nagłówkowe Dzięki plikom nagłówkowym możemy zebrać w jednym miejscu deklaracje wszystkich zmiennych i funkcji, których definicję są rozproszone po wielu plikach. Włącza- 1 Ta nazwa nie ma nic wspólnego z programowaniem zorientowanym obiektowo. 2

4 jąc odpowiednio przygotowany plik nagłówkowy do innych plików z kodem źródłowym unikamy konieczności wielokrotnego przepisywania deklaracji wspomnianych elementów programu. Spróbujmy zastosować plik nagłówkowy w ostatnim przykładowym programie z poprzedniego rozdziału. #i f n d e f HEADER H #d e f i n e HEADER H header.h extern i n t foo ; extern void p r i n t ( i n t ) ; #e n d i f #i n c l u d e header. h i n t foo ; external.c #include <s t d i o. h> #i n c l u d e header. h external2.c void p r i n t ( i n t v a r i a b l e ) p r i n t f ( %d\n, v a r i a b l e ) ; #i n c l u d e header. h prog2.c i n t main ( void ) p r i n t ( foo ) ; r eturn 0 ; Jak widać na załączonych listingach deklaracje zmiennej foo oraz funkcji print zostały umieszczone w pliku nagłówkowym. Można również zauważyć, że te deklaracje otoczone są instrukcjami poprzedzonymi znakiem #. Są to instrukcje preprocesora, które zapobiegają wielokrotnemu włączeniu wspomnianych deklaracji w wypadku gdybyśmy mieli do czynienia z kilkoma plikami nagłówkowymi, które wzajemnie się włączają. Zasada działania tego tych instrukcji zwanych wartownikami pliku nagłówkowego zostanie wyjaśniona w następnej instrukcji. Zaważmy, że stworzony przez nas plik nagłówkowy został włączony do wszystkich plików z rozszerzeniem.c za pomocą instrukcji include, ale nazwa tego pliku nie jest ujęta w nawiasy trójkątne, tylko w cudzysłów. Informuje to kompilator, że powinien poszukać naszego pliku nagłówkowego w katalogu bieżącym. Moglibyśmy umieścić 3

5 nazwę naszego pliku w nawiasach trójkątnych, ale wówczas musielibyśmy dołączyć katalog z naszym plikiem nagłówkowym do listy katalogów, które będą przeszukiwane przez kompilator (opcja -I ). Włączenie pliku nagłówkowego do pliku z kodem źródłowym, gdzie definiowana jest zmienna lub funkcja w opisywanym przykładzie jest opcjonalne, ale pozwala kompilatorowi na etapie kompilacji sprawdzić, czy nie ma rozbieżności między definicją i deklaracją funkcji i zmiennej. W sytuacji gdy plik nagłówkowy zawiera definicje typów lub makr preprocesora takie włączenie jest konieczne. Reasumując - zawsze opłaca się włączyć plik nagłówkowy do wszystkich plików źródłowych z nim związanych. W pliku nagłówkowym powinniśmy unikać umieszczania definicji zmiennych i funkcji, poprzestając tylko na deklaracjach. Słowo kluczowe extern przed nagłówkiem funkcji jest opcjonalne. 4 Program make Kiedy mamy kod źródłowy programu podzielony na kilka plików (jednostek kompilacji) konieczne staje się kilkukrotne wywołanie kompilatora z linii poleceń. Taka metoda kompilacji jest w przypadku dużych projektów zbyt czasochłonna. Rozwiązaniem tego problemu jest użycie narzędzia do kompilacji rozłącznej, jakim jest program make. Wielokrotna kompilacja przy pomocy tego programu sprawdza się wyłącznie do wypisania jego nazwy w linii poleceń i naciśnięcia klawisza Enter. Zanim jednak tak się stanie należy przygotować specjalny plik o nazwie Makefile, który będzie zawierał odpowiednie reguły dla takiej kompilacji. Oto plik Makefile dla przykładu, który był omawiany w poprzednim rozdziale. CC = gcc OFLAGS = Wall o CFLAGS = Wall c Makefile prog2 : prog2. c e x t e r n a l 2. o e x t e r n a l. o $ (CC) $ (OFLAGS) prog2 prog2. c e x t e r n a l. o e x t e r n a l 2. o e x t e r n a l 2. o : e x t e r n a l 2. c $ (CC) $ (CFLAGS) e x t e r n a l 2. c e x t e r n a l. o : e x t e r n a l. c $ (CC) $ (CFLAGS) e x t e r n a l. c c l e a n : rm f rm f rm f. o. a c l e a n a l l : c l e a n rm f prog2 Na początku tego pliku znajdują się deklaracje zmiennych, które posłużą do zdefiniowania odpowiednich reguł. Zmiene te definowane są poprzez podanie ich nazwy i nadanie im wartości za pomocą operatora =. W powyższym przykładzie tymi 4

6 wartościami są nazwa kompilatora oraz flagi kompilacji. Pierwsza reguła która zostanie zdefiniowana w pliku Makefile jest wykonywana domyślnie. W przykładowym pliku ta reguła nazywa się prog2 i powoduje skompilowanie pliku zawierającego funkcję main. Regułę definiuje się podając jej nazwę, która może (lecz nie musi) być taka sama jak nazwa pliku powstającego w wyniku wykonania tej reguły. Po nazwie stawiamy dwukropek. Po nim należy podać nazwy reguł, które muszą być wykonane przed definiowaną regułą. Opcjonalnie można również podać nazwy plików z kodem źródłowym niezbędnym do wykonania reguły. Działania wykonywane w ramach reguły definiowne są w następnych wierszach. W omawianym przykładzie jest to po prostu takie samo wywołanie kompilatora jakie do tej pory ręcznie wpisywaliśmy w powłoce systemowej. Jedyna różnica polega na zastąpieniu nazwy kompilatora i flag wartościami odpowiednich zmiennych. Wartości te uzyskujemy umieszczając nazwę zmiennej w nawiasach okrągłych, a przed całością stawiając znak dolara. Definicję poszczególnych reguł oddzielamy pustym wierszem. Po zdefiniowaniu pliku Makefile w katalogu z kodem źródłowym programu wystarczy wydać w powłoce systemowej polecenie make żeby wykonać kompilację programu. Tak jak napisano to wcześniej zostanie wykonana reguła prog2 oraz wszystkie inne od których ona zależy. Nie zostaną wykonane natomiast reguły clean i cleanall. Pierwsza z tych reguł jest odpowiedzialna za usunięcie zbędnych plików powstałych podczas kompilacji i edycji plików, a ostania za usunięcie wszystkich plików powstałych podczas kompilacji. Aby je wykonać należy w powłoce systemowej po słowie make wpisać nazwę reguły, która ma być wykonana. Tak możemy postąpić z dowolną regułą zdefiniowaną w pliku Makefile. Możemy również stworzyć regułę, która będzie kompilowała więcej niż jeden program. Wystarczy dla każdego z tych programów stworzyć osobną regułę kompilacji, a następnie jako pierwszą w pliku umieścić regułę która na liście zależności będzie miała wymienione te reguły. Reguła ta może być pusta, tzn. po pierwszym wierszu będą dwa wiersze puste. Program make porównuje czasy powstania plików wynikowych z czasami modyfikacji plików źródłowych. Jeśli plik wynikowy jest starszy od źródłowego, to nie wykonuje związanej z nim reguły kompilacji. Jeśli jest odwrotnie lub jeśli plik wynikowy nie istnieje to reguła jest wykonywana. Jeśli z jakiś powodów nie możemy użyć nazwy Makefile to możemy użyć nazwy makefile lub dowolnej innej. W tym ostatnim przypadku należy programowi make wskazać nazwę pliku z regułami, dodając do jego wywołania przełącznik -f i podając nazwę tego pliku. Program make jest dosyć dobrze zintegrowany z edytorem Vim. Możemy wywołać program make z poziomu tego edytora. Wystarczy w trybie poleceń wydać polecenie :cmake. Jeśli podczas kompilacji pojawią się błędy to możemy przestawiać kursor do wiersza w którym występują za pomocą poleceń :cnext i :cprev. Programu make możemy używać również dla programów napisanych w innych językach programowania. 5 Kompresja bibliotek statycznych Biblioteki statyczne są w całości włączane do kodu wynikowego kompilowanych z nimi programów, zwiększając tym samym objętość plików wynikowych. Istnieją również biblioteki dynamiczne, które nie mają tej wady. Proces ich tworzenia jest opisany w następnym rozdziale. Biblioteki statyczne można archiwizować programem ar. Pliki z rozszerzeniem.o są pakowane do plików z rozszerzeniem.a i zastępują je podczas kompilacji. Oto przykład użycia programu ar : ar rs archiwum.a external.o external2.o. Program używające skompresowanych bi- 5

7 bliotek można skompilować na dwa sposoby. Prostszy polega na umieszczeniu nazwy archiwum w wywołaniu kompilatora (przykład 3). Bardziej skomplikowany Przykład 3 gcc -Wall -o program program.c archiwum.a sposób wymaga odpowiedniej nazwy archiwum. Nie może być ona dowolna, musi rozpoczynać się przedrostkiem lib. W przypadku naszego przykładowego archiwum zamiast nazwy archiwum.a w wywołaniu programu ar należałoby więc umieścić nazwę libarchiwum.a. Taką bibliotekę możemy włączyć do programu za pomocą wywołania kompilatora przedstawionego w przykładzie 4: Uwaga: po opcjach -l, ani Przykład 4 gcc -Wall -o program program.c -L. -larchiwum -L nie występuje spacja! Opcja -l nakazuje włączenie konsolidatorowi do programu wynikowego bibliotek z archiwum o podanej nazwie. Konsolidator (ang. linker) jest programem, który odpowiedzialny jest za łączenie plików obiektowych i tworzenie pliku wynikowego. Jest uruchamiany automatycznie podczas kompilacji, ale może być wywołany również osobno. W polskiej literaturze często używa się jego angielskiej nazwy. Jeśli archiwum znajduje się w domyślnym katalogu lub katalogach, które przeszukuje kompilator podczas pracy, to wystarczy użyć tylko opcji -l. W przeciwnym przypadku należy określić także, który katalog dodatkowo kompilator powinien przeszukać, używając opcji -L. W przykładzie, po opcji -L występuje kropka oznaczająca katalog bieżący. Drugi sposób kompilacji z zarchiwizowanymi bibliotekami jest wygodniejszy, jeśli mamy do czynienia z wieloma bibliotekami, które nie znajdują się w bieżącym katalogu. 6 Biblioteki dynamiczne Biblioteki dynamiczne nazywane są w środowiskach uniksowych bibliotekami współdzielonymi lub obiektami współdzielonymi i zapisywane są w plikach wykonywalnych posiadających rozszerzenie.so. Aby stworzyć taką bibliotekę należy najpierw skompilować pliki obiektowe wchodzące w skład tej biblioteki z opcją -fpic (przykład 5). W wyniku kompilacji powstają pliki obiektowe (z rozszerzeniem.o ), gcc -Wall -c -fpic external.c Przykład 5 które możemy połączyć w jedną bibliotekę odpowiednim wywołaniem kompilatora (przykład 6). Tak powstałą bibliotekę można włączyć do programu na trzy sposoby. Przykład 6 gcc -Wall -shared -fpic -o libexternal.so external.o external2.o Pierwszy polega na wskazaniu konsolidatorowi, w czasie jego pracy, gdzie znajduje 6

8 wymagana biblioteka. Możemy to uczynić za pomocą opcji -Wl,-rpath,katalog kompilatora gcc, gdzie katalog oznacza ścieżkę do katalogu z plikiem biblioteki współdzielonej (przykład 7). Drugi sposób polega na zdefiniowaniu zmiennej środowi- Przykład 7 gcc -Wall -o prog2 prog2.c -L. -lexternal -Wl,-rpath,. skowej LD LIBRARY PATH lub na zmianie jej wartości, tak aby uwzględniała katalog, w którym znajduje się biblioteka współdzielona. Przykład 8 pokazuje jak to zrobić używając powłoki Bash. Jeśli odpowiednio ustawimy wartość tej zmiennej, to Przykład 8 export LD LIBRARY PATH=$LD LIBRARY PATH:. w wywołaniu kompilatora z przykładu 7 możemy pominąć opcję -Wl,-rpath. Trzeci sposób polega na dodaniu odpowiedniego wpisu w pliku /etc/ld.so.conf i uruchomieniu programu ldconfig, ale ta metoda wymaga posiadania specjalnych uprawnień, więc nie każdy użytkownik może z niej skorzystać. Jeśli chcemy dowiedzieć się z jakich bibliotek współdzielonych korzysta program, to możemy użyć programu ldd, który może być wywołany na przykład tak: ldd program. Zaletą bibliotek współdzielonych jest to, że są ładowane do pamięci dopiero wtedy, gdy odwoła się do nich choć jeden proces oraz to, że z jednego egzemplarza biblioteki znajdującego się w RAM komputera może korzystać wiele procesów równocześnie. Biblioteki współdzielone są również dostępne w systemach rodziny Windows, ale pod inną postacią. 7 Dynamiczne ładowanie bibliotek współdzielonych Biblioteki dynamiczne nie muszą być łączone z programem podczas kompilacji. Program może sam je załadować podczas wykonania. Takie rozwiązanie umożliwia tworzenie wtyczek (ang. plug-ins). Funkcje, które są niezbędne do skorzystania z tej możliwości nazywają się dlopen(), dlsym(), dlerror() i dlclose() i wymagają włączenia do kodu źródłowego programu pliku nagłółkowego dlfcn.h. Poniżej znajduje się przykład programu, który korzysta z tej możliwości. #include <d l f c n. h> #i n c l u d e header. h prog3.c i n t main ( void ) void handle = dlopen ( l i b e x t e r n a l. so,rtld LAZY) ; void ( p r i n t ) ( i n t ) = dlsym ( handle, p r i n t ) ; i n t foo = dlsym ( handle, foo ) ; ( p r i n t ) ( foo ) ; d l c l o s e ( handle ) ; r eturn 0 ; 7

9 Funkcja dlopen() ładuje bibliotekę o podanej przez argument nazwie do pamięci i zwraca wskaźnik na nią. Funkcja dlsym() zwraca wskaźnik adres symbolu z biblioteki, którego nazwę jej przekazujemy. Jeśli tym symbolem jest funkcja, to zwrócony adres należy zapisać we wskaźniku na funkcję i za jego pomocą tę funkcję wywoływać. Funkcja dlclose() usuwa z pamięci załadowaną bibliotekę. Bezpośrednio po każdym z wywołań tych funkcji należy (czego nie uczyniono w przykładzie) wywołać funkcję dlerror(). Jeśli wystąpi wyjątek podczas wykonywania wcześniej opisanych funkcji, to dlerror() zwróci jego opis, jesli nie, to natychmiast zakończy swoje działanie. Programy używające wyżej wymienionych funkcji należy kompilować z flagą -ldl. 8