Preprocesor języka C, biblioteki dzielone
|
|
|
- Janusz Sikorski
- 8 lat temu
- Przeglądów:
Transkrypt
1 języka C, biblioteki dzielone Bogdan Kreczmer Katedra Cybernetyki i Robotyki Politechnika Wrocławska Kurs: Copyright c 2014 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 Organizacja kursu 1 Organizacja kursu Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 2 3 Konstrukcja listy 4 Podstawowe informacje
4 Plan prezentacji Organizacja kursu Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 1 Organizacja kursu Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 2 3 Konstrukcja listy 4 Podstawowe informacje języka C, biblioteki dzielone
5 Moje dane Organizacja kursu 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) 17:00 19:00 cz. 13:00 15:00 Strona kursu: kreczmer/zamp
6 Plan prezentacji Organizacja kursu Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 1 Organizacja kursu Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 2 3 Konstrukcja listy 4 Podstawowe informacje języka C, biblioteki dzielone
7 Warunki zaliczeń Organizacja kursu Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 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: zdobycie z kartkówek 60%, ocena z laboratorium 5, 0 ocena z kursu: 5, 0, ocena z laboratorium 4, 5 ocena z kursu: 4, 5. 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 Zarys planu kursu, literatura 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: zdobycie z kartkówek 60%, ocena z laboratorium 5, 0 ocena z kursu: 5, 0, ocena z laboratorium 4, 5 ocena z kursu: 4, 5. 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 Zarys planu kursu, literatura 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: zdobycie z kartkówek 60%, ocena z laboratorium 5, 0 ocena z kursu: 5, 0, ocena z laboratorium 4, 5 ocena z kursu: 4, 5. 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 Zarys planu kursu, literatura 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: zdobycie z kartkówek 60%, ocena z laboratorium 5, 0 ocena z kursu: 5, 0, ocena z laboratorium 4, 5 ocena z kursu: 4, 5. 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 Warunki zaliczeń Organizacja kursu Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 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: zdobycie z kartkówek 60%, ocena z laboratorium 5, 0 ocena z kursu: 5, 0, ocena z laboratorium 4, 5 ocena z kursu: 4, 5. 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
12 Warunki zaliczeń Organizacja kursu Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 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: zdobycie z kartkówek 60%, ocena z laboratorium 5, 0 ocena z kursu: 5, 0, ocena z laboratorium 4, 5 ocena z kursu: 4, 5. 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
13 Plan prezentacji Organizacja kursu Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 1 Organizacja kursu Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 2 3 Konstrukcja listy 4 Podstawowe informacje języka C, biblioteki dzielone
14 Zarys planu kursu (wykład) Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 1 języka C, biblioteki dzielone 2 Programowanie uogólnione w języku C oraz w języku C++, XML i XML Scheme, biblioteka xerces 3 Urbi 4 Automake - tworzenie pakietów instalacyjnych 5 Urbi i Python, bibtex Strona kursu: kreczmer/zamp
15 Zarys planu kursu (laboratorium) Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 1 Interpreter opisu ekspresji twarzy robota lista niejednorodna 2 Interpreter opisu ekspresji twarzy robota wykorzystanie preprocesora, bibliotek dzielonych 3 Interpreter opisu ekspresji twarzy robota XML 4 Interpreter opisu ekspresji twarzy robota Urbi 5 Pakiet instalacyjny interpretera opisu ekspresji twarzy robota Strona kursu: kreczmer/zamp
16 Literatura Organizacja kursu Konsultacje Warunki zaliczenia Zarys planu kursu, literatura Jerry Cain, Programming Paradigms, wykłady 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 B. Collins-Sussman, B. W. Fitzpatrick, C. M. Pilato; Version Control with Subversion (For Subversion 1.7), 2011
17 Plan prezentacji Organizacja kursu 1 Organizacja kursu Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 2 3 Konstrukcja listy 4 Podstawowe informacje języka C, biblioteki dzielone
18 Definiowanie symbolu Organizacja kursu #define ROZMIAR TAB 100
19 Definiowanie symbolu Organizacja kursu #define ROZMIAR TAB 100 Treścią definiowanego symbolu jest to, co znajduje się za nim w tej samej linii.
20 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 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ół
21 Definiowanie symbolu Organizacja kursu #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];
22 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ę.
23 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];
24 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];
25 Definiowanie symboli pustych #define WSTEPNY TEST Definicje symboli pustych wykorzystywane są do sterowania przebiegiem kompilacji kodu. Realizowane to jest poprzez kompilację warunkową.
26 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
27 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;
28 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
29 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;
30 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
31 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
32 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;
33 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
34 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
35 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
36 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
37 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
38 Pragma dyrektywa dla kompilatora #pragma implementation
39 Pragma dyrektywa dla kompilatora #pragma implementation Pragma nie jest dyrektywą preprocesora, choć rozpoczyna się od znaku #. Jest to dyrektywa dla kompilatora.
40 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 main( ) 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 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];
42 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];
43 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];
44 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];
45 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];
46 Plan prezentacji Organizacja kursu 1 Organizacja kursu Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 2 3 Konstrukcja listy 4 Podstawowe informacje języka C, biblioteki dzielone
47 Dyrektywa #include Organizacja kursu #include <iostream> Plik, który ma być dołączony, szukany jest w katalogach systemowych kompilatora.
48 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.
49 Dyrektywa #include Organizacja kursu #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
50 Dyrektywa #include Organizacja kursu #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
51 Dyrektywa #include Organizacja kursu #include <iostream> #include mojplik.h Opcja -iquote rozszerza listę przeszukiwanych kartotek tylko dla dyrektywy #include.... Konsola gcc -iquote inc -iquote inc/kernel mojplik.c
52 Organizacja kursu 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;
53 Organizacja kursu struct LZespolona double re, im; ; struct WektorZ LZespolona x, y; ; int main( ) WektorZ Wz;
54 Organizacja kursu 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 Organizacja kursu 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;
56 Organizacja kursu struct WektorZ LZespolona x, y; ; struct LZespolona double re, im; ; int main( ) WektorZ Wz;
57 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;
58 Efekt dołączenia w pliku głównym i nagłówkowym struct LZespolona double re, im; ; struct WektorZ LZespolona x, y; ; int main( ) WektorZ Wz;
59 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;
60 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;
61 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;
62 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;
63 Organizacja kursu struct LZespolona double re, im; ; struct WektorZ LZespolona x, y; ; int main( ) WektorZ Wz;
64 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;
65 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;
66 Wielokrotne definiowanie symbolu #define word unsigned short int
67 Wielokrotne definiowanie symbolu #define word unsigned short int #define word short int
68 Wielokrotne definiowanie symbolu #define word unsigned short int #define word unsigned short int
69 Wielokrotne definiowanie symbolu #define word unsigned short int #undef word #define word unsigned short int
70 Wielokrotne definiowanie symbolu #define word unsigned short int #ifdef word # define word unsigned short int #endif
71 Plan prezentacji Organizacja kursu 1 Organizacja kursu Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 2 3 Konstrukcja listy 4 Podstawowe informacje języka C, biblioteki dzielone
72 Rozwijanie definicji makra #define MAX( aa, bb ) aa > bb? aa : bb int main( ) double Zm = 9; Zm = MAX( Zm, 20);
73 Po rozwinięciu makra Organizacja kursu int main( ) double Zm = 9; Zm = Zm > 20? Zm : 20; Zawartość zmiennej na końcu programu Zm: 20
74 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);
75 Wypływ priorytetu operatorów na wynik operacji int main( ) double Zm = 9; Zm = 35 + Zm > 20? Zm : 20;
76 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
77 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);
78 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);
79 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);
80 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
81 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
82 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);
83 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 );
84 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));
85 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) );
86 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) );
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 #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) );
89 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)) );
90 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));
91 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 );
92 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) );
93 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 );
94 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 );
95 Makra wywoływane przez makra #define MAX( aa, bb ) ((aa) > (bb)? (aa) : (bb)) int main( ) double Zm; Zm = MAX( Zm, MAX( Zm, 5 ) );
96 Makra wywoływane przez makra int main( ) double Zm; Zm = ((Zm) > ((Zm) > (5)? (Zm) : (5))? (Zm) : ((Zm) > (5)? (Zm) : (5)));
97 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 );
98 Makra wywoływane przez makra int main( ) double Zm; Zm = ((Zm) > ((Zm) > (5)? (Zm) : (5))? (Zm) : ((Zm) > (5)? (Zm) : (5)));
99 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);
100 Czy są możliwe rekurencyjne wywołania makr? int main( ) double Zm; Zm = ((20) > 1? (20)*SILNIA((20)-1) : 1);
101 Plan prezentacji Organizacja kursu 1 Organizacja kursu Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 2 3 Konstrukcja listy 4 Podstawowe informacje języka C, biblioteki dzielone
102 Tworzenie napisu Organizacja kursu #define STR(x) #x int main( ) const char *wnapis = STR(Ten tekst bedzie napisem);
103 Tworzenie napisu Organizacja kursu int main( ) const char *wnapis = Ten tekst bedzie napisem ;
104 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);
105 Końcowy rezultat Organizacja kursu int main( ) const char *wnapis = TEKST ;
106 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)
107 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;
108 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;
109 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)
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 <<endl; Potega2(LZespolona& Z) Z *= Z; cout << Funkcja: Potega2
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 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;
113 Łączenie napisów Organizacja kursu #define DOLACZ NAPIS( x ) Prefix ##x
114 Łączenie napisów Organizacja kursu #define DOLACZ NAPIS( x ) DOLACZ NAPIS( RdzenNazwy ) Prefix ##x
115 Łączenie napisów Organizacja kursu #define DOLACZ NAPIS( x ) DOLACZ NAPIS( RdzenNazwy ) Prefix RdzenNazwy Prefix ##x
116 Łączenie napisów Organizacja kursu #define DOLACZ NAPIS( x ) DOLACZ NAPIS( RdzenNazwy ) PrefixRdzenNazwy Prefix##x
117 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)
118 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;
119 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()
120 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;
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() #define DISPLAY MAX( Typ ) cout << Maks. STR(Typ) : << MAX ##Typ << endl; void main( ) DISPLAY MAX(int) DISPLAY MAX(double)
122 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;
123 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)
124 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;
125 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;
126 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;
127 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;
128 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;
129 Problem różnego nazewnictwa Załóżmy, że występują różnice w nazw, 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 dodatkowe makra, które stworzą właściwy mechanizm tlumaczenia nazw.
130 Problem różnego nazewnictwa Załóżmy, że występują różnice w nazw, 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 dodatkowe makra, które stworzą właściwy mechanizm tlumaczenia nazw.
131 Postać docelowa Organizacja kursu 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;
132 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 ; \
133 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.
134 Przykład realizacji mechanizmu tłumaczenia nazw #define STR(x) #x #define EN Ruch Move #define EN Skret Turn #define EN Rotate 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.
135 Przykład realizacji mechanizmu tłumaczenia nazw #define STR(x) #x #define EN Ruch Move #define EN Skret Turn #define EN Rotate 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.
136 Przykład realizacji mechanizmu tłumaczenia nazw #define STR(x) #x #define EN Ruch Move #define EN Skret Turn #define EN Rotate 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
137 Przykład realizacji mechanizmu tłumaczenia nazw #define STR(x) #x #define EN Ruch Move #define EN Skret Turn #define EN Rotate 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
138 Przykład realizacji mechanizmu tłumaczenia nazw #define STR(x) #x #define EN Ruch Move #define EN Skret Turn #define EN Rotate 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
139 Przykład realizacji mechanizmu tłumaczenia nazw #define STR(x) #x #define EN Ruch Move #define EN Skret Turn #define EN Rotate 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.
140 Przykład realizacji mechanizmu tłumaczenia nazw #define STR(x) #x #define EN Ruch Move #define EN Skret Turn #define EN Rotate 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.
141 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;
142 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;
143 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 << endl; cerr << Data komilacji: << DATE << endl; cerr << Godzina: << TIME abort(); return Dzielna/Dzielnik; << endl;
144 Kontrola błędów Organizacja kursu 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;
145 Kontrola błędów Organizacja kursu double Operacja Podzialu( double Dzielna, double Dzielnik ) assert(dzielnik!= 0); return Dzielna/Dzielnik;
146 Kontrola błędów Organizacja kursu #include <cassert> double Operacja Podzialu( double Dzielna, double Dzielnik ) assert(dzielnik!= 0); return Dzielna/Dzielnik;
147 Kontrola błędów Organizacja kursu #define NDEBUG #include <cassert> double Operacja Podzialu( double Dzielna, double Dzielnik ) assert(dzielnik!= 0); return Dzielna/Dzielnik;
148 Postać makra assert (język C) #include <assert.h> double Operacja Podzialu( double Dzielna, double Dzielnik ) assert(dzielnik!= 0); return Dzielna/Dzielnik;
149 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;
150 Postać makra assert (język C) #define NDEBUG #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 ) (void) (0); return Dzielna/Dzielnik;
152 Postać makra assert (język C++) #include <cassert> 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 ) ((Dzielnik!= 0)? static cast<void>(0) : assert fail("dzielnik!= 0", "kontrola.c", 6, PRETTY FUNCTION )); return Dzielna/Dzielnik;
154 Postać makra assert (język C++) #define NDEBUG #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 ) (static cast<void>(0)); return Dzielna/Dzielnik;
156 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;
157 Plan prezentacji Organizacja kursu Konstrukcja listy 1 Organizacja kursu Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 2 3 Konstrukcja listy 4 Podstawowe informacje języka C, biblioteki dzielone
158 Klasa bazowa i klasy pochodne Konstrukcja listy class Command public : virtual void PrintCmd() const = 0; ;
159 Klasa bazowa i klasy pochodne Konstrukcja listy class Command public : virtual void PrintCmd() const = 0; ; class Command4Fly: public Command public : static const char GetCmdName() return Fly ; virtual void PrintCmd() const cout << GetCmdName() << 0, 0, 0;\n ; ;
160 Klasa bazowa i klasy pochodne Konstrukcja listy class Command public : virtual void PrintCmd() const = 0; ; class Command4Fly: public Command public : static const char GetCmdName() return Fly ; virtual void PrintCmd() const cout << GetCmdName() << 0, 0, 0;\n ; ; class Command4Rotate: public Command public : static const char GetCmdName() return Rotate ; virtual void PrintCmd() const cout << GetCmdName() << 0, 0;\n ; ;
161 Przeglądanie listy Organizacja kursu Konstrukcja listy int main() std::list<command > CmdsList; CmdsList.push back(new CmdsList.push back(new Command4Fly()); Command4Rotate()); for (std::list<command >::const iterator Iter = CmdsList.begin(); Iter!= CmdsList.end(); ++Iter) ( Iter)->PrintCmd();
162 Przeglądanie listy Organizacja kursu Konstrukcja listy int main() std::list<command > CmdsList; CmdsList.push back(new CmdsList.push back(new Command4Fly()); Command4Rotate()); for (auto Iter = CmdsList.begin(); Iter!= CmdsList.end(); ++Iter) ( Iter)->PrintCmd();
163 Przeglądanie listy Organizacja kursu Konstrukcja listy int main() std::list<command > CmdsList; CmdsList.push back(new CmdsList.push back(new Command4Fly()); Command4Rotate()); for (auto Iter : CmdsList ) ( Iter)->PrintCmd();
164 Przeglądanie listy Organizacja kursu Konstrukcja listy int main() std::list<command > CmdsList; CmdsList.push back(new CmdsList.push back(new Command4Fly()); Command4Rotate()); int arr[10]; for (auto Elem : arr ) cout << Elem << endl;
165 Plan prezentacji Organizacja kursu Podstawowe informacje 1 Organizacja kursu Konsultacje Warunki zaliczenia Zarys planu kursu, literatura 2 3 Konstrukcja listy 4 Podstawowe informacje języka C, biblioteki dzielone
166 Podstawowe funkcje Organizacja kursu 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);
167 Podstawowe własności Organizacja kursu 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.
168 Interfejs biblioteki Organizacja kursu Podstawowe informacje extern C const char GetCmdName(void); void PrintSyntax(void); Command CreateCmd(void);
169 Interfejs biblioteki Organizacja kursu Podstawowe informacje extern C const char GetCmdName(void); void PrintSyntax(void); Command CreateCmd(void); const char GetCmdName(void) return Command4Move::GetCmdName( );
170 Interfejs biblioteki Organizacja kursu Podstawowe informacje extern C const char GetCmdName(void); void PrintSyntax(void); Command CreateCmd(void); void PrintSyntax(void) Command4Move::PrintSyntax( );
171 Interfejs biblioteki Organizacja kursu Podstawowe informacje extern C const char GetCmdName(void); void PrintSyntax(void); Command CreateCmd(void); Command CreateCmd(void) return Command4Move::CreateCmd( );
172 Interfejs biblioteki Organizacja kursu Podstawowe informacje extern C const char GetCmdName(void); void PrintSyntax(void); Command CreateCmd(void); const char Command4Move::GetCmdName( ) return Move ;
173 Koniec prezentacji Dziękuję za uwagę języka C, biblioteki dzielone
Preprocesor języka C, biblioteki dzielone
języka C, biblioteki dzielone Bogdan Kreczmer bogdan.kreczmer@pwr.edu.pl Katedra Cybernetyki i Robotyki Wydziału Elektroniki Politechnika Wrocławska Kurs: Copyright c 2018 Bogdan Kreczmer Niniejszy dokument
Preprocesor języka C
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
Szablony funkcji i szablony klas
Bogdan Kreczmer bogdan.kreczmer@pwr.wroc.pl Zakład Podstaw Cybernetyki i Robotyki Instytut Informatyki, Automatyki i Robotyki Politechnika Wrocławska Kurs: Copyright c 2011 Bogdan Kreczmer Niniejszy dokument
Wprowadzenie do szablonów klas
Bogdan Kreczmer bogdan.kreczmer@pwr.wroc.pl Zakład Podstaw Cybernetyki i Robotyki Instytut Informatyki, Automatyki i Robotyki Politechnika Wrocławska Kurs: Copyright c 2008-2010 Bogdan Kreczmer Niniejszy
Qt sygnały i sloty. Bogdan Kreczmer. Katedra Cybernetyki i Robotyki Wydział Elektroniki Politechnika Wrocławska
Qt sygnały i sloty Bogdan Kreczmer bogdan.kreczmer@pwr.wroc.pl Katedra Cybernetyki i Robotyki Wydział Elektroniki Politechnika Wrocławska Kurs: Copyright c 2018 Bogdan Kreczmer Niniejszy dokument zawiera
Katedra Elektrotechniki Teoretycznej i Informatyki. wykład 12 - sem.iii. M. Czyżak
Katedra Elektrotechniki Teoretycznej i Informatyki wykład 12 - sem.iii M. Czyżak Język C - preprocesor Preprocesor C i C++ (cpp) jest programem, który przetwarza tekst programu przed przekazaniem go kompilatorowi.
Wykład. Materiały bazują częściowo na slajdach Marata Dukhana
Wykład Materiały bazują częściowo na slajdach Marata Dukhana Języki programowania Kompilowane np. C, C++, Pascal Interpretowane np. JavaScript, PHP, Python, VBA Pośrednie np. Java, C# Znane kompilatory
Qt sygnały i designer
Qt sygnały i designer Bogdan Kreczmer bogdan.kreczmer@pwr.wroc.pl Zakład Podstaw Cybernetyki i Robotyki Instytut Informatyki, Automatyki i Robotyki Politechnika Wrocławska Kurs: Copyright c 2015 Bogdan
Wykład VII. Programowanie. dr inż. Janusz Słupik. Gliwice, 2014. Wydział Matematyki Stosowanej Politechniki Śląskiej. c Copyright 2014 Janusz Słupik
Wykład VII Wydział Matematyki Stosowanej Politechniki Śląskiej Gliwice, 2014 c Copyright 2014 Janusz Słupik Kompilacja Kompilator C program do tłumaczenia kodu źródłowego na język maszynowy. Preprocesor
Wyjątki. Wyjątki. Bogdan Kreczmer. Katedra Cybernetyki i Robotyki Politechnika Wrocławska
Bogdan Kreczmer bogdan.kreczmer@pwr.edu.pl Katedra Cybernetyki i Robotyki Politechnika Wrocławska Kurs: Copyright c 2018 Bogdan Kreczmer Niniejszy dokument zawiera materiały do wykładu dotyczącego programowania
METODY I JĘZYKI PROGRAMOWANIA PROGRAMOWANIE STRUKTURALNE. Wykład 02
METODY I JĘZYKI PROGRAMOWANIA PROGRAMOWANIE STRUKTURALNE Wykład 02 NAJPROSTSZY PROGRAM /* (Prawie) najprostszy przykład programu w C */ /*==================*/ /* Między tymi znaczkami można pisać, co się
Wprowadzenie do szablonów szablony funkcji
Wprowadzenie do szablonów szablony funkcji Bogdan Kreczmer ZPCiR IIAiR PWr pokój 307 budynek C3 bogdan.kreczmer@pwr.wroc.pl Copyright c 2006 2010 Bogdan Kreczmer Niniejszy dokument zawiera materiały do
Podstawy języka C++ Maciej Trzebiński. Instytut Fizyki Jądrowej Polskiej Akademii Nauk. Praktyki studenckie na LHC IVedycja,2016r.
M. Trzebiński C++ 1/14 Podstawy języka C++ Maciej Trzebiński Instytut Fizyki Jądrowej Polskiej Akademii Nauk Praktyki studenckie na LHC IVedycja,2016r. IFJ PAN Przygotowanie środowiska pracy Niniejsza
Wprowadzenie do szablonów szablony funkcji
Bogdan Kreczmer ZPCiR IIAiR PWr pokój 307 budynek C3 bogdan.kreczmer@pwr.wroc.pl Copyright c 2006 2010 Bogdan Kreczmer Niniejszy dokument zawiera materiały do wykładu na temat programowania obiektowego.
Co nie powinno być umieszczane w plikach nagłówkowych:
Zawartość plików nagłówkowych (*.h) : #include #define ESC 27 dyrektywy dołączenia definicje stałych #define MAX(x,y) ((x)>(y)?(x):(y)) definicje makr int menu(char* tab[], int ilosc); struct
Przestrzenie nazw. Bogdan Kreczmer. Katedra Cybernetyki i Robotyki Politechnika Wrocławska
Bogdan Kreczmer bogdan.kreczmer@pwr.edu.pl Katedra Cybernetyki i Robotyki Politechnika Wrocławska Kurs: Copyright c 2018 Bogdan Kreczmer Niniejszy dokument zawiera materiały do wykładu dotyczącego programowania
Schemat konstrukcja pliku Makefile
Bogdan Kreczmer bogdan.kreczmer@pwr.wroc.pl Zakład Podstaw Cybernetyki i Robotyki Instytut Informatyki, Automatyki i Robotyki Politechnika Wrocławska Kurs: Copyright c 2008 Bogdan Kreczmer Niniejszy dokument
#line #endif #ifndef #pragma
8.1 Instrukcje preprocesorowe... 1 8.1.1 Instrukcja #define... 1 8.1.2 Instrukcje #pragma... 2 8.2 Polecenie _asm... 3 8.3 Polecenie declspec... 4 8.4 Definiowanie makr... 5 8.5 Programy wieloplikowe,
Wykład 15. Literatura. Kompilatory. Elementarne różnice. Preprocesor. Słowa kluczowe
Wykład 15 Wprowadzenie do języka na bazie a Literatura Podobieństwa i różnice Literatura B.W.Kernighan, D.M.Ritchie Język ANSI Kompilatory Elementarne różnice Turbo Delphi FP Kylix GNU (gcc) GNU ++ (g++)
Operacje wejścia/wyjścia odsłona pierwsza
Bogdan Kreczmer ZPCiR IIAiR PWr pokój 307 budynek C3 bogdan.kreczmer@pwr.wroc.pl Copyright c 2005 2008 Bogdan Kreczmer Niniejszy dokument zawiera materiały do wykładu na temat programowania obiektowego.
Organizacja kursu, paradygmaty, ogólnie o C i C++
Organizacja kursu, paradygmaty, ogólnie o C i C++ Bogdan Kreczmer bogdan.kreczmer@pwr.wroc.pl Katedra Cybernetyki i Robotyki Wydziału Elektroniki Politechniki Wrocławskiej Kurs: Copyright c 2015 Bogdan
Podstawy Informatyki. Inżynieria Ciepła, I rok. Wykład 10 Kurs C++
Podstawy Informatyki Inżynieria Ciepła, I rok Wykład 10 Kurs C++ Historia Lata 70-te XX w język C (do pisania systemów operacyjnych) "The C programming language" B. Kernighan, D. Ritchie pierwszy standard
Biblioteki dzielone, XML i readline
Bogdan Kreczmer bogdan.kreczmer@pwr.edu.pl Katedra Cybernetyki i Robotyki Politechnika Wrocławska Kurs: Copyright c 2017 Bogdan Kreczmer Niniejszy dokument zawiera materiały do wykładu dotyczącego programowania
Zad. 5: Układ równań liniowych liczb zespolonych
Zad. 5: Układ równań liniowych liczb zespolonych 1 Cel ćwiczenia Wykształcenie zdolności abstrahowania operacji arytmetycznych od konkretnych typów. Unaocznienie problemów związanych z programowaniem uogólnionym
Hermetyzacja oraz pola i metody statyczne
Bogdan Kreczmer bogdan.kreczmer@pwr.wroc.pl Zakład Podstaw Cybernetyki i Robotyki Instytut Informatyki, Automatyki i Robotyki Politechnika Wrocławska Kurs: Copyright c 2010 Bogdan Kreczmer Niniejszy dokument
Część 4 życie programu
1. Struktura programu c++ Ogólna struktura programu w C++ składa się z kilku części: część 1 część 2 część 3 część 4 #include int main(int argc, char *argv[]) /* instrukcje funkcji main */ Część
Podstawy wykorzystania bibliotek DLL w skryptach oprogramowania InTouch
INFORMATOR TECHNICZNY WONDERWARE Informator Techniczny nr 60 04-12-2002 Podstawy wykorzystania bibliotek DLL w skryptach oprogramowania InTouch Wstęp PoniŜsza dokumentacja oparta na przykładach stworzonych
Język C - podstawowe informacje
Język C - podstawowe informacje Michał Rad AGH Laboratorium Maszyn Elektrycznych 2014-12-05 Outline Program w języku C Funkcje Składnia Instrukcje sterujace Na koniec... Po kolei napisać program (zwykły
Programowanie w C++ Wykład 9. Katarzyna Grzelak. 14 maja K.Grzelak (Wykład 9) Programowanie w C++ 1 / 30
Programowanie w C++ Wykład 9 Katarzyna Grzelak 14 maja 2018 K.Grzelak (Wykład 9) Programowanie w C++ 1 / 30 Klasy - powtórzenie Klasy typy definiowane przez użytkownika Klasy zawieraja dane składowe plus
Podstawy języka C++ Maciej Trzebiński. Praktyki studenckie na LHC IFJ PAN. Instytut Fizyki Jądrowej Polskiej Akademii Nauk. M. Trzebiński C++ 1/16
M. Trzebiński C++ 1/16 Podstawy języka C++ Maciej Trzebiński Instytut Fizyki Jądrowej Polskiej Akademii Nauk Praktyki studenckie na LHC IFJ PAN 6lipca2015 Uruchomienie maszyny w CC1 M. Trzebiński C++ 2/16
Laboratorium 3: Preprocesor i funkcje ze zmienną liczbą argumentów. mgr inż. Arkadiusz Chrobot
Laboratorium 3: Preprocesor i funkcje ze zmienną liczbą argumentów mgr inż. Arkadiusz Chrobot 10 listopada 2010 1 Preprocesor Preprocesor jest programem uruchamianym przed właściwym procesem kompilacji
Język C++ wykład VIII
Programowanie uzupełnienie notatek: dr Jerzy Białkowski 1 2 3 4 Obiektowość języka C++ ˆ Klasa (rozszerzenie struktury), obiekt instancją klasy, konstruktory i destruktory ˆ Enkapsulacja - kapsułkowanie,
1. Wartość, jaką odczytuje się z obszaru przydzielonego obiektowi to: a) I - wartość b) definicja obiektu c) typ oboektu d) p - wartość
1. Wartość, jaką odczytuje się z obszaru przydzielonego obiektowi to: a) I - wartość b) definicja obiektu c) typ oboektu d) p - wartość 2. Poprawna definicja wskażnika b to: a) float *a, **b = &a; b) float
Szablony funkcji i klas (templates)
Instrukcja laboratoryjna nr 3 Programowanie w języku C 2 (C++ poziom zaawansowany) Szablony funkcji i klas (templates) dr inż. Jacek Wilk-Jakubowski mgr inż. Maciej Lasota dr inż. Tomasz Kaczmarek Wstęp
Język ludzki kod maszynowy
Język ludzki kod maszynowy poziom wysoki Język ludzki (mowa) Język programowania wysokiego poziomu Jeśli liczba punktów jest większa niż 50, test zostaje zaliczony; w przeciwnym razie testu nie zalicza
Programowanie w C++ Wykład 8. Katarzyna Grzelak. 15 kwietnia K.Grzelak (Wykład 8) Programowanie w C++ 1 / 33
Programowanie w C++ Wykład 8 Katarzyna Grzelak 15 kwietnia 2019 K.Grzelak (Wykład 8) Programowanie w C++ 1 / 33 Klasy - powtórzenie Klasy typy definiowane przez użytkownika Klasy zawieraja dane składowe
Rzutowanie i konwersje
Rzutowanie i konwersje Bogdan Kreczmer ZPCiR IIAiR PWr pokój 307 budynek C3 bogdan.kreczmer@pwr.wroc.pl Copyright c 2005 2013 Bogdan Kreczmer Niniejszy dokument zawiera materiały do wykładu na temat programowania
I - Microsoft Visual Studio C++
I - Microsoft Visual Studio C++ 1. Nowy projekt z Menu wybieramy File -> New -> Projekt -> Win32 Console Application w okienku Name: podajemy nazwę projektu w polu Location: wybieramy miejsce zapisu i
Wykład I. Programowanie II - semestr II Kierunek Informatyka. dr inż. Janusz Słupik. Wydział Matematyki Stosowanej Politechniki Śląskiej
Wykład I - semestr II Kierunek Informatyka Wydział Matematyki Stosowanej Politechniki Śląskiej Gliwice, 2015 c Copyright 2015 Janusz Słupik Zaliczenie przedmiotu Do zaliczenia przedmiotu niezbędne jest
public: // interfejs private: // implementacja // składowe klasy protected: // póki nie będziemy dziedziczyć, // to pole nas nie interesuje
Zbudujemy klasę Definicję klasy zapiszmy w pliku tstring.h #ifndef TSTRING_H #define TSTRING_H #include // w pliku nagłówkowym NIE // otwieramy przestrzeni std // interfejs private: // implementacja
Klasa, metody, rozwijanie w linii
Bogdan Kreczmer ZPCiR IIAiR PWr pokój 307 budynek C3 bogdan.kreczmer@pwr.wroc.pl Copyright c 2005 2008 Bogdan Kreczmer Niniejszy dokument zawiera materiały do wykładu na temat programowania obiektowego.
Wstęp do programowania INP003203L rok akademicki 2018/19 semestr zimowy. Laboratorium 3. Karol Tarnowski A-1 p.
Wstęp do programowania INP003203L rok akademicki 2018/19 semestr zimowy Laboratorium 3 Karol Tarnowski karol.tarnowski@pwr.edu.pl A-1 p. 411B Plan prezentacji Dyrektywy preprocesora #include #define Interakcja
Laboratorium 1 Temat: Przygotowanie środowiska programistycznego. Poznanie edytora. Kompilacja i uruchomienie prostych programów przykładowych.
Laboratorium 1 Temat: Przygotowanie środowiska programistycznego. Poznanie edytora. Kompilacja i uruchomienie prostych programów przykładowych. 1. Przygotowanie środowiska programistycznego. Zajęcia będą
Zaawansowane programowanie w języku C++ Funkcje uogólnione - wzorce
Zaawansowane programowanie w języku C++ Funkcje uogólnione - wzorce Prezentacja jest współfinansowana przez Unię Europejską w ramach Europejskiego Funduszu Społecznego w projekcie pt. Innowacyjna dydaktyka
Pola i metody statyczne
Pola i metody statyczne Bogdan Kreczmer ZPCiR IIAiR PWr pokój 307 budynek C3 bogdan.kreczmer@pwr.wroc.pl Copyright c 2005 2009 Bogdan Kreczmer Niniejszy dokument zawiera materiały do wykładu na temat programowania
Wykład 1. Program przedmiotu. Programowanie Obiektowe (język C++) Literatura. Program przedmiotu c.d.:
Program przedmiotu Programowanie Obiektowe (język C++) Wykład 1. Definiowanie prostych klas. Przykłady. Przypomnienie: typy referencyjne, domyślne wartości argumentów, przeciąŝanie funkcji. Konstruktory,
Zasoby, pliki graficzne
Bogdan Kreczmer bogdan.kreczmer@pwr.wroc.pl Katedra Cybernetyki i Robotyki Wydziału Elektroniki Politechnika Wrocławska Kurs: Copyright c 2017 Bogdan Kreczmer Niniejszy dokument zawiera materiały do wykładu
wykład IV uzupełnienie notatek: dr Jerzy Białkowski Programowanie C/C++ Język C, a C++. wykład IV dr Jarosław Mederski Spis Język C++ - wstęp
Programowanie uzupełnienie notatek: dr Jerzy Białkowski 1 2 3 4 Historia C++ został zaprojektowany w 1979 przez Bjarne Stroustrupa jako rozszerzenie języka C o obiektowe mechanizmy abstrakcji danych i
Przesłanianie nazw, przestrzenie nazw
Przesłanianie nazw, przestrzenie nazw Bogdan Kreczmer ZPCiR IIAiR PWr pokój 307 budynek C3 bogdan.kreczmer@pwr.wroc.pl Copyright c 2005 2013 Bogdan Kreczmer Niniejszy dokument zawiera materiały do wykładu
zastępować zarezerwowane słowa lub symbole innymi,
Wykład 7 7. Preprocesor i dyrektywy kompilatora 7.1. Makrodefinicje proste 7.2. Makrodefinicje parametryczne 7.3. Usuwanie definicji makra 7.4. Włączanie innych zbiorów do tekstu programu 7.5. Dyrektywy
Klasa, metody, rozwijanie w linii
Klasa, metody, rozwijanie w linii Bogdan Kreczmer ZPCiR IIAiR PWr pokój 307 budynek C3 bogdan.kreczmer@pwr.wroc.pl Copyright c 2005 2008 Bogdan Kreczmer Niniejszy dokument zawiera materiały do wykładu
Pobieranie argumentów wiersza polecenia
Pobieranie argumentów wiersza polecenia 2. Argumenty wiersza polecenia Lista argumentów Lista argumentów zawiera cały wiersz poleceń, łącznie z nazwą programu i wszystkimi dostarczonymi argumentami. Przykłady:
Wartości domyślne, przeciażenia funkcji
Wartości domyślne, przeciażenia funkcji Bogdan Kreczmer ZPCiR IIAiR PWr pokój 307 budynek C3 bogdan.kreczmer@pwr.wroc.pl Niniejszy dokument zawiera materiały do wykładu na temat programowania obiektowego.
Wykład II. Programowanie II - semestr II Kierunek Informatyka. dr inż. Janusz Słupik. Wydział Matematyki Stosowanej Politechniki Śląskiej
Wykład II - semestr II Kierunek Informatyka Wydział Matematyki Stosowanej Politechniki Śląskiej Gliwice, 2015 c Copyright 2015 Janusz Słupik Operacje dyskowe - zapis do pliku #include #include
Język JAVA podstawy. Wykład 3, część 3. Jacek Rumiński. Politechnika Gdańska, Inżynieria Biomedyczna
Język JAVA podstawy Wykład 3, część 3 1 Język JAVA podstawy Plan wykładu: 1. Konstrukcja kodu programów w Javie 2. Identyfikatory, zmienne 3. Typy danych 4. Operatory, instrukcje sterujące instrukcja warunkowe,
Wartości domyślne, przeciażenia funkcji
Bogdan Kreczmer ZPCiR IIAiR PWr pokój 307 budynek C3 bogdan.kreczmer@pwr.wroc.pl Copyright c 2005 2008 Bogdan Kreczmer Niniejszy dokument zawiera materiały do wykładu na temat programowania obiektowego.
Szablon klasy std::vector
Szablon klasy std::vector Bogdan Kreczmer ZPCiR IIAiR PWr pokój 307 budynek C3 bogdan.kreczmer@pwr.wroc.pl Copyright c 2006 2010 Bogdan Kreczmer Niniejszy dokument zawiera materiały do wykładu na temat
Podstawowe elementy proceduralne w C++ Program i wyjście. Zmienne i arytmetyka. Wskaźniki i tablice. Testy i pętle. Funkcje.
Podstawowe elementy proceduralne w C++ Program i wyjście Zmienne i arytmetyka Wskaźniki i tablice Testy i pętle Funkcje Pierwszy program // Niezbędne zaklęcia przygotowawcze ;-) #include using
Wyliczanie wyrażenia obiekty tymczasowe
Wyliczanie wyrażenia obiekty tymczasowe Bogdan Kreczmer ZPCiR IIAiR PWr pokój 307 budynek C3 bogdan.kreczmer@pwr.wroc.pl Copyright c 2013 Bogdan Kreczmer Niniejszy dokument zawiera materiały do wykładu
Funkcje. Spotkanie 5. Tworzenie i używanie funkcji. Przekazywanie argumentów do funkcji. Domyślne wartości argumentów
Funkcje. Spotkanie 5 Dr inż. Dariusz JĘDRZEJCZYK Tworzenie i używanie funkcji Przekazywanie argumentów do funkcji Domyślne wartości argumentów Przeładowanie nazw funkcji Dzielenie programu na kilka plików
PARADYGMATY PROGRAMOWANIA Wykład 4
PARADYGMATY PROGRAMOWANIA Wykład 4 Metody wirtualne i polimorfizm Metoda wirualna - metoda używana w identyczny sposób w całej hierarchii klas. Wybór funkcji, którą należy wykonać po wywołaniu metody wirtualnej
Szablon klasy std::list
Szablon klasy std::list Bogdan Kreczmer ZPCiR IIAiR PWr pokój 307 budynek C3 bogdan.kreczmer@pwr.wroc.pl Copyright c 2006 2010 Bogdan Kreczmer Niniejszy dokument zawiera materiały do wykładu na temat programowania
1. Pierwszy program. Kompilator ignoruje komentarze; zadaniem komentarza jest bowiem wyjaśnienie programu człowiekowi.
1. Pierwszy program // mój pierwszy program w C++ #include using namespace std; cout
Wykład 1
Wstęp do programowania 1 Bożena Woźna-Szcześniak bwozna@gmail.com Jan Długosz University, Poland Wykład 1 Wprowadzenie Cel wykładów z programowania proceduralnego Wykład jest poświęcony językowi C i jego
Papyrus. Papyrus. Katedra Cybernetyki i Robotyki Politechnika Wrocławska
Katedra Cybernetyki i Robotyki Politechnika Wrocławska Kurs: Zaawansowane metody programowania Copyright c 2014 Bogdan Kreczmer Niniejszy dokument zawiera materiały do wykładu dotyczącego programowania
Wartości domyślne, szablony funkcji i klas
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
Zajęcia nr 1 Podstawy programowania. dr inż. Łukasz Graczykowski mgr inż. Leszek Kosarzewski Wydział Fizyki Politechniki Warszawskiej
Zajęcia nr 1 Podstawy programowania dr inż. Łukasz Graczykowski mgr inż. Leszek Kosarzewski Wydział Fizyki Politechniki Warszawskiej Ramowy program warsztatów 1. Pierwsze: Podstawy programowania 2. Drugie:
Podstawy Informatyki. Kompilacja. Historia. Metalurgia, I rok. Kompilatory C++ Pierwszy program. Dyrektywy preprocesora. Darmowe:
Podstawy Informatyki Metalurgia, I rok Historia Lata 0-te XX w język C (do pisania systemów operacyjnych) "The C programming language" B. Kernighan, D. Ritchie pierwszy standard Koniec lat 80 standard
Podstawy Informatyki. Metalurgia, I rok. Wykład 6 Krótki kurs C++
Podstawy Informatyki Metalurgia, I rok Wykład 6 Krótki kurs C++ Historia Lata 70-te XX w język C (do pisania systemów operacyjnych) "The C programming language" B. Kernighan, D. Ritchie pierwszy standard
Wprowadzenie do UML, przykład użycia kolizja
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
Programowanie obiektowe w języku C++ dr inż. Jarosław Forenc
Rok akademicki 2016/2017, Wykład nr 4 2/45 Plan wykładu nr 4 Informatyka 2 Politechnika Białostocka - Wydział Elektryczny Elektrotechnika, semestr III, studia stacjonarne I stopnia Rok akademicki 2016/2017
Programowanie w języku C++
Programowanie w języku C++ Część dziewiąta Autor Roman Simiński Kontakt siminski@us.edu.pl www.us.edu.pl/~siminski Niniejsze opracowanie zawiera skrót treści wykładu, lektura tych materiałów nie zastąpi
Programowanie strukturalne i obiektowe
Programowanie strukturalne i obiektowe Język C część I Opracował: Grzegorz Flesik Literatura: A. Majczak, Programowanie strukturalne i obiektowe, Helion, Gliwice 2010 P. Domka, M. Łokińska, Programowanie
PROGRAMOWANIE w C prolog
PROGRAMOWANIE w C prolog dr inż. Jarosław Stańczyk Uniwersytet Przyrodniczy we Wrocławiu Wydział Biologii i Hodowli Zwierząt Katedra Genetyki 1 / jaroslaw.stanczyk@up.wroc.pl programowanie w c 17.10.2014
Wprowadzenie do języka Java
WSNHiD, Programowanie 2 Lab. 1 [ część 1 ] Wprowadzenie do języka Java Wprowadzenie Język programowania Java jest obiektowym językiem programowania. Powstał w 1995 i od tej pory był intensywnie rozwijany.
JAVA W SUPER EXPRESOWEJ PIGUŁCE
JAVA W SUPER EXPRESOWEJ PIGUŁCE Obiekt Obiekty programowe to zbiór własności i zachowań (zmiennych i metod). Podobnie jak w świecie rzeczywistym obiekty posiadają swój stan i zachowanie. Komunikat Wszystkie
Praca z aplikacją designer
Bogdan Kreczmer bogdan.kreczmer@pwr.wroc.pl Zakład Podstaw Cybernetyki i Robotyki Instytut Informatyki, Automatyki i Robotyki Politechnika Wrocławska Kurs: Copyright c 2014 Bogdan Kreczmer Niniejszy dokument
Wstęp do Programowania, laboratorium 02
Wstęp do Programowania, laboratorium 02 Zadanie 1. Napisać program pobierający dwie liczby całkowite i wypisujący na ekran największą z nich. Zadanie 2. Napisać program pobierający trzy liczby całkowite
Podstawy programowania skrót z wykładów:
Podstawy programowania skrót z wykładów: // komentarz jednowierszowy. /* */ komentarz wielowierszowy. # include dyrektywa preprocesora, załączająca biblioteki (pliki nagłówkowe). using namespace
Programowanie I. O czym będziemy mówili. Plan wykładu nieco dokładniej. Plan wykładu z lotu ptaka. Podstawy programowania w językach. Uwaga!
Programowanie I O czym będziemy mówili Podstawy programowania w językach proceduralnym ANSI C obiektowym Java Uwaga! podobieństwa w podstawowej strukturze składniowej (zmienne, operatory, instrukcje sterujące...)
Programowanie w C++ Wykład 8. Katarzyna Grzelak. 7 maja K.Grzelak (Wykład 8) Programowanie w C++ 1 / 31
Programowanie w C++ Wykład 8 Katarzyna Grzelak 7 maja 2018 K.Grzelak (Wykład 8) Programowanie w C++ 1 / 31 STL - powtórzenie STL Standard Template Libarary standardowa biblioteka szablonów Składowe biblioteki:
Podstawy Programowania Podstawowa składnia języka C++
Podstawy Programowania Podstawowa składnia języka C++ Katedra Analizy Nieliniowej, WMiI UŁ Łódź, 3 października 2013 r. Szablon programu w C++ Najprostszy program w C++ ma postać: #include #include
Programowanie - wykład 4
Programowanie - wykład 4 Filip Sośnicki Wydział Fizyki Uniwersytet Warszawski 20.03.2019 Przypomnienie Prosty program liczący i wyświeltający wartość silni dla wprowadzonej z klawiatury liczby: 1 # include
Operacje wejścia/wyjścia (odsłona druga) - pliki
Operacje wejścia/wyjścia (odsłona druga) - pliki Bogdan Kreczmer ZPCiR IIAiR PWr pokój 307 budynek C3 bogdan.kreczmer@pwr.wroc.pl Copyright c 2005 2008 Bogdan Kreczmer Niniejszy dokument zawiera materiały
utworz tworzącą w pamięci dynamicznej tablicę dwuwymiarową liczb rzeczywistych, a następnie zerującą jej wszystkie elementy,
Lista 3 Zestaw I Zadanie 1. Zaprojektować i zaimplementować funkcje: utworz tworzącą w pamięci dynamicznej tablicę dwuwymiarową liczb rzeczywistych, a następnie zerującą jej wszystkie elementy, zapisz
2 Przygotował: mgr inż. Maciej Lasota
Laboratorium nr 2 1/7 Język C Instrukcja laboratoryjna Temat: Wprowadzenie do języka C 2 Przygotował: mgr inż. Maciej Lasota 1) Wprowadzenie do języka C. Język C jest językiem programowania ogólnego zastosowania
Wstęp do wiadomości teoretycznych (nie, nie jest to masło maślane ani wstęp, wstępów proszę cierpliwie czytać)
Języki i Paradygmaty Programowania Laboratorium 1 Obiekty i klasy C++ Wstęp do wiadomości teoretycznych (nie, nie jest to masło maślane ani wstęp, wstępów proszę cierpliwie czytać) UWAGA! Umiejętność tworzenia
Pytania sprawdzające wiedzę z programowania C++
Pytania sprawdzające wiedzę z programowania C++ Wstęp 1. Zaprezentuj mechanikę tworzenia programu napisanego w języku C++. 2. Co to jest kompilacja? 3. Co to jest konsolidacja? 4. Co to jest kod wykonywalny?
Programowanie w C++ Wykład 6. Katarzyna Grzelak. kwiecień K.Grzelak (Wykład 6) Programowanie w C++ 1 / 40
Programowanie w C++ Wykład 6 Katarzyna Grzelak kwiecień 2019 K.Grzelak (Wykład 6) Programowanie w C++ 1 / 40 STL - powtórzenie STL Standard Template Libarary standardowa biblioteka szablonów Składowe biblioteki:
Konstruktor kopiujacy
Konstruktor kopiujacy Bogdan Kreczmer ZPCiR IIAiR PWr pokój 307 budynek C3 bogdan.kreczmer@pwr.wroc.pl Niniejszy dokument zawiera materiały do wykładu na temat programowania obiektowego. Jest on udostępniony
Wstęp do programowania. Wykład 1
Wstęp do programowania Wykład 1 1 / 49 Literatura Larry Ullman, Andreas Signer. Programowanie w języku C++. Walter Savitch, Kenrick Mock. Absolute C++. Jerzy Grębosz. Symfonia C++. Standard. Stephen Prata.
Programowanie C++ Wykład 2 - podstawy języka C++ dr inż. Jakub Możaryn. Warszawa, Instytut Automatyki i Robotyki
Wykład 2 - podstawy języka C++ Instytut Automatyki i Robotyki Warszawa, 2014 Wstęp Plan wykładu Struktura programu. Zmienne i ich nazwy, podstawowe typy: całkowite, rzeczywiste, znakowe i napisowe. Instrukcje:
Strona główna. Strona tytułowa. Programowanie. Spis treści. Sobera Jolanta 16.09.2006. Strona 1 z 26. Powrót. Full Screen. Zamknij.
Programowanie Sobera Jolanta 16.09.2006 Strona 1 z 26 1 Wprowadzenie do programowania 4 2 Pierwsza aplikacja 5 3 Typy danych 6 4 Operatory 9 Strona 2 z 26 5 Instrukcje sterujące 12 6 Podprogramy 15 7 Tablice
Java jako język programowania
Java jako język programowania Interpretowany programy wykonują się na wirtualnej maszynie (JVM Java Virtual Machine) Składnia oparta o język C++ W pełni zorientowany obiektowo (wszystko jest obiektem)
Programowanie w C++ Wykład 12. Katarzyna Grzelak. 20 maja K.Grzelak (Wykład 12) Programowanie w C++ 1 / 32
Programowanie w C++ Wykład 12 Katarzyna Grzelak 20 maja 2019 K.Grzelak (Wykład 12) Programowanie w C++ 1 / 32 Klasy - powtórzenie Klasy typy definiowane przez użytkownika Klasy zawieraja dane składowe
Zadanie 2: Arytmetyka symboli
1 Cel ćwiczenia Zadanie 2: Arytmetyka symboli Wykształcenie umiejętności abstrahowania operacji arytmetycznych. Zapoznanie się i przećwiczenie mechanizmu tworzenia przeciążeń funkcji operatorowych. Utrwalenie
Globalne / Lokalne. Wykład 15. Podstawy programowania (język C) Zmienne globalne / lokalne (1) Zmienne globalne / lokalne (2)
Podstawy programowania (język C) Globalne / Lokalne Wykład 15. Tomasz Marks - Wydział MiNI PW -1- Tomasz Marks - Wydział MiNI PW -2- Zmienne globalne / lokalne (1) int A, *Q; // definicja zmiennych globalnych
PARADYGMATY PROGRAMOWANIA Wykład 3
PARADYGMATY PROGRAMOWANIA Wykład 3 Definiowanie operatorów i ich przeciążanie Przykłady zastosowania operatorów: a) operator podstawienia ( = ) obiektów o złożonej strukturze, b) operatory działania na
Zadanie 04 Ktory z ponizszych typow danych w jezyku ANSI C jest typem zmiennoprzecinkowym pojedynczej precyzji?
Zadanie 01 W przedstawionym ponizej programie w jezyku ANSI C w miejscu wykropkowanym brakuje jednej linii: #include... int main() { printf("tralalalala"); return 0; } A. B. "iostream" C.
Zofia Kruczkiewicz, ETE8305_2 1
Wprowadzenie do programowania obiektowego w C++ 1. Główne zasady programowania obiektowego: hermetyzacja, dziedziczenie, polimorfizm 2. Pojęcie klasy: sposoby deklarowania i definiowania składowych klasy,