Preprocesor języka C

Transkrypt

1 języka C Bogdan Kreczmer bogdan.kreczmer@pwr.wroc.pl Zakład Podstaw Cybernetyki i Robotyki Instytut Informatyki, Automatyki i Robotyki Politechnika Wrocławska Kurs: Copyright c 2012 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

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

3 1 Organizacja kursu Konsultacje Warunki zaliczenia Plan kursu Źródła 2 języka C

4 Moje dane Organizacja kursu Konsultacje Warunki zaliczenia Plan kursu Źródła Bogdan Kreczmer, dr inż., pok. 307 bud C-3 Terminy konsultacji: wt. 14:00 15:00 cz. 13:00 14:00 pt. 13:00 15:00 Strona kursu: kreczmer/zamp

5 Warunki zaliczeń Organizacja kursu Konsultacje Warunki zaliczenia Plan kursu Źródła Kurs kończy się zaliczeniem. Warunkiem uzyskania zaliczenia jest otrzymanie oceny pozytywnej z kolokwium i oceny pozytywnej z laboratorium. Istnieje możliwość zwolnienia z kolokwium na podstawie oceny z laboratorium. Warunki zwolnienia: brak opóźnień w oddawaniu programów na laboratorium, ocena z laboratorium 5, 0 ocena z kursu: 5, 0, ocena z laboratorium 4, 5 ocena z kursu: 4, 0. Sposób liczenia oceny w przypadku pisania kolokwium: Ocena z kursu = 40% oceny laboratorium + 60% oceny z kolokwium Ocena celująca z kursu kolokwium: 5, 0; laboratorium: 5, 5 lub kolokwium: 5, 5; laboratorium: 5, 0

6 Warunki zaliczeń Organizacja kursu Konsultacje Warunki zaliczenia Plan kursu Źródła Kurs kończy się zaliczeniem. Warunkiem uzyskania zaliczenia jest otrzymanie oceny pozytywnej z kolokwium i oceny pozytywnej z laboratorium. Istnieje możliwość zwolnienia z kolokwium na podstawie oceny z laboratorium. Warunki zwolnienia: brak opóźnień w oddawaniu programów na laboratorium, ocena z laboratorium 5, 0 ocena z kursu: 5, 0, ocena z laboratorium 4, 5 ocena z kursu: 4, 0. Sposób liczenia oceny w przypadku pisania kolokwium: Ocena z kursu = 40% oceny laboratorium + 60% oceny z kolokwium Ocena celująca z kursu kolokwium: 5, 0; laboratorium: 5, 5 lub kolokwium: 5, 5; laboratorium: 5, 0

7 Warunki zaliczeń Organizacja kursu Konsultacje Warunki zaliczenia Plan kursu Źródła Kurs kończy się zaliczeniem. Warunkiem uzyskania zaliczenia jest otrzymanie oceny pozytywnej z kolokwium i oceny pozytywnej z laboratorium. Istnieje możliwość zwolnienia z kolokwium na podstawie oceny z laboratorium. Warunki zwolnienia: brak opóźnień w oddawaniu programów na laboratorium, ocena z laboratorium 5, 0 ocena z kursu: 5, 0, ocena z laboratorium 4, 5 ocena z kursu: 4, 0. Sposób liczenia oceny w przypadku pisania kolokwium: Ocena z kursu = 40% oceny laboratorium + 60% oceny z kolokwium Ocena celująca z kursu kolokwium: 5, 0; laboratorium: 5, 5 lub kolokwium: 5, 5; laboratorium: 5, 0

8 Warunki zaliczeń Organizacja kursu Konsultacje Warunki zaliczenia Plan kursu Źródła Kurs kończy się zaliczeniem. Warunkiem uzyskania zaliczenia jest otrzymanie oceny pozytywnej z kolokwium i oceny pozytywnej z laboratorium. Istnieje możliwość zwolnienia z kolokwium na podstawie oceny z laboratorium. Warunki zwolnienia: brak opóźnień w oddawaniu programów na laboratorium, ocena z laboratorium 5, 0 ocena z kursu: 5, 0, ocena z laboratorium 4, 5 ocena z kursu: 4, 0. Sposób liczenia oceny w przypadku pisania kolokwium: Ocena z kursu = 40% oceny laboratorium + 60% oceny z kolokwium Ocena celująca z kursu kolokwium: 5, 0; laboratorium: 5, 5 lub kolokwium: 5, 5; laboratorium: 5, 0

9 Warunki zaliczeń Organizacja kursu Konsultacje Warunki zaliczenia Plan kursu Źródła Kurs kończy się zaliczeniem. Warunkiem uzyskania zaliczenia jest otrzymanie oceny pozytywnej z kolokwium i oceny pozytywnej z laboratorium. Istnieje możliwość zwolnienia z kolokwium na podstawie oceny z laboratorium. Warunki zwolnienia: brak opóźnień w oddawaniu programów na laboratorium, ocena z laboratorium 5, 0 ocena z kursu: 5, 0, ocena z laboratorium 4, 5 ocena z kursu: 4, 0. Sposób liczenia oceny w przypadku pisania kolokwium: Ocena z kursu = 40% oceny laboratorium + 60% oceny z kolokwium Ocena celująca z kursu kolokwium: 5, 0; laboratorium: 5, 5 lub kolokwium: 5, 5; laboratorium: 5, 0

10 Warunki zaliczeń Organizacja kursu Konsultacje Warunki zaliczenia Plan kursu Źródła Kurs kończy się zaliczeniem. Warunkiem uzyskania zaliczenia jest otrzymanie oceny pozytywnej z kolokwium i oceny pozytywnej z laboratorium. Istnieje możliwość zwolnienia z kolokwium na podstawie oceny z laboratorium. Warunki zwolnienia: brak opóźnień w oddawaniu programów na laboratorium, ocena z laboratorium 5, 0 ocena z kursu: 5, 0, ocena z laboratorium 4, 5 ocena z kursu: 4, 0. Sposób liczenia oceny w przypadku pisania kolokwium: Ocena z kursu = 40% oceny laboratorium + 60% oceny z kolokwium Ocena celująca z kursu kolokwium: 5, 0; laboratorium: 5, 5 lub kolokwium: 5, 5; laboratorium: 5, 0

11 Plan kursu (wykład) Organizacja kursu Konsultacje Warunki zaliczenia Plan kursu Źródła 1 języka C, wstęp do programowania uogólnionego w języku C 2 Programowanie uogólnione w języku C oraz w języku C++ 3 Wybrane szablony z STL C++, C++ 0x, wstęp do XML 4 XML i XML Scheme, automake - tworzenie pakietów instalacyjnych, latex bibtex 5 Interpetery. bash, Lisp, Python - wybrane zagadnienia Strona kursu: kreczmer/zamp

12 Plan kursu (laboratorium) Konsultacje Warunki zaliczenia Plan kursu Źródła 1 Interpreter opisu działań robota mobilnego wykorzystanie preprocesora 2 Interpreter opisu działań robota mobilnego XML 3 Interpreter opisu działań robota mobilnego Urbi 4 Pakiet instalacyjny interpretera opisu działań robota mobilnego Strona kursu: kreczmer/zamp

13 Literatura Organizacja kursu Konsultacje Warunki zaliczenia Plan kursu Źródła Jerry Cain, Programming Paradigms, wykłady 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 Ch. Ramey, B. Fox; Bash Reference Manual, 2009

14 Definiowanie symbolu Organizacja kursu #define ROZMIAR TAB 100

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

16 Definiowanie symbolu Organizacja kursu #define ROZMIAR TAB 100 Treścią definiowanego symbolu jest to, co znajduje się za nim w tej samej linii. #define ROZMIAR TAB 100 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ół

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

18 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ę.

19 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 Tablica[ ] = WARTOSCI POCZATKOWE ; for (int i = 1; Tablica[i] > 0; ++i) Tablica[i-1] = Tablica[i];

20 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 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];

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

22 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 Zm; #ifdef WSTEPNY TEST if (Zm!= 0) return 1; #endif

23 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 Zm; if (Zm!= 0) return 1;

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

25 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 Zm;

26 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 Zm; #ifndef WSTEPNY TEST if (Zm!= 0) return 1; #endif

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

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

29 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 Zm; #if defined(wstepny TEST) if (Zm!= 0) return 1; #endif

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

31 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 Zm; #if! defined(wstepny TEST) && ( defined( GNUG ) defined( BORLANDC ) ) #else if (Zm!= 0) return 1; #endif

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

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

34 Pragma dyrektywa dla kompilatora #pragma implementation

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

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

37 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 Tablica[100]; for (int i = 0; i < 100-1; ++i) Tablica[i] = Tablica[i+1];

38 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 Tablica[ROZMIAR TAB]; for (int i = 0; i < ROZMIAR TAB-1; ++i) Tablica[i] = Tablica[i+1];

39 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 Tablica[ROZMIAR TAB]; for (int i = 0; i < ROZMIAR TAB-1; ++i) Tablica[i] = Tablica[i+1];

40 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 Tablica[ROZMIAR TAB]; for (int i = 0; i < ROZMIAR TAB-1; ++i) Tablica[i] = Tablica[i+1];

41 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 Tablica[ROZMIAR TAB]; for (int i = 0; i < ROZMIAR TAB-1; ++i) Tablica[i] = Tablica[i+1];

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

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

44 Dyrektywa #include #include <iostream> #include mojplik.h Organizacja kursu 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

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

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

47 LZespolona.hh Organizacja kursu struct LZespolona double re, im; ; WektorZ.hh struct WektorZ LZespolona x, y; ; prog.cpp #include LZespolona.hh #include WektorZ.hh WektorZ Wz;

48 Organizacja kursu struct LZespolona double re, im; ; struct WektorZ LZespolona x, y; ; WektorZ Wz;

49 LZespolona.hh Organizacja kursu struct LZespolona double re, im; ; WektorZ.hh struct WektorZ LZespolona x, y; ; prog.cpp #include LZespolona.hh #include WektorZ.hh WektorZ Wz;

50 LZespolona.hh Organizacja kursu struct LZespolona double re, im; ; WektorZ.hh struct WektorZ LZespolona x, y; ; prog.cpp #include WektorZ.hh #include LZespolona.hh WektorZ Wz;

51 Organizacja kursu struct WektorZ LZespolona x, y; ; struct LZespolona double re, im; ; WektorZ Wz;

52 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 WektorZ Wz;

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

54 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 WektorZ Wz;

55 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 WektorZ Wz;

56 Efekt dołączenia wszystkich plików nagłówkowych struct LZespolona double re, im; ; struct WektorZ LZespolona x, y; ; struct LZespolona double re, im; ; WektorZ Wz;

57 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 WektorZ Wz;

58 Organizacja kursu struct LZespolona double re, im; ; struct WektorZ LZespolona x, y; ; WektorZ Wz;

59 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 WektorZ Wz;

60 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 WektorZ Wz;

61 Wielokrotne definiowanie symbolu #define word unsigned short int

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

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

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

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

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

67 Po rozwinięciu makra Organizacja kursu double Zm = 9; Zm = Zm > 20? Zm : 20; Zawartość zmiennej na końcu programu Zm: 20

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

69 Wypływ priorytetu operatorów na wynik operacji double Zm = 9; Zm = 35 + Zm > 20? Zm : 20;

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

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

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

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

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

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

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

77 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/ )); double Zm = 9; Zm = MAX( Compute(2.5*Zm, 0.25), 20 );

78 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/ )); double Zm = 9; Zm = ((Compute(2.5*Zm, 0.25)) > (20)? (Compute(2.5*Zm, 0.25)) : (20));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

94 Tworzenie napisu Organizacja kursu #define STR(x) #x const char *wnapis = STR(Ten tekst bedzie napisem);

95 Tworzenie napisu Organizacja kursu const char *wnapis = Ten tekst bedzie napisem ;

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

97 Końcowy rezultat Organizacja kursu const char *wnapis = TEKST ;

98 Przykład użycia Organizacja kursu #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)

99 Przykład użycia Organizacja kursu 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;

100 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;

101 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)

102 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

103 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)

104 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;

105 Łączenie napisów Organizacja kursu #define DOLACZ NAPIS( x ) Prefix ##x

106 Łączenie napisów Organizacja kursu #define DOLACZ NAPIS( x ) DOLACZ NAPIS( RdzenNazwy ) Prefix ##x

107 Łączenie napisów Organizacja kursu #define DOLACZ NAPIS( x ) DOLACZ NAPIS( RdzenNazwy ) Prefix RdzenNazwy Prefix ##x

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

109 Przykład użycia Organizacja kursu #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)

110 Przykład użycia Organizacja kursu 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 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()

112 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;

113 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)

114 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;

115 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)

116 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;

117 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;

118 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;

119 Przykład użycia Organizacja kursu #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;

120 Przykład użycia Organizacja kursu #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;

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

122 Kontrola błędów Organizacja kursu 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;

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

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

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

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

127 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;

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

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

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

131 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;

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

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

134 Czytanie pliku generowanego przez preprocesor #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 NULL; while (fgets(line,line SIZE,pProc)) OTmpStrm << Line; IStrm4Cmds.str(OTmpStrm.str()); return pclose(pproc) == 0;

135 I to już koniec. języka C