Preprocesor języka C, biblioteki dzielone

Transkrypt

1 języka C, biblioteki dzielone Bogdan Kreczmer Katedra Cybernetyki i Robotyki Wydziału Elektroniki Politechnika Wrocławska Kurs: Copyright c 2018 Bogdan Kreczmer Niniejszy dokument zawiera materiały do wykładu dotyczącego programowania obiektowego. Jest on udostępniony pod warunkiem wykorzystania wyłącznie do własnych prywatnych potrzeb i może on być kopiowany wyłącznie w całości, razem z niniejszą stroną tytułową. języka C, biblioteki dzielone

2 Niniejsza prezentacja została wykonana przy użyciu systemu składu L A TEX oraz stylu beamer, którego autorem jest Till Tantau. Strona domowa projektu Beamer:

3 Plan prezentacji 1 Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 2 Czym jest 3 4 Podstawowe informacje

4 Plan prezentacji Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 1 Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 2 Czym jest 3 4 Podstawowe informacje języka C, biblioteki dzielone

5 Moje dane Konsultacje Warunki zaliczenia Zarys planu kursu, literatura Bogdan Kreczmer, dr inż., pok. 307 bud C-3 Terminy konsultacji: śr.(p) 11:00 13:00 śr.(n) 9:00 11:00 cz. 9:00 11:00 Strona kursu: kreczmer/zamp

6 Plan prezentacji Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 1 Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 2 Czym jest 3 4 Podstawowe informacje języka C, biblioteki dzielone

7 Warunki zaliczeń Konsultacje Warunki zaliczenia Zarys planu kursu, literatura Kurs kończy się zaliczeniem. Warunkiem uzyskania zaliczenia jest otrzymanie oceny pozytywnej z kolokwium. Istnieje możliwość zwolnienia z kolokwium na podstawie oceny z laboratorium. Warunki zwolnienia: zdobycie z kartkówek 90% 5, 0 zdobycie z kartkówek 80% 4, 5

8 Warunki zaliczeń Konsultacje Warunki zaliczenia Zarys planu kursu, literatura Kurs kończy się zaliczeniem. Warunkiem uzyskania zaliczenia jest otrzymanie oceny pozytywnej z kolokwium. Istnieje możliwość zwolnienia z kolokwium na podstawie oceny z laboratorium. Warunki zwolnienia: zdobycie z kartkówek 90% 5, 0 zdobycie z kartkówek 80% 4, 5

9 Warunki zaliczeń Konsultacje Warunki zaliczenia Zarys planu kursu, literatura Kurs kończy się zaliczeniem. Warunkiem uzyskania zaliczenia jest otrzymanie oceny pozytywnej z kolokwium. Istnieje możliwość zwolnienia z kolokwium na podstawie oceny z laboratorium. Warunki zwolnienia: zdobycie z kartkówek 90% 5, 0 zdobycie z kartkówek 80% 4, 5

10 Warunki zaliczeń Konsultacje Warunki zaliczenia Zarys planu kursu, literatura Kurs kończy się zaliczeniem. Warunkiem uzyskania zaliczenia jest otrzymanie oceny pozytywnej z kolokwium. Istnieje możliwość zwolnienia z kolokwium na podstawie oceny z laboratorium. Warunki zwolnienia: zdobycie z kartkówek 90% 5, 0 zdobycie z kartkówek 80% 4, 5

11 Plan prezentacji Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 1 Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 2 Czym jest 3 4 Podstawowe informacje języka C, biblioteki dzielone

12 Zarys planu kursu (wykład) Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 1 2 języka C, biblioteki dzielone 3 Programowanie uogólnione w języku C oraz w języku C++, XML i XML Scheme, biblioteka xerces 4 Programowanie współbieżne w C++ (wątki) 5 Automake tworzenie pakietów instalacyjnych 6 CMake 7 GStreamer ogólna charakterystyka i przykłady Strona kursu: kreczmer/zamp

13 Literatura Konsultacje Warunki zaliczenia Zarys planu kursu, literatura Jerry Cain, Programming Paradigms, wykłady W. Taymans, S. Baker, A. Wingo, R. S. Bultje, S. Kost, GStreamer Application Development S. Lippman, J. Lajoie, B. E. Moo, C++ Primer, wyd. 5., 2012 David Vandevoorde, Nicolai M. Josuttis, C++ szablony, Helion, 2003 Thomas G. Habing, XML Tutorial, 2004 (prezentacja) D. MacKenzie, T. Tromey, A. Duret-Lutz; GNU Automake, 2009 D. MacKenzie, B. Elliston, A. D le; GNU Autoconf, 2010

14 Plan prezentacji Czym jest 1 Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 2 Czym jest 3 4 Podstawowe informacje języka C, biblioteki dzielone

15 krótka historia Czym jest Autorami systemu BibTEX są Orena Patashnik i Leslie Lamport. System ten został stworzony w Służy do formatowania bibliografii na podstawie zadanego stylu i bazy zawierającej informacje o kolejnych pozycjach bibliograficznych. Podsawowe cechy systemu Pliki *.bib zawierają opis bibliograficzny poszczególnych pozycji, Plik *.bst zawiera specyfikację stylu, Plik *.bbl tworzony jest przez i włączany jest do dokumentu. BIBINPUTS zmienna środowiskowa, która pozwala zdefinować zbiór ścieżek dla programu bibtex

16 Czym jest Czym jest Język opisujący styl bibliografii, który wykorzystuje jest językiem stosu postfiksów (ang. postfix stack language). Opis stylu bibliografii jest programem napisanym we wcześniej wspomianym języku (nie posida on żadnej nazwy własnej). Program ten mówi jak formatować pozycje z bazy bibliograficznej (pliki *.bib), które następnie umieszczane są w liście referencyjnej danego dokumentu.

17 Co generuje L A TEX dla Czym jest L A TEX Plik tworzony przez L A TEX wykorzystywany później przez : *.aux jest tworzony niezależnie od tego, czy będzie wykorzystywany, czy też nie. L A TEX Plik tworzony przez wykorzystywany później przez L A TEX: *.bbl zawiera zestawienie cytowanych pozycji wraz z odpowiednimi makrami formatującymi tekst.

18 Tandem: L A TEX, Czym jest Proces kompilacji dokumentu latex tworzy pliki *.aux bibtex tworzy pliki *.bbl latex aktualizuje etykiety (numery odwołań) i dołącza *.bbl latex aktualizuje etykiety cytowań

19 Plan prezentacji 1 Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 2 Czym jest 3 4 Podstawowe informacje języka C, biblioteki dzielone

20 Definiowanie symbolu #define ROZMIAR TAB 100

21 Definiowanie symbolu #define ROZMIAR TAB 100 Treścią definiowanego symbolu jest to, co znajduje się za nim w tej samej linii.

22 Definiowanie symbolu #define ROZMIAR TAB 100 Treścią definiowanego symbolu jest to, co znajduje się za nim w tej samej linii. #define ROZMIAR TAB 100 int main( ) int Tablica[ROZMIAR TAB]; /* W tym programie niewiele się dzieje :( */ for (int i = 0; i < ROZMIAR TAB-1; ++i) Tablica[i] = Tablica[i+1]; // Przepisywanie wartości w w dół

23 Definiowanie symbolu #define ROZMIAR TAB 100 Przed zasadniczą kompilacją tekst programu przetwarzany jest przez preprocesor. int main( ) int Tablica[100]; for (int i = 0; i < 100-1; ++i) Tablica[i] = Tablica[i+1];

24 Wieloliniowe definicje symboli #define WARTOSCI POCZATKOWE 437, 567, 201, 109, 309,\ 561, 789, 401, 271, 901,\ 654, 978, 982, 729, -1 Jeżeli treść symbolu chcemy umieścić w kilku liniach, to na końcu linii poprzedniej musi być znak kontynuacji \. będzie traktował całość jako jedną długą linię.

25 Wieloliniowe definicje symboli #define WARTOSCI POCZATKOWE 437, 567, 201, 109, 309,\ 561, 789, 401, 271, 901,\ 654, 978, 982, 729, -1 Jeżeli treść symbolu chcemy umieścić w kilku liniach, to na końcu linii poprzedniej musi być znak kontynuacji \. będzie traktował całość jako jedną długą linię. #define WARTOSCI POCZATKOWE 437, 567, 201, 109, 309,\ 561, 789, 401, 271, 901,\ 654, 978, 982, 729, -1 int main( ) int Tablica[ ] = WARTOSCI POCZATKOWE ; for (int i = 1; Tablica[i] > 0; ++i) Tablica[i-1] = Tablica[i];

26 Wieloliniowe definicje symboli #define WARTOSCI POCZATKOWE 437, 567, 201, 109, 309,\ 561, 789, 401, 271, 901,\ 654, 978, 982, 729, -1 Tekst makra jest rozwijany po uprzedniej redukcji wielokrotnych spacji prowadzących. int main( ) int Tablica[ ] = 437, 567, 201, 109, 309, 561, 789, 401, 271, 901, 654, 978, 982, 729, -1; for (int i = 1; Tablica[i] > 0; ++i) Tablica[i-1] = Tablica[i];

27 Definiowanie symboli pustych #define WSTEPNY TEST Definicje symboli pustych wykorzystywane są do sterowania przebiegiem kompilacji kodu. Realizowane to jest poprzez kompilację warunkową.

28 Dyrektywa warunkowa #ifdef #define WSTEPNY TEST Definicje symboli pustych wykorzystywane są do sterowania przebiegiem kompilacji kodu. Realizowane to jest poprzez kompilację warunkową. #define WSTEPNY TEST int main( ) int Zm; #ifdef WSTEPNY TEST if (Zm!= 0) return 1; #endif

29 Dyrektywa warunkowa #ifdef #define WSTEPNY TEST Kod znajdujący się wewnątrz dyrektywy #ifdef, dla której spełniony jest warunek istnienia definicji symbolu, zostaje dołączony do kompilowanego tekstu programu. int main( ) int Zm; if (Zm!= 0) return 1;

30 Dyrektywa warunkowa #ifndef #define WSTEPNY TEST Dyrektywa warunkowa #ifndef, testuje warunek nieistnienia definicji danego symbolu. #define WSTEPNY TEST int main( ) int Zm; #ifndef WSTEPNY TEST if (Zm!= 0) return 1; #endif

31 Dyrektywa warunkowa #ifndef #define WSTEPNY TEST Jeśli dla dyrektywy warunkowej warunek nie jest spełniony, to kod nie zostaje dołączony do kompilowanego tekstu programu. int main( ) int Zm;

32 Dyrektywa warunkowa #ifndef #define WSTEPNY TEST Czy można zmienić zapis tej dyrektywy #ifndef tak, aby tekst był dołączany wtedy gdy symbol jest zdefiniowany? #define WSTEPNY TEST int main( ) int Zm; #ifndef WSTEPNY TEST if (Zm!= 0) return 1; #endif

33 Dyrektywa warunkowa #ifndef #define WSTEPNY TEST Aby to otrzymać wystarczy dopisać dyrektywę #else. #define WSTEPNY TEST int main( ) int Zm; #ifndef WSTEPNY TEST #else if (Zm!= 0) return 1; #endif

34 Dyrektywa warunkowa #ifndef #define WSTEPNY TEST Tym razem dołączany jest kod, który znajduje się w sekcji else dyrektywy #ifndef. int main( ) int Zm; if (Zm!= 0) return 1;

35 Dyrektywa warunkowa #if #define WSTEPNY TEST Do sprawdzania istnienia definicji symbolu można wykorzystać ogólną postać dyrektywy #if wraz z odpowiednim operatorem. #define WSTEPNY TEST int main( ) int Zm; #if defined(wstepny TEST) if (Zm!= 0) return 1; #endif

36 Dyrektywa warunkowa #if #define WSTEPNY TEST W wyrażeniu logicznym można użyć operatora negacji. #define WSTEPNY TEST int main( ) int Zm; #if! defined(wstepny TEST) #else if (Zm!= 0) return 1; #endif

37 Dyrektywa warunkowa #if #define WSTEPNY TEST Można też użyć operatora koniunkcji i alternatywy. Ich oznaczenie jest takie samo jak w języku C/C++. Operator negacji ma najwyższy priorytet. #define WSTEPNY TEST int main( ) int Zm; #if! defined(wstepny TEST) && ( defined( GNUG ) defined( BORLANDC ) ) #else if (Zm!= 0) return 1; #endif

38 Dyrektywa warunkowa #if #define WSTEPNY TEST Równoważna postać. #define WSTEPNY TEST int main( ) int Zm; #if (! defined(wstepny TEST)) && ( defined( GNUG ) defined( BORLANDC ) ) #else if (Zm!= 0) return 1; #endif

39 Dyrektywa warunkowa #if #define WSTEPNY TEST Równoważna postać. #define WSTEPNY TEST int main( ) int Zm; #if! defined WSTEPNY TEST && (defined GNUG defined BORLANDC ) #else if (Zm!= 0) return 1; #endif

40 Pragma dyrektywa dla kompilatora #pragma implementation

41 Pragma dyrektywa dla kompilatora #pragma implementation Pragma nie jest dyrektywą preprocesora, choć rozpoczyna się od znaku #. Jest to dyrektywa dla kompilatora.

42 Pragma dyrektywa dla kompilatora #pragma implementation Zawiera ona informacje dla kompilatora, które sterują jego pracą. #define ROZMIAR TAB 100 #pragma interface #pragma implementation int main( ) int Tablica[ROZMIAR TAB]; for (int i = 0; i < ROZMIAR TAB-1; ++i) Tablica[i] = Tablica[i+1];

43 Pragma dyrektywa dla kompilatora #pragma implementation Dlatego też preprocesor nie przetwarza dyrektywy #pragma i pozostawia ją w tekście programu. #pragma interface #pragma implementation int main( ) int Tablica[100]; for (int i = 0; i < 100-1; ++i) Tablica[i] = Tablica[i+1];

44 Pragma dyrektywa dla kompilatora #pragma implementation Treść i znacznie dyrektywy zależy od konkretnego kompilatora. Dlatego też jej wystąpienie wiąże się z kompilacją warunkową. #define ROZMIAR TAB 100 #ifdef GNUG #pragma interface #pragma implementation #endif int main( ) int Tablica[ROZMIAR TAB]; for (int i = 0; i < ROZMIAR TAB-1; ++i) Tablica[i] = Tablica[i+1];

45 Pragma dyrektywa dla kompilatora #pragma implementation Znak # nie musi bezpośrednio poprzedzać nazwę dyrektywy. Dotyczy to zarówno dyrektywy kompilatora jak też preprocesora. #define ROZMIAR TAB 100 #ifdef GNUG # pragma interface # pragma implementation #endif int main( ) int Tablica[ROZMIAR TAB]; for (int i = 0; i < ROZMIAR TAB-1; ++i) Tablica[i] = Tablica[i+1];

46 Pragma dyrektywa dla kompilatora #pragma implementation Nie muszą też rozpoczynać się od pierwszej kolumny. #define ROZMIAR TAB 100 #ifdef GNUG # pragma interface # pragma implementation #endif int main( ) int Tablica[ROZMIAR TAB]; for (int i = 0; i < ROZMIAR TAB-1; ++i) Tablica[i] = Tablica[i+1];

47 Pragma dyrektywa dla kompilatora #pragma implementation Muszą być jednak pierwszym elementem w linii. int Zm; #define ROZMIAR TAB 100 #ifdef GNUG # pragma interface # pragma implementation #endif int main( ) int Tablica[ROZMIAR TAB]; for (int i = 0; i < ROZMIAR TAB-1; ++i) Tablica[i] = Tablica[i+1];

48 Plan prezentacji 1 Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 2 Czym jest 3 4 Podstawowe informacje języka C, biblioteki dzielone

49 Dyrektywa #include #include <iostream> Plik, który ma być dołączony, szukany jest w katalogach systemowych kompilatora.

50 Dyrektywa #include #include mojplik.h Plik najpierw szukany jest w katalogu bieżącym, a w razie niepowodzenia w drugiej kolejności przeszukiwane są katalogi systemowe kompilatora.

51 Dyrektywa #include #include <iostream> #include mojplik.h Dla obu dyrektyw listę przeszukiwanych katalogów można rozszerzyć stosując opcje -I. Katalogi występujące po -I przeszukiwane są przed katalogami systemowymi. Konsola gcc -Iinc -Iinc/kernel mojplik.c

52 Dyrektywa #include #include <iostream> #include ext/mojplik.h W jakim katalogu będzie szukany teraz plik mojplik.h? Konsola jkowalsk@panamint> gcc -Iinc -Iinc/kernel mojplik.c

53 Dyrektywa #include #include <iostream> #include mojplik.h Opcja -iquote rozszerza listę przeszukiwanych kartotek tylko dla dyrektywy #include.... Konsola gcc -iquote inc -iquote inc/kernel mojplik.c

54 LZespolona.hh struct LZespolona double re, im; ; WektorZ.hh struct WektorZ LZespolona x, y; ; prog.cpp #include LZespolona.hh #include WektorZ.hh int main( ) WektorZ Wz;

55 struct LZespolona double re, im; ; struct WektorZ LZespolona x, y; ; int main( ) WektorZ Wz;

56 LZespolona.hh struct LZespolona double re, im; ; WektorZ.hh struct WektorZ LZespolona x, y; ; prog.cpp #include LZespolona.hh #include WektorZ.hh int main( ) WektorZ Wz;

57 LZespolona.hh struct LZespolona double re, im; ; WektorZ.hh struct WektorZ LZespolona x, y; ; prog.cpp #include WektorZ.hh #include LZespolona.hh int main( ) WektorZ Wz;

58 struct WektorZ LZespolona x, y; ; struct LZespolona double re, im; ; int main( ) WektorZ Wz;

59 Dołączanie w pliku nagłówkowym LZespolona.hh struct LZespolona double re, im; ; WektorZ.hh #include lzespolona.hh struct WektorZ LZespolona x, y; ; prog.cpp #include WektorZ.hh int main( ) WektorZ Wz;

60 Efekt dołączenia w pliku głównym i nagłówkowym struct LZespolona double re, im; ; struct WektorZ LZespolona x, y; ; int main( ) WektorZ Wz;

61 Wielokrotne wystąpienie pliku nagłówkowego LZespolona.hh struct LZespolona double re, im; ; WektorZ.hh #include lzespolona.hh struct WektorZ LZespolona x, y; ; prog.cpp #include WektorZ.hh int main( ) WektorZ Wz;

62 Wielokrotne wystąpienie pliku nagłówkowego LZespolona.hh struct LZespolona double re, im; ; WektorZ.hh #include lzespolona.hh struct WektorZ LZespolona x, y; ; prog.cpp #include WektorZ.hh #include LZespolona.hh int main( ) WektorZ Wz;

63 Efekt dołączenia wszystkich plików nagłówkowych struct LZespolona double re, im; ; struct WektorZ LZespolona x, y; ; struct LZespolona double re, im; ; int main( ) WektorZ Wz;

64 Zapobieganie wielokrotnemu dołączaniu tego samego pliku LZespolona.hh #ifndef LZESPOLONA HH #define LZESPOLONA HH struct LZespolona double re, im; ; #endif WektorZ.hh #ifndef WEKTORZ HH #define WEKTORZ HH #include lzespolona.hh struct WektorZ LZespolona x, y; ; #endif prog.cpp #include WektorZ.hh #include LZespolona.hh int main( ) WektorZ Wz;

65 struct LZespolona double re, im; ; struct WektorZ LZespolona x, y; ; int main( ) WektorZ Wz;

66 Jaki wpływ ma zamiana kolejności dołączania plików? LZespolona.hh #ifndef LZESPOLONA HH #define LZESPOLONA HH struct LZespolona double re, im; ; #endif WektorZ.hh #ifndef WEKTORZ HH #define WEKTORZ HH #include lzespolona.hh struct WektorZ LZespolona x, y; ; #endif prog.cpp #include WektorZ.hh #include LZespolona.hh int main( ) WektorZ Wz;

67 Jaki wpływ ma zamiana kolejności dołączania plików? LZespolona.hh #ifndef LZESPOLONA HH #define LZESPOLONA HH struct LZespolona double re, im; ; #endif WektorZ.hh #ifndef WEKTORZ HH #define WEKTORZ HH #include lzespolona.hh struct WektorZ LZespolona x, y; ; #endif prog.cpp #include LZespolona.hh #include WektorZ.hh int main( ) WektorZ Wz;

68 Wielokrotne definiowanie symbolu #define word unsigned short int

69 Wielokrotne definiowanie symbolu #define word unsigned short int #define word short int

70 Wielokrotne definiowanie symbolu #define word unsigned short int #define word unsigned short int

71 Wielokrotne definiowanie symbolu #define word unsigned short int #undef word #define word unsigned short int

72 Wielokrotne definiowanie symbolu #define word unsigned short int #ifdef word # define word unsigned short int #endif

73 Plan prezentacji 1 Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 2 Czym jest 3 4 Podstawowe informacje języka C, biblioteki dzielone

74 Rozwijanie definicji makra #define MAX( aa, bb ) aa > bb? aa : bb int main( ) double Zm = 9; Zm = MAX( Zm, 20);

75 Po rozwinięciu makra int main( ) double Zm = 9; Zm = Zm > 20? Zm : 20; Zawartość zmiennej na końcu programu Zm: 20

76 Wypływ priorytetu operatorów na wynik operacji #define MAX( aa, bb ) aa > bb? aa : bb int main( ) double Zm = 9; Zm = 35 + MAX( Zm, 20);

77 Wypływ priorytetu operatorów na wynik operacji int main( ) double Zm = 9; Zm = 35 + Zm > 20? Zm : 20;

78 Wypływ priorytetu operatorów na wynik operacji int main( ) double Zm = 9; Zm = 35 + Zm > 20? Zm : 20; Zawartość zmiennej na końcu programu Zm: 9

79 Wypływ priorytetu operatorów na wynik operacji #define MAX( aa, bb ) aa > bb? aa : bb int main( ) double Zm = 9; Zm = 35 + MAX( Zm, 20);

80 Wypływ priorytetu operatorów na wynik operacji #define MAX( aa, bb ) (aa > bb? aa : bb) int main( ) double Zm = 9; Zm = 35 + MAX( Zm, 20);

81 Wypływ priorytetu operatorów na wynik operacji #define MAX( aa, bb ) (aa > bb? aa : bb) int main( ) double Zm = 9, Z tmp; Zm = 35 + MAX( Zm, Z tmp=20);

82 Wypływ priorytetu operatorów na wynik operacji #define MAX( aa, bb ) (aa > bb? aa : bb) int main( ) double Zm = 9, Z tmp; Zm = 35 + MAX( Zm, Z tmp=20); Komunikat kompilatora prog.cpp: In function int main( ) : prog.cpp:12: error: lvalue required as left operand of assignment

83 Wypływ priorytetu operatorów na wynik operacji #define MAX( aa, bb ) (aa > bb? aa : bb) int main( ) double Zm = 9; Zm = 35 + (Zm > Z tmp = 20? Zm : Z tmp = 20); Komunikat kompilatora prog.cpp: In function int main( ) : prog.cpp:12: error: lvalue required as left operand of assignment

84 Wypływ priorytetu operatorów na wynik operacji #define MAX( aa, bb ) ((aa) > (bb)? (aa) : (bb)) int main( ) double Zm = 9; Zm = 35 + MAX( Zm, Z tmp=20);

85 Skutki wywołania funkcji w makrze #define MAX( aa, bb ) ((aa) > (bb)? (aa) : (bb)) double Compute(double r, double angle) return log(pow(r,4.32)*sin(4.5*angle/ )); int main( ) double Zm = 9; Zm = MAX( Compute(2.5*Zm, 0.25), 20 );

86 Skutki wywołania funkcji w makrze #define MAX( aa, bb ) ((aa) > (bb)? (aa) : (bb)) double Compute(double r, double angle) return log(pow(r,4.32)*sin(4.5*angle/ )); int main( ) double Zm = 9; Zm = ((Compute(2.5*Zm, 0.25)) > (20)? (Compute(2.5*Zm, 0.25)) : (20));

87 Rozwijanie makr w makrze #define MAX( aa, bb ) ((aa) > (bb)? (aa) : (bb)) #define PI 3.14 int main( ) double Zm = 9; Zm = MAX( PI/15, pow(log(pi),8) );

88 Rozwijanie makr w makrze int main( ) double Zm = 9; Zm = ( (3.14/15) > (pow(log(3.14),8))? (3.14/15) : (pow(log(3.14),8) );

89 Rozwijanie makr w makrze #define MAX( aa, bb ) ((aa) > (bb)? (aa) : (bb)) #define PI 3.14 int main( ) double Zm = 9; Zm = MAX( PI/15, pow(log(pi),8) );

90 Rozwijanie makr w makrze #define MAX( aa, bb ) ((aa) > (bb)? (aa) : (bb)) #define FUN( arg1, arg2 ) pow(log((arg1)),(arg2)) #define PI 3.14 int main( ) double Zm = 9; Zm = MAX( PI/15, FUN(PI, 8) );

91 Rozwijanie makr w makrze int main( ) double Zm = 9; Zm = ( (3.14/15) > (pow(log((3.14)),(8)))? (3.14/15) : (pow(log((3.14)),(8)) );

92 Jaka jest kolejność rozwijania makr #define FUN( arg1, arg2 ) pow(log((arg1)),(arg2)) int main( ) double ZmA = 9, ZmB; ZmA = pow(log(zma *= 2), (ZmB = ZmA+10, ZmA *= 3));

93 Jaka jest kolejność rozwijania makr #define FUN( arg1, arg2 ) pow(log((arg1)),(arg2)) int main( ) double ZmA = 9, ZmB; Zm = FUN(ZmA *= 2, ZmB = ZmA+10, ZmA *= 3 );

94 Jaka jest kolejność rozwijania makr #define FUN( arg1, arg2 ) pow(log((arg1)),(arg2)) int main( ) double ZmA = 9, ZmB; Zm = FUN(ZmA *= 2, (ZmB = ZmA+10, ZmA *= 3) );

95 Jaka jest kolejność rozwijania makr #define FUN( arg1, arg2 ) pow(log((arg1)),(arg2)) #define ARG ZmB = ZmA+10, ZmA *= 3 int main( ) double ZmA = 9, ZmB; Zm = FUN(ZmA *= 2, ARG );

96 Jaka jest kolejność rozwijania makr #define FUN( arg1, arg2 ) pow(log((arg1)),(arg2)) #define ARG (ZmB = ZmA+10, ZmA *= 3) int main( ) double ZmA = 9, ZmB; Zm = FUN(ZmA *= 2, ARG );

97 Makra wywoływane przez makra #define MAX( aa, bb ) ((aa) > (bb)? (aa) : (bb)) int main( ) double Zm; Zm = MAX( Zm, MAX( Zm, 5 ) );

98 Makra wywoływane przez makra int main( ) double Zm; Zm = ((Zm) > ((Zm) > (5)? (Zm) : (5))? (Zm) : ((Zm) > (5)? (Zm) : (5)));

99 Makra wywoływane przez makra #define MAX( aa, bb ) ((aa) > (bb)? (aa) : (bb)) #define ARG MAX( Zm, 5 ) int main( ) double Zm; Zm = MAX( Zm, ARG );

100 Makra wywoływane przez makra int main( ) double Zm; Zm = ((Zm) > ((Zm) > (5)? (Zm) : (5))? (Zm) : ((Zm) > (5)? (Zm) : (5)));

101 Czy są możliwe rekurencyjne wywołania makr? #define SILNIA(x) (((x) > 1)? (x)*silnia((x)-1) : 1) int main( ) double Zm; Zm = SILNIA(20);

102 Czy są możliwe rekurencyjne wywołania makr? int main( ) double Zm; Zm = ((20) > 1? (20)*SILNIA((20)-1) : 1);

103 Plan prezentacji 1 Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 2 Czym jest 3 4 Podstawowe informacje języka C, biblioteki dzielone

104 Tworzenie napisu #define STR(x) #x int main( ) const char *wnapis = STR(Ten tekst bedzie napisem);

105 Tworzenie napisu int main( ) const char *wnapis = Ten tekst bedzie napisem ;

106 A jaki teraz będzie rezultat rozwinięcia makra? #define STR(x) #x #define TEKST Ten tekst bedzie napisem int main( ) const char *wnapis = STR(TEKST);

107 Końcowy rezultat int main( ) const char *wnapis = TEKST ;

108 Przykład użycia #define STR(x) #x #define DEF FUN( Nazwa, Ciag Instr ) \ void Nazwa( LZespolona& Z ) \ Ciag Instr; \ cout << Funkcja: STR(Nazwa) << endl; \ DEF FUN(Zamien, double x; x = Z.re; Z.re = Z.im; Z.im = x) DEF FUN(Inwersja, Z.re = -Z.re; Z.im = -Z.im) DEF FUN(Potega2, Z *= Z)

109 Przykład użycia void Zamien(LZespolona& Z) double x; x = Z.re; Z.re = Z.im; Z.im = x; cout << Funkcja: Zamien <<endl; void Inwersja(LZespolona& Z) Z.re = -Z.re; Z.im = -Z.im; cout << Funkcja: Inwersja <<endl; void Potega2(LZespolona& Z) Z *= Z; cout << Funkcja: Potega2 <<endl;

110 Sformułowanie problemu void FunZesp Zamien(LZespolona& Z) double x; x = Z.re; Z.re = Z.im; Z.im = x; cout << Funkcja: Zamien <<endl; void FunZesp Inwersja(LZespolona& Z) Z.re = -Z.re; Z.im = -Z.im; cout << Funkcja: Inwersja <<endl; void FunZesp Potega2(LZespolona& Z) Z *= Z; cout << Funkcja: Potega2 <<endl;

111 Sformułowanie problemu #define DEF FUN( Nazwa, Ciag Instr ) \ void FunZesp Nazwa( LZespolona& Z ) \ Ciag Instr; \ cout << Funkcja: STR(Nazwa) << endl; \ DEF FUN(Zamien, double x; x = Z.re; Z.re = Z.im; Z.im = x) DEF FUN(Inwersja, Z.re = -Z.re; Z.im = -Z.im) DEF FUN(Potega2, Z *= Z)

112 Sformułowanie problemu void FunZesp Zamien(LZespolona& Z) double x; x = Z.re; Z.re = Z.im; Z.im = x; cout << Funkcja: Zamien <<endl; void FunZesp Inwersja(LZespolona& Z) Z.re = -Z.re; Z.im = -Z.im; cout << Funkcja: Inwersja <<endl; void FunZesp <<endl; Potega2(LZespolona& Z) Z *= Z; cout << Funkcja: Potega2

113 Sformułowanie problemu #define DEF FUN( Nazwa, Ciag Instr ) \ void FunZesp Nazwa( LZespolona& Z ) \ Ciag Instr; \ cout << Funkcja: STR(Nazwa) << endl; \ DEF FUN(Zamien, double x; x = Z.re; Z.re = Z.im; Z.im = x) DEF FUN(Inwersja, Z.re = -Z.re; Z.im = -Z.im) DEF FUN(Potega2, Z *= Z)

114 Sformułowanie problemu void FunZesp Nazwa(LZespolona& Z) double x; x = Z.re; Z.re = Z.im; Z.im = x; cout << Funkcja: Zamien <<endl; void FunZesp Nazwa(LZespolona& Z) Z.re = -Z.re; Z.im = -Z.im; cout << Funkcja: Inwersja <<endl; void FunZesp Nazwa(LZespolona& Z) Z *= Z; cout << Funkcja: Potega2 <<endl;

115 Łączenie napisów #define DOLACZ NAPIS( x ) Prefix ##x

116 Łączenie napisów #define DOLACZ NAPIS( x ) DOLACZ NAPIS( RdzenNazwy ) Prefix ##x

117 Łączenie napisów #define DOLACZ NAPIS( x ) DOLACZ NAPIS( RdzenNazwy ) Prefix RdzenNazwy Prefix ##x

118 Łączenie napisów #define DOLACZ NAPIS( x ) DOLACZ NAPIS( RdzenNazwy ) PrefixRdzenNazwy Prefix##x

119 Przykład użycia #define STR(x) #x #define DEF FUN( Nazwa, Ciag Instr ) \ void FunZesp ##Nazwa( LZespolona& Z ) \ Ciag Instr; \ cout << Funkcja: STR(Nazwa) << endl; \ DEF FUN(Zamien, double x; x = Z.re; Z.re = Z.im; Z.im = x) DEF FUN(Inwersja, Z.re = -Z.re; Z.im = -Z.im) DEF FUN(Potega2, Z *= Z)

120 Przykład użycia void FunZesp Zamien(LZespolona& Z) double x; x = Z.re; Z.re = Z.im; Z.im = x; cout << Funkcja: Zamien <<endl; void FunZesp Inwersja(LZespolona& Z) Z.re = -Z.re; Z.im = -Z.im; cout << Funkcja: Inwersja <<endl; void FunZesp Potega2(LZespolona& Z) Z *= Z; cout << Funkcja: Potega2 <<endl;

121 Konstruowanie rozwinięcia makr w makrach #define STR( x ) #x #define MAX int #define MAX double std::numeric limits<int>::max() std::numeric limits<double>::max()

122 Konstruowanie rozwinięcia makr w makrach #define STR( x ) #x #define MAX int #define MAX double std::numeric limits<int>::max() std::numeric limits<double>::max() #define DISPLAY MAX( Typ ) cout << Maks. STR(Typ) : << MAX ##Typ << endl;

123 Konstruowanie rozwinięcia makr w makrach #define STR( x ) #x #define MAX int #define MAX double std::numeric limits<int>::max() std::numeric limits<double>::max() #define DISPLAY MAX( Typ ) cout << Maks. STR(Typ) : << MAX ##Typ << endl; void main( ) DISPLAY MAX(int) DISPLAY MAX(double)

124 Konstruowanie rozwinięcia makr w makrach void main( ) cout << Maks. int : << std::numeric limits<int>::max() << endl; cout << Maks. double : << std::numeric limits<double>::max() << endl;

125 Rozwinięcia makr parametrycznych w makrach #define STR( x ) #x #define LIMIT int(fun) #define LIMIT double(fun) std::numeric limits<int>::fun() std::numeric limits<double>::fun() #define DISPLAY LIMIT( T, L ) cout << Maks. STR(T) : << LIMIT ##T(L) << endl; void main( ) DISPLAY LIMIT(int, max) DISPLAY LIMIT(double, min)

126 Rozwinięcia makr parametrycznych w makrach void main( ) cout << Maks. int : << std::numeric limits<int>::max() << endl; cout << Maks. double : << std::numeric limits<double>::min() << endl;

127 Przykładowy implementacja głównej pętli parsera bool CommandsParser::ReadCmdsList( istream &IStrm, CommandsList &CmdLst) string Keyword; while (IStrm >> Keyword) if (Keyword == Move ) if (!ReadCmd Move(IStrm,CmdLst)) return false; continue ; if (Keyword == Turn ) if (!ReadCmd Turn(IStrm,CmdLst)) return false; continue ; if (Keyword == Rotate ) if (!ReadCmd Rotate(IStrm,CmdLst)) return false; continue ; return true;

128 Definicja pomocniczego makra #define STR(x) #x #define IF CMD THEN READ( CmdName ) \ if (Keyword == STR(CmdName)) \ if (!ReadCmd ##CmdName(IStrm,CmdLst)) return false; \ continue ; \ bool CommandsParser::ReadCmdsList( istream &IStrm, CommandsList &CmdLst) string Keyword; while (IStrm >> Keyword) if (Keyword == Move ) if (!ReadCmd Move(IStrm,CmdLst)) return false; continue ;... return true;

129 Przykład użycia #define STR(x) #x #define IF CMD THEN READ( CmdName ) \ if (Keyword == STR(CmdName)) \ if (!ReadCmd ##CmdName(IStrm,CmdLst)) return false; \ continue ; \ bool CommandsParser::ReadCmdsList( istream &IStrm, CommandsList &CmdLst) string Keyword; while (IStrm >> Keyword) IF CMD THEN READ( Move ) IF CMD THEN READ( Turn ) IF CMD THEN READ( Rotate ) return true;

130 Przykład użycia #define STR(x) #x #define IF CMD THEN READ( CmdName ) \ if (Keyword == STR(CmdName)) \ if (!ReadCmd ##CmdName(IStrm,CmdLst)) return false; \ continue ; \ bool CommandsParser::ReadCmdsList( istream &IStrm, CommandsList &CmdLst) string Keyword; while (IStrm >> Keyword) IF CMD THEN READ( Move ) IF CMD THEN READ( Turn ) IF CMD THEN READ( Rotate ) return false; return true;

131 Problem różnego nazewnictwa Załóżmy, że występują różnice w nazwach, tzn. nazwy poleceń są polskojęzyczne, zaś nazwy funkcji, które chcemy wywołać dla poszczególnych poleceń są angielskojęzyczne. Tak jak jest to przedstawione poniżej. Ruch ReadCmd Move Skret ReadCmd Turn Rotacja ReadCmd Rotate Aby to uwzględnić, należy zdefiować kilka dodatkowych makr, które stworzą właściwy mechanizm tlumaczenia nazw.

132 Problem różnego nazewnictwa Załóżmy, że występują różnice w nazwach, tzn. nazwy poleceń są polskojęzyczne, zaś nazwy funkcji, które chcemy wywołać dla poszczególnych poleceń są angielskojęzyczne. Tak jak jest to przedstawione poniżej. Ruch ReadCmd Move Skret ReadCmd Turn Rotacja ReadCmd Rotate Aby to uwzględnić, należy zdefiować kilka dodatkowych makr, które stworzą właściwy mechanizm tlumaczenia nazw.

133 Postać docelowa bool CommandsParser::ReadCmdsList( istream &IStrm, CommandsList &CmdLst) string Keyword; while (IStrm >> Keyword) if (Keyword == Ruch ) if (!ReadCmd Move(IStrm,CmdLst)) return false; continue ; if (Keyword == Skret ) if (!ReadCmd Turn(IStrm,CmdLst)) return false; continue ; if (Keyword == Rotacja ) if (!ReadCmd Rotate(IStrm,CmdLst)) return false; continue ; return true;

134 Postać docelowa użycie makr IF CMD THEN READ( Ruch ) IF CMD THEN READ( Skret ) if (Keyword == Ruch ) \ if (!ReadCmd Move(IStrm,CmdLst)) return false; \ continue ; \ if (Keyword == Skret ) \ if (!ReadCmd Turn(IStrm,CmdLst)) return false; \ continue ; \

135 Przykład realizacji mechanizmu tłumaczenia nazw #define STR(x) #x #define IF CMD THEN READ( CmdName ) \ if (Keyword == STR(CmdName)) \ if (!ReadCmd ##CmdName(IStrm,CmdLst)) return false; \ continue ; \ Najpierw musimy dodać makra, które będą służyły jako translatory nazw.

136 Przykład realizacji mechanizmu tłumaczenia nazw #define STR(x) #x #define EN Ruch Move #define EN Skret Turn #define EN Rotacja Rotate #define IF CMD THEN READ( CmdName ) \ if (Keyword == STR(CmdName)) \ if (!ReadCmd ##CmdName(IStrm,CmdLst)) return false; \ continue ; \ Makra te w swojej nazwie muszą mieć tłumaczone słowo. Będzie to potrzebne w dalszej konstrukcji.

137 Przykład realizacji mechanizmu tłumaczenia nazw #define STR(x) #x #define EN Ruch Move #define EN Skret Turn #define EN Rotacja Rotate #define IF CMD THEN READ( CmdName ) \ if (Keyword == STR(CmdName)) \ if (!ReadCmd ##CmdName(IStrm,CmdLst)) return false; \ continue ; \ Następnie musimy zdefinować makro, które utworzy odpowiednią nazwę funkcji.

138 Przykład realizacji mechanizmu tłumaczenia nazw #define STR(x) #x #define EN Ruch Move #define EN Skret Turn #define EN Rotacja Rotate #define CREATE FUN NAME( Nazwa ) ReadCmd ##EN ##Nazwa #define IF CMD THEN READ( CmdName ) \ if (Keyword == STR(CmdName)) \ if (!CREATE FUN NAME( Ruch )(IStrm,CmdLst)) return false; \ continue ; \ Jednak w takiej postaci to makro nie jest porawne. Jako wynik jego rozwinięcia otrzymamy nazwę funkcji: ReadCmd EN Ruch

139 Przykład realizacji mechanizmu tłumaczenia nazw #define STR(x) #x #define EN Ruch Move #define EN Skret Turn #define EN Rotacja Rotate #define CREATE FUN NAME( Prefix, Postfix ) Prefix##Postfix #define IF CMD THEN READ( CmdName ) \ if (Keyword == STR(CmdName)) \ if (!CREATE FUN NAME( ReadCmd, EN ##CmdName )(IStrm,CmdLst)) \ return false; \ continue ; \ Ta forma makra jest dobra, ale jego wywołanie nie da spodziewanego wyniku. Podobnie jak wcześniej otrzymamy: ReadCmd EN Ruch

140 Przykład realizacji mechanizmu tłumaczenia nazw #define STR(x) #x #define EN Ruch Move #define EN Skret Turn #define EN Rotacja Rotate #define CREATE FUN NAME( Prefix, Postfix ) #define FUN CALL( Prefix, Postfix ) Prefix##Postfix CREATE FUN NAME(Prefix,Postfix) #define IF CMD THEN READ( CmdName ) \ if (Keyword == STR(CmdName)) \ if (!FUN CALL(ReadCmd,EN ##CmdName)(IStrm,CmdLst)) return false; \ continue ; \ To jest pełna poprawna postać. Teraz po rozwinięciu makra otrzymamy nazwę funkcji w postaci: ReadCmd Move

141 Przykład realizacji mechanizmu tłumaczenia nazw #define STR(x) #x #define EN Ruch Move #define EN Skret Turn #define EN Rotacja Rotate #define CREATE FUN NAME( Prefix, Postfix ) #define FUN CALL( Prefix, Postfix ) Prefix##Postfix CREATE FUN NAME(Prefix,Postfix) #define IF CMD THEN READ( CmdName ) \ if (Keyword == STR(CmdName)) \ if (!FUN CALL(ReadCmd,EN ##CmdName)(IStrm,CmdLst)) return false; \ continue ; \ To podwójne wywołanie makra o takiej samej postaci (po rozwinięciu) jest w tym przypadku niezbędne. Wynika to z tego, że przed rozwinięciem pierwszego makra preprocesor tworzy napis jego drugiego argumentu. nie wykonuje drugiego przebiegu i nie próbuje interpretować utworzonego napisu. Dopiero, gdy napis ten występuje w pełnej formie jako argument drugiego makra, wówczas w pierwszym (i jedynym) przebiegu preprocesor interpretuje go.

142 Przykład realizacji mechanizmu tłumaczenia nazw #define STR(x) #x #define EN Ruch Move #define EN Skret Turn #define EN Rotacja Rotate #define CREATE FUN NAME( Postfix ) #define FUN CALL( Postfix ) ReadCmd ##Postfix CREATE FUN NAME(Postfix) #define IF CMD THEN READ( CmdName ) \ if (Keyword == STR(CmdName)) \ if (!FUN CALL(EN ##CmdName)(IStrm,CmdLst)) return false; \ continue ; \ Korzystając, że w naszym przypadku przedrostek nazwy funkcji jest we wszystkich przypadkach taki sam, makra możemy uprościć i liczbę parametrów ograniczyć do jednego.

143 Kontrola błędów double Operacja Podzialu( double Dzielna, double Dzielnik ) if (Dzielnik == 0) cerr << Blad operacji dzielenia w funkcji Operacja Podzialu << endl; abort(); return Dzielna/Dzielnik;

144 Kontrola błędów double Operacja Podzialu( double Dzielna, double Dzielnik ) if (Dzielnik == 0) cerr << Blad operacji dzielenia w funkcji Operacja Podzialu << endl; cerr << Modul: << FILE << endl; cerr << Linia: << LINE abort(); return Dzielna/Dzielnik; << endl;

145 Kontrola błędów double Operacja Podzialu( double Dzielna, double Dzielnik ) if (Dzielnik == 0) cerr << Blad operacji dzielenia w funkcji Operacja Podzialu << endl; cerr << Modul: << FILE << endl; cerr << Linia: << LINE << endl; cerr << Data komilacji: << DATE << endl; cerr << Godzina: << TIME abort(); return Dzielna/Dzielnik; << endl;

146 Kontrola błędów double Operacja Podzialu( double Dzielna, double Dzielnik ) if (Dzielnik == 0) cerr << Blad operacji dzielenia w funkcji << func cerr << Modul: << FILE << endl; cerr << Linia: << LINE << endl; cerr << Data komilacji: << DATE << endl; cerr << Godzina: << TIME abort(); return Dzielna/Dzielnik; << endl; << endl;

147 Kontrola błędów double Operacja Podzialu( double Dzielna, double Dzielnik ) assert(dzielnik!= 0); return Dzielna/Dzielnik;

148 Kontrola błędów #include <cassert> double Operacja Podzialu( double Dzielna, double Dzielnik ) assert(dzielnik!= 0); return Dzielna/Dzielnik;

149 Kontrola błędów #define NDEBUG #include <cassert> double Operacja Podzialu( double Dzielna, double Dzielnik ) assert(dzielnik!= 0); return Dzielna/Dzielnik;

150 Postać makra assert (język C) #include <assert.h> double Operacja Podzialu( double Dzielna, double Dzielnik ) assert(dzielnik!= 0); return Dzielna/Dzielnik;

151 Postać makra assert (język C) double Operacja Podzialu( double Dzielna, double Dzielnik ) ((Dzielnik!= 0)? (void) (0) : assert fail("dzielnik!= 0", "kontrola.c", 6, PRETTY FUNCTION )); return Dzielna/Dzielnik;

152 Postać makra assert (język C) #define NDEBUG #include <assert.h> double Operacja Podzialu( double Dzielna, double Dzielnik ) assert(dzielnik!= 0); return Dzielna/Dzielnik;

153 Postać makra assert (język C) double Operacja Podzialu( double Dzielna, double Dzielnik ) (void) (0); return Dzielna/Dzielnik;

154 Postać makra assert (język C++) #include <cassert> double Operacja Podzialu( double Dzielna, double Dzielnik ) assert(dzielnik!= 0); return Dzielna/Dzielnik;

155 Postać makra assert (język C++) double Operacja Podzialu( double Dzielna, double Dzielnik ) ((Dzielnik!= 0)? static cast<void>(0) : assert fail("dzielnik!= 0", "kontrola.c", 6, PRETTY FUNCTION )); return Dzielna/Dzielnik;

156 Postać makra assert (język C++) #define NDEBUG #include <cassert> double Operacja Podzialu( double Dzielna, double Dzielnik ) assert(dzielnik!= 0); return Dzielna/Dzielnik;

157 Postać makra assert (język C++) double Operacja Podzialu( double Dzielna, double Dzielnik ) (static cast<void>(0)); return Dzielna/Dzielnik;

158 Czytanie pliku generowanego przez preprocesor #include <cstdio> #define LINE SIZE 500 bool Exec( const char NazwaPliku, istringstream &IStrm4Cmds ) string Cmd4Preproc = cpp -P ; char Line[LINE SIZE]; ostringstream OTmpStrm; Cmd4Preproc += NazwaPliku; FILE pproc = popen(cmd4preproc.c str(), r ); if (!pproc) return false; while (fgets(line,line SIZE,pProc)) OTmpStrm << Line; IStrm4Cmds.str(OTmpStrm.str()); return pclose(pproc) == 0;

159 Plan prezentacji Podstawowe informacje 1 Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 2 Czym jest 3 4 Podstawowe informacje języka C, biblioteki dzielone

160 Podstawowe funkcje Podstawowe informacje #include <dlfcn.h> void dlopen(const char filename, int flag); char dlerror(void ); void dlsym(void handle, const char symbol); int dlclose(void handle);

161 Podstawowe własności Podstawowe informacje Kompilacja biblioteki musi być realizowana z opcją -fpic. Pozwala to utworzyć relokowalny kod. W poleceniu konsolidacji trzeba pamiętać o opcji -shared oraz -ldl. Funkcja init( ), o ile istnieje, wykonuje się tylko raz.

162 Interfejs biblioteki Podstawowe informacje extern C const char GetCmdName(void); void PrintSyntax(void); Command CreateCmd(void);

163 Interfejs biblioteki Podstawowe informacje extern C const char GetCmdName(void); void PrintSyntax(void); Command CreateCmd(void); const char GetCmdName(void) return Command4Move::GetCmdName( );

164 Interfejs biblioteki Podstawowe informacje extern C const char GetCmdName(void); void PrintSyntax(void); Command CreateCmd(void); void PrintSyntax(void) Command4Move::PrintSyntax( );

165 Interfejs biblioteki Podstawowe informacje extern C const char GetCmdName(void); void PrintSyntax(void); Command CreateCmd(void); Command CreateCmd(void) return Command4Move::CreateCmd( );

166 Interfejs biblioteki Podstawowe informacje extern C const char GetCmdName(void); void PrintSyntax(void); Command CreateCmd(void); const char Command4Move::GetCmdName( ) return Move ;

167 Koniec prezentacji Dziękuję za uwagę języka C, biblioteki dzielone