Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00131 011954 16924019 na godz. na dobę w sumie
Język C/C++ i obliczenia numeryczne. Krótkie wprowadzenie - książka
Język C/C++ i obliczenia numeryczne. Krótkie wprowadzenie - książka
Autor: Liczba stron: 96
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-2152-6 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c - programowanie
Porównaj ceny (książka, ebook, audiobook).

Poznaj zalety języka C/C++!


Język C i jego następca C++ towarzyszą programistom komputerowym już od dawna. Mimo to zainteresowanie tymi językami wcale nie maleje, lecz rośnie — i język C++ nadal się rozwija. Przyczyna jest prosta: nie ma on sobie równych, jeśli chodzi o szybkość działania kodu wynikowego i wszechstronne możliwości zastosowania w różnych dziedzinach. Jednak do nauki tego języka trzeba się trochę przyłożyć. Jeśli przerażają Cię opasłe tomy opisujące C/C++ w najdrobniejszych szczegółach, sięgnij po książkę, która pomoże Ci szybko nauczyć się podstaw programowania w tym języku.

W tym krótkim, treściwym podręczniku pokazano sposób konstruowania programów obliczeniowych na prostych, przejrzystych przykładach. Dzięki temu także i Ty możesz szybko napisać swój pierwszy program, który ułatwi Ci pracę i odpowie na Twoje konkretne potrzeby. Dowiesz się stąd, jak używać poszczególnych elementów programowania w C/C++ jako przygotowania do pracy z gotowymi bibliotekami numerycznymi. Zobaczysz, jak powinna wyglądać struktura Twojego programu i jak zaimplementować w nim różne funkcje. Sprawdzisz, jak efektywnie uczyć się programowania i na co koniecznie należy zwracać uwagę. Zobacz sam!

C/C++ to przepustka do programowania dla każdego!

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Opieka redakcyjna: Ewelina Burska Projekt okładki: Studio Gravite/Olsztyn Obarek, Pokoński, Pazdrijowski, Zaprucki Materiały graficzne na okładce zostały wykorzystane za zgodą Shutterstock. Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/jcconu Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. ISBN: 978-83-283-2152-6 Copyright © Helion 2016 Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis tre(cid:264)ci Wst(cid:246)p .............................................................................................. 5 Rozdzia(cid:228) 1. Szybki start ..................................................................................... 7 Rozdzia(cid:228) 2. Rodzaje wielko(cid:264)ci w j(cid:246)zyku C/C++ i ich deklaracja ......................... 11 Rozdzia(cid:228) 3. Deklaracja tablic ............................................................................ 17 Rozdzia(cid:228) 4. Operacje na zadeklarowanych wielko(cid:264)ciach i funkcje standardowe ..... 19 Rozdzia(cid:228) 5. Instrukcje warunkowe i sterowanie prac(cid:241) programu ........................ 23 Rozdzia(cid:228) 6. Automatyzacja oblicze(cid:254) .................................................................. 31 Rozdzia(cid:228) 7. Architektura programu i pierwsze programy ..................................... 39 Rozdzia(cid:228) 8. Operacje wyprowadzania wyników ................................................... 51 Rozdzia(cid:228) 9. Opis przyk(cid:228)adowych programów do nauki programowania ................. 57 Rozdzia(cid:228) 10. Wska(cid:274)niki, tablice, funkcje, struktury, prze(cid:228)adowanie operatora, liczby zespolone ............................................................................. 63 Rozdzia(cid:228) 11. Przestrzenie nazw ........................................................................... 77 Zako(cid:254)czenie .................................................................................. 81 Dodatek A Cztery programy przyk(cid:228)adowe w oparciu o rozdzia(cid:228)y 9. i 10. ............. 83 Literatura ....................................................................................... 89 Skorowidz ...................................................................................... 91 Poleć książkęKup książkę 4 J(cid:246)zyk C/C++ i obliczenia numeryczne Poleć książkęKup książkę Rozdzia(cid:228) 10. Wska(cid:274)niki, tablice, funkcje, struktury, prze(cid:228)adowanie operatora, liczby zespolone Ka(cid:298)dej wielko(cid:286)ci, np. x, zadeklarowanej w programie przypisany jest w pami(cid:266)ci kom- putera adres, który oznacza si(cid:266) jako x. Adres ten, czyli numer komórki w pami(cid:266)ci komputera, nosi nazw(cid:266) wska(cid:296)nika do wielko(cid:286)ci x. Znaj(cid:261)c wska(cid:296)nik, np. a, mo(cid:298)emy postawi(cid:252) pytanie: co kryje si(cid:266) pod adresem a. Odpowiedzi udzieli nam tzw. operacja dereferencji (nazywana te(cid:298) operacj(cid:261) wy(cid:225)uskiwania), któr(cid:261) zapisuje si(cid:266) jako *a. Je(cid:286)li wi(cid:266)c a = x, to x = *a. Innymi s(cid:225)owy, x jest tym samym co *( x). Zatem gwiazdka umiesz- czona przed symbolem wska(cid:296)nika a „demaskuje” zawarto(cid:286)(cid:252) komórki pami(cid:266)ci o adre- sie a. Zmiennej *a mo(cid:298)emy dalej u(cid:298)ywa(cid:252) w programie zamiast x = (*a), np. zamiast pisa(cid:252) w programie y = x * x;, mo(cid:298)emy u(cid:298)y(cid:252) alternatywy y = (*a) * (*a);, gdzie symbol * mi(cid:266)dzy nawiasami oznacza zwyk(cid:225)e mno(cid:298)enie. Je(cid:286)li w programie chcemy u(cid:298)ywa(cid:252) wska(cid:296)- nika a, to musimy go zadeklarowa(cid:252): typ *a; W deklaracji tej *a musi by(cid:252) tego samego typu co wielko(cid:286)(cid:252), któr(cid:261) wskazuje, tzn. je(cid:286)li a ma wskaza(cid:252) wielko(cid:286)(cid:252) x typu double, to *a musi by(cid:252) zadeklarowane jako double *a; (a samodzielnie nie deklarujemy). Aby oswoi(cid:252) si(cid:266) z wprowadzonymi poj(cid:266)ciami, rozpa- trzmy przyk(cid:225)ad 19. Oto on: Przyk(cid:228)ad 19 ________________________________________________________________________ Poni(cid:298)szy program jest bardzo krótki. Polecenie printf() poni(cid:298)ej wy(cid:286)wietli na ekranie sta(cid:225)(cid:261) x = 2.971828, jej adres w komputerze, a nast(cid:266)pnie wy(cid:286)wietli 2 razy warto(cid:286)(cid:252) zmien- nej x, zapisan(cid:261) w równowa(cid:298)nych postaciach jako *a i *( x). ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// #include stdio.h #include math.h ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Poleć książkęKup książkę 64 J(cid:246)zyk C/C++ i obliczenia numeryczne const double x = 2.971828; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// double *a; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// int main() { a = x; // Poznajemy adres zmiennej x printf( x = f a = d *a = f *( x) = f\n , x, a, *a, *( x)); getchar(); // To pokazuje, (cid:298)e * a i * ( x) to jest to samo co x return 0; } Znamy ju(cid:298) poj(cid:266)cie tablicy oraz sposób, w jaki deklarujemy j(cid:261) w programie. I tu wska(cid:296)niki okazuj(cid:261) si(cid:266) bardzo po(cid:298)yteczne, poniewa(cid:298) zawarto(cid:286)(cid:252) ca(cid:225)ej tablicy mo(cid:298)na (cid:225)atwo odczyta(cid:252), u(cid:298)ywaj(cid:261)c jednego tylko wska(cid:296)nika. Aby to przedstawi(cid:252), zadeklarujmy tablic(cid:266) jednowy- miarow(cid:261) np. jako double tab[10];. Nie wspominali(cid:286)my jeszcze o tym, (cid:298)e samo s(cid:225)owo tab, jako nazwa tablicy, stanowi równocze(cid:286)nie wska(cid:296)nik do jej pierwszego elementu, czyli jego adres. Innymi s(cid:225)owy, tab = tab[0]. Przyj(cid:266)to tu konwencj(cid:266), (cid:298)e: tab[i] = *(tab + i) (93) Wobec tego mamy tu prosty sposób dotarcia do zawarto(cid:286)ci ka(cid:298)dego elementu tablicy, znaj(cid:261)c jedynie wska(cid:296)nik do niej, czyli tab. Dla dwuwymiarowych tablic kwadratowych, zadeklarowanych np. jako double xtab[m][m], obowi(cid:261)zuje wzór: xtab[i][j] = *(b + m * i + j) (94) gdzie b = xtab = xtab[0][0]. Zademonstrujemy to na poni(cid:298)szym przyk(cid:225)adzie. Przyk(cid:228)ad 20 ________________________________________________________________________ Rozpatrujemy tu dwie tablice o nazwach tab (tablica jednowymiarowa o 4 elemen- tach) i xtab (tablica dwuwymiarowa o 4 elementach). Przypisuj(cid:261)c symbolom a i b wska(cid:296)niki (adresy) do tych tablic, wy(cid:286)wietlimy elementy ka(cid:298)dej z tablic na dwa spo- soby. W sposobie pierwszym nie u(cid:298)ywamy wska(cid:296)ników. W sposobie drugim u(cid:298)ywamy pisowni wska(cid:296)nikowej, zdefiniowanej wy(cid:298)ej. Wpisuj(cid:261)c ten program do komputera, mo(cid:298)na si(cid:266) przekona(cid:252), (cid:298)e obydwa te sposoby w zastosowaniu do tablicy tab[4] daj(cid:261) ten sam wynik, co mo(cid:298)na stwierdzi(cid:252), porównuj(cid:261)c dwa pierwsze wydruki przy u(cid:298)yciu printf(). To samo dotyczy wy(cid:286)wietlenia elementów tablicy xtab[2][2] przy u(cid:298)yciu kolejnych dwóch polece(cid:276) printf(). Sprawdzimy te(cid:298), (cid:298)e xtab[i][j] = *(b + m * i + j), gdzie w naszym przyk(cid:225)adzie m = 2 i b = xtab. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// #include stdio.h #include math.h ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// double tab[4]; double xtab[2][2]; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// int main() { double *a, *b; tab[0] = 2.718282; tab[1] = 3.141579; tab[2] = 0.434294; tab[3] = 23.140693; Poleć książkęKup książkę Rozdzia(cid:228) 10. (cid:105) Wska(cid:274)niki, tablice, funkcje, struktury, prze(cid:228)adowanie operatora, liczby zespolone 65 xtab[0][0] = 0.612151; xtab[0][1] = –8.123456; xtab[1][0] = 2.977519; xtab[1][1] = 0.379143; a = tab; printf( tab[0] = f tab[1] = f tab[2] = f tab[3] = f\n , tab[0], tab[1], tab[2], tab[3]); printf( tab[0] = f tab[1] = f tab[2] = f tab[3] = f\n , *a, *(a + 1), *(a + 2), *(a + 3)); b = xtab; printf( xtab[0][0] = f xtab[0][1] = f xtab[1][0] = f xtab[1][1] = f\n , xtab[0][0], xtab[0][1], xtab[1][0], xtab[1][1]); printf( xtab[0][0] = f xtab[0][1] = f xtab[1][0] = f xtab[1][1] = f\n , *b, *(b + 1), *(b + 2), *(b + 3)); // Zgodnie z powy(cid:298)szym wzorem xtab[i][j] = * (b + m * i + j) a dla m = 2 poszczególne elementy // s(cid:261) równe: // xtab[0][0] = * (b + 2 * 0 + 0) = * b, xtab[0][1] = * (b + 2 * 0 + 1) = * (b + 1), // xtab[1][0] = * (b + 2 * 1 + 0) = * (b + 2) oraz xtab[1][1] = * (b + 2 * 1 + 1) = * (b + 3) getchar(); return 0; } Poni(cid:298)ej prezentujemy inny sposób inicjowania tablic. Zamiast deklaracji dwóch tablic tu(cid:298) przed main jako double tab[4]; i double xtab[2][2]; mo(cid:298)na wpisa(cid:252) od razu dekla- racj(cid:266) z przypisaniem warto(cid:286)ci, czyli: double tab[4] = {2.718282, 3.141579, 0.434294, 23.140693}; double xtab[2][2] = {0.612151, –8.123456, 2.977519, 0.379143}; gdzie w przypadku tablic xtab[n][n] wpisujemy najpierw elementy pierwszego wiersza, nast(cid:266)pnie drugiego wiersza itd. U(cid:298)ywaj(cid:261)c powy(cid:298)szej deklaracji z przypisaniem, nale(cid:298)y w main wykre(cid:286)li(cid:252) 8 zb(cid:266)dnych wierszy zawartych pomi(cid:266)dzy liniami double *a, *b; oraz a = tab;. Zasi(cid:266)g zmiennych lokalnych ograniczony jest do obiektu (np. funkcji lub main), w któ- rym zosta(cid:225)y one zadeklarowane. Dlatego cz(cid:266)sto zachodzi potrzeba przekazywania ich z obiektu do obiektu, np. z main do funkcji itp. Wiemy ju(cid:298), (cid:298)e do funkcji mo(cid:298)na przeka- zywa(cid:252) parametry przez ich warto(cid:286)(cid:252) (porównaj (66) i przyk(cid:225)ad 16.). Innym, cz(cid:266)sto u(cid:298)y- wanym sposobem jest przekazywanie parametrów lokalnych przez wska(cid:296)niki. Jest to szczególnie wygodne i cz(cid:266)sto u(cid:298)ywane w praktyce w przypadku tablic. Rozpatrzmy w tym celu przyk(cid:225)ad 21a i b, który to ilustruje. Przyk(cid:228)ad 21 ________________________________________________________________________ a) W przyk(cid:225)adzie tym w celu zachowania prostoty rozpatrujemy funkcj(cid:266) jednoparametrow(cid:261) funk(double *y), do której parametr przekazujemy nie przez warto(cid:286)(cid:252), lecz przez (adres) wska(cid:296)nik y. Sama funkcja wywo(cid:225)ywana jest w main za pomoc(cid:261) polecenia z = funk( x);, co oznacza, (cid:298)e zamiast *y zostanie tam wstawione *y = *( x) = x. Funkcja funk oblicza zatem wyra(cid:298)enie 1. + 2. * cos(*y) dla *y = x i zwraca jego warto(cid:286)(cid:252) za pomoc(cid:261) polecenia return wynik do zmiennej z w main, gdzie nast(cid:266)pnie wy(cid:286)wietlany jest wynik. A oto sam program: Poleć książkęKup książkę 66 J(cid:246)zyk C/C++ i obliczenia numeryczne ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// #include stdio.h #include math.h ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// double funk(double *y); ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// int main() { const double x = 3.; double z; z = funk( x); printf( x = f wynik = f\n , x, z); getchar(); return 0; } ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// double funk(double *y) // Tu * y b(cid:266)dzie równe * ( x) = x po wywo(cid:225)aniu w main z = funk( x); { double wynik; //Opcjonalnie mo(cid:298)na to skróci(cid:252) do: return 1. + 2. * cos(*y); wynik = 1. + 2. * cos(*y); return wynik; } ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// b) Przyk(cid:225)ad ten, b(cid:266)d(cid:261)cy rozwini(cid:266)ciem poprzedniego, pokazuje, jak za pomoc(cid:261) jednego wska(cid:296)nika przekaza(cid:252) do funkcji wiele argumentów zadeklarowanych lokalnie jako tablica. W tym celu wspó(cid:225)czynniki trójmianu w[0]x2 + w[1]x + w[2] deklarujemy lokalnie w main jako tablic(cid:266) w[3], a warto(cid:286)(cid:252) trójmianu obliczamy w funkcji zadeklarowanej jako double funk(double xx, double *y);, przekazuj(cid:261)c do niej argument trójmianu przez jego warto(cid:286)(cid:252) x, a tablic(cid:266) wspó(cid:225)czynników w[3] przez jej wska(cid:296)nik, czyli nazw(cid:266) w. Wywo(cid:225)anie tej funkcji w main (w celu obliczenia warto(cid:286)ci trójmianu) ma zatem posta(cid:252) z = funk(x, w);, gdzie z jest warto(cid:286)ci(cid:261) trójmianu odpowiadaj(cid:261)c(cid:261) x. Sugeruje to, (cid:298)e przy wywo(cid:225)aniu funkcji double funk(double xx, double *y) podstawiamy do niej xx = x i y = w, co oznacza, (cid:298)e wska(cid:296)nik y staje si(cid:266) teraz w (cid:286)rodku funkcji funk nazw(cid:261) tablicy w. Dzi(cid:266)ki temu wspó(cid:225)czynniki trójmianu w funkcji funk, wyst(cid:266)puj(cid:261)ce tam w postaci *y, *(y + 1), *(y + 2) (cid:127) mog(cid:261)ce te(cid:298) wyst(cid:261)pi(cid:252) równowa(cid:298)nie (porównaj (93) jako y[0], y[1], y[2] (cid:127) zostan(cid:261) tam wykorzystane jako *w, *(w + 1), *(w + 2) (czyli równowa(cid:298)nie jako w[0], w[1], w[2]), co umo(cid:298)liwia obliczenie warto(cid:286)ci trójmianu. Polecenie return wynik; przekazuje t(cid:266) warto(cid:286)(cid:252) do zmiennej z w main jako warto(cid:286)(cid:252) zwracan(cid:261). W nast(cid:266)pnej linii w main drukowane s(cid:261) x oraz z, czyli argument i poszukiwana warto(cid:286)(cid:252) trójmianu. Pokazuje to poni(cid:298)szy program: ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// #include stdio.h #include math.h ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// double funk(double xx, double *y); ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// int main() { double w[3]; // Lub double w[3] = {1., 2., 3.}; ale wtedy 3 wiersze tu(cid:298) po double z nale(cid:298)y //skre(cid:286)li(cid:252) const double x = 3.; double z; Poleć książkęKup książkę Rozdzia(cid:228) 10. (cid:105) Wska(cid:274)niki, tablice, funkcje, struktury, prze(cid:228)adowanie operatora, liczby zespolone 67 w[0] = 1.; w[1] = 2.; w[2] = 3.; z = funk(x, w); printf( x = f wynik = f\n , x, z); getchar(); return 0; } ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// double funk(double xx, double *y) { double wynik; wynik=((*y)*xx+(*(y+1)))*xx+(*(y+2)); // Lub te(cid:298) alternatywnie: wynik = (y[0] * xx + // y[1]) * xx + y[2]; return (wynik); } Je(cid:286)li nasz program zawiera tablice i funkcje, to przekazania elementów tablicy (zadekla- rowanej lokalnie) do jakiej(cid:286) funkcji mo(cid:298)na dokona(cid:252) jeszcze pro(cid:286)ciej, ni(cid:298) pokazano to w przyk(cid:225)adzie 21b. W tym celu nale(cid:298)y u(cid:298)y(cid:252) zmodyfikowanej definicji funkcji (66), wprowadzaj(cid:261)c do niej typ i nazw(cid:266) danej tablicy (czyli jej wska(cid:296)nik). W pierwszej linii (66) istniej(cid:261)cy nawias uzupe(cid:225)niamy w nast(cid:266)puj(cid:261)cy sposób: typ nazwa(typ p1, typ p2, ..., typ pn, typ nazwa tablicy [], ...) (95a) a pozosta(cid:225)a cz(cid:266)(cid:286)(cid:252) definicji (66) pozostaje bez zmian. Wyst(cid:266)puj(cid:261)cy po nazwie (wska(cid:296)niku) tablicy nawias [] pozostawiamy pusty, gdy(cid:298) komputer sam rozpozna (po deklaracji tablicy), ile elementów posiada tablica o danej nazwie. Je(cid:286)li do przekazania jest wiele tablic, nale(cid:298)y je wszystkie wpisa(cid:252) po kolei w nawiasie w (95a), u(cid:298)ywaj(cid:261)c rozdzielaj(cid:261)- cego przecinka mi(cid:266)dzy poszczególnymi segmentami okre(cid:286)laj(cid:261)cymi dan(cid:261) tablic(cid:266). Funkcj(cid:266) (95a) wywo(cid:225)ujemy w programie, pisz(cid:261)c np. w odpowiedniej linii polecenie: z = nazwa (p1, p2, ..., pn, nazwa tablicy, ...); (95b) Funkcja, do której przekazujemy tablic(cid:266), mo(cid:298)e by(cid:252) równie(cid:298) typu void, tzn. mo(cid:298)e nie zwraca(cid:252) (cid:298)adnej warto(cid:286)ci. Przypadek ten poka(cid:298)emy ni(cid:298)ej w przyk(cid:225)adzie 25., a teraz przedstawimy bardzo prosty i krótki program (nawi(cid:261)zuj(cid:261)cy do przyk(cid:225)adu 21b), który w praktyce ilustruje przekazywanie tablic w funkcjach za pomoc(cid:261) (95a i b). Przyk(cid:228)ad 22 ________________________________________________________________________ Przedstawiamy tu, zgodnie z definicj(cid:261) (95a), funkcj(cid:266) zadeklarowan(cid:261) jako double calc (cid:180)(double x, double a[]);, która oblicza warto(cid:286)(cid:252) trójmianu kwadratowego w[0]x2 + w[1]x + w[2], gdzie wspó(cid:225)czynniki trójmianu zadeklarowane s(cid:261) lokalnie w main w postaci tablicy w[3]. Sytuacja jest tu o wiele prostsza ni(cid:298) w przyk(cid:225)adzie 21b, gdy(cid:298) polecenie w main w postaci: result = calc(arg, w); od razu przekazuje do funkcji calc ca(cid:225)(cid:261) tablic(cid:266) w[3]. Zatem funkcja calc, po jej wywo(cid:225)aniu, b(cid:266)dzie dzia(cid:225)a(cid:225)a w taki sposób, jakby x zosta(cid:225)o zamienione na arg oraz tablica a na tablic(cid:266) w. Nast(cid:266)pnie obli- czona zastaje warto(cid:286)(cid:252) samego trójmianu. Polecenie return result; przekazuje z kolei warto(cid:286)(cid:252) trójmianu jako warto(cid:286)(cid:252) zwracan(cid:261) do main i umieszcza j(cid:261) w zmiennej wynik. W kolejnej linii nast(cid:266)puje wydruk argumentu arg i obliczonej warto(cid:286)ci trójmianu wynik. Spójrzmy wi(cid:266)c na poni(cid:298)szy program: Poleć książkęKup książkę 68 J(cid:246)zyk C/C++ i obliczenia numeryczne ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// #include stdio.h #include math.h ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// const double arg = 10.; //Argument trójmianu ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// double calc(double x, double a[]); ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// int main() { double w[3]; //Lub double w[] = {1., 2., 3.} double wynik; w[0] = 1.; w[1] = 2.; w[2] = 3.; wynik = calc(arg, w); printf( arg = f wynik = f\n , arg, wynik); getchar(); //Zamiast poprzednich dwóch linii mo(cid:298)na te(cid:298) napisa(cid:252): return 0; //printf( arg = f wynik = f\n , arg, calc(arg, w)); } ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// double calc(double x, double a[]) { double result; result = (a[0] * x + a[1]) * x + a[2]; return result; //Lub return (a[0] * x + a[1]) * x + a[2]; } W j(cid:266)zyku C/C++ istnieje szczególnie przydatna mo(cid:298)liwo(cid:286)(cid:252) wywo(cid:225)ywania funkcji z funk- cji w taki sposób, (cid:298)e parametrem (argumentem) funkcji wywo(cid:225)uj(cid:261)cej mo(cid:298)e by(cid:252) nazwa funkcji wywo(cid:225)ywanej. Naj(cid:225)atwiej jest to zademonstrowa(cid:252) na przyk(cid:225)adzie. W tym celu wykorzystamy tu przyk(cid:225)ad 18., gdzie funkcj(cid:266) podca(cid:225)kow(cid:261) fcn, która zwraca warto(cid:286)(cid:252), zadeklarowali(cid:286)my jako double fcn(double arg);. Analogicznie do tablic samo s(cid:225)owo fcn, oznaczaj(cid:261)ce nazw(cid:266) funkcji, jest równocze(cid:286)nie wska(cid:296)nikiem (adresem) do tej funkcji. Ale po nazwie fcn (a równie(cid:298) po ka(cid:298)dej innej nazwie funkcji) wyst(cid:266)puje jeszcze dodat- kowo nawias (). Przyj(cid:266)to wi(cid:266)c konwencj(cid:266), aby warto(cid:286)(cid:252) zwracan(cid:261) przez funkcj(cid:266) fcn oznacza(cid:252) albo przez fcn(), albo te(cid:298) przez (*fcn)(). Tak wi(cid:266)c funkcj(cid:266) fcn z przyk(cid:225)adu 18. mo(cid:298)na wywo(cid:225)a(cid:252) w programie na dwa sposoby: w znany nam ju(cid:298) sposób, pisz(cid:261)c w jakiej(cid:286) linii polecenie np. y = fcn(x);, lub te(cid:298) pisz(cid:261)c y = (*fcn)(x);. Oba te sposoby wywo(cid:225)a- nia s(cid:261) ca(cid:225)kowicie równowa(cid:298)ne, bo daj(cid:261) w wyniku to samo y jako warto(cid:286)(cid:252) zwracan(cid:261). Zarówno jeden, jak i drugi sposób realizuje w zasadzie wywo(cid:225)anie funkcji za pomoc(cid:261) jej wska(cid:296)nika (adresu), poniewa(cid:298) wska(cid:296)nik ten (tu: nazwa fcn) w obu przypadkach zosta(cid:225) u(cid:298)yty w sposób jawny. Jak wida(cid:252), równie(cid:298) w przypadku funkcji takie poj(cid:266)cia jak „wska(cid:296)nik”, „adres” czy „nazwa” mo(cid:298)na uzna(cid:252) za synonimy. Przyk(cid:225)ad 23., oparty na wspomnianym wy(cid:298)ej przyk(cid:225)adzie 18., pokazuje w sposób konkretny, jak mo(cid:298)na wywo- (cid:225)a(cid:252) funkcj(cid:266) z funkcji za pomoc(cid:261) nazwy funkcji wywo(cid:225)ywanej. Przypomnijmy najpierw, (cid:298)e centraln(cid:261) rol(cid:266) w przyk(cid:225)adzie 18. pe(cid:225)ni trójparametrowa funkcja simpson, zadekla- rowana jako double simpson(double a, double b, int m);. Novum polega na tym, (cid:298)e funkcj(cid:266) t(cid:266) zast(cid:261)pimy w przyk(cid:225)adzie 23. czteroparametrow(cid:261) funkcj(cid:261), któr(cid:261) zadekla- rujemy jako double simpson(double a, double b, int m, double fcn (double x));, a sam(cid:261) funkcj(cid:266) umie(cid:286)cimy w programie po main. Opcjonalnie mo(cid:298)emy tu zast(cid:261)pi(cid:252) fcn Poleć książkęKup książkę Rozdzia(cid:228) 10. (cid:105) Wska(cid:274)niki, tablice, funkcje, struktury, prze(cid:228)adowanie operatora, liczby zespolone 69 przez (*fcn) w ca(cid:225)ej funkcji simpson. Widzimy teraz, (cid:298)e nowa funkcja simpson wywo- (cid:225)uje funkcj(cid:266) fcn przy u(cid:298)yciu jej nazwy, która sta(cid:225)a si(cid:266) argumentem funkcji simpson. Ale argument (parametr) ka(cid:298)dej funkcji mo(cid:298)na przy jej wywo(cid:225)ywaniu zamieni(cid:252) na jaki(cid:286) inny. Nic wi(cid:266)c nie stoi na przeszkodzie, aby funkcj(cid:266) ca(cid:225)kuj(cid:261)c(cid:261) wywo(cid:225)a(cid:252) w main za pomoc(cid:261) polecenia: calka = simpson(a, b, m, funk);. Ale wtedy musimy równie(cid:298) nasz(cid:261) aktualn(cid:261) funkcj(cid:266) podca(cid:225)kow(cid:261) o wybranej przez nas nazwie funk zadeklarowa(cid:252) przed main jako double funk(double x);, a sam(cid:261) funkcj(cid:266) funk umie(cid:286)ci(cid:252) po main. Wywo(cid:225)anie funkcji simpson w programie jako calka = simpson(a, b, m, funk); spowoduje, (cid:298)e funkcja simpson b(cid:266)dzie dzia(cid:225)a(cid:252) teraz dok(cid:225)adnie tak, jakby jej program zosta(cid:225) od razu napisany przy u(cid:298)yciu nazwy funk zamiast wcze(cid:286)niejszej nazwy fcn. Oznacza to, (cid:298)e w samej funkcji simpson warto(cid:286)(cid:252) zwracana przez fcn zostanie auto- matycznie zast(cid:261)piona warto(cid:286)ci(cid:261) zwracan(cid:261) przez funk (porównaj te(cid:298) przyk(cid:225)ad 23.). Widzimy wi(cid:266)c, (cid:298)e mamy tu teraz sytuacj(cid:266) bardziej komfortow(cid:261) ni(cid:298) w przyk(cid:225)adzie 18., bo funkcj(cid:266) podca(cid:225)kow(cid:261), która wspó(cid:225)pracuje z procedur(cid:261) ca(cid:225)kuj(cid:261)c(cid:261), mo(cid:298)emy teraz nazwa(cid:252), jak chcemy (np. funk). Niezwykle wa(cid:298)ny jest te(cid:298) fakt, (cid:298)e tak zaprogramowana funkcja simpson, umo(cid:298)liwiaj(cid:261)ca u(cid:298)ycie dowolnej nazwy dla funkcji podca(cid:225)kowej, b(cid:266)dzie funk- cjonowa(cid:252) równie(cid:298) i wtedy, gdy funkcja simpson zostanie najpierw skompilowana do pliku o okre(cid:286)lonej nazwie, a nast(cid:266)pnie (jako plik w j(cid:266)zyku wewn(cid:266)trznym) do(cid:225)(cid:261)czona do programu w(cid:225)a(cid:286)ciwego w procesie kompilacji i konsolidacji. W przyk(cid:225)adzie 23. omó- wimy teraz szczegó(cid:225)owo to, co nale(cid:298)y zmieni(cid:252) w programie z przyk(cid:225)adu 18., aby uzyska(cid:252) po(cid:298)(cid:261)dan(cid:261) swobod(cid:266) w wyborze nazwy funkcji podca(cid:225)kowej (przej(cid:286)cie od wspomnianej wersji 1 do bardziej u(cid:298)ytecznej wersji 2). Przyk(cid:228)ad 23 ________________________________________________________________________ Aby przej(cid:286)(cid:252) od wersji 1 do wersji 2, nale(cid:298)y w przyk(cid:225)adzie 18. (tu(cid:298) przed main) usun(cid:261)(cid:252) poprzedni(cid:261) deklaracj(cid:266) i zast(cid:261)pi(cid:252) j(cid:261) now(cid:261) (w poni(cid:298)szej linii deklarujemy jednocze(cid:286)nie dwie funkcje, czyli simpson i funk, oddzielone przecinkiem!): double simpson(double a, double b, int m, double fcn(double x)), funk(double x); Zauwa(cid:298)my przy tym, (cid:298)e funkcja podca(cid:225)kowa nazywa si(cid:266) teraz funk i dlatego nazw(cid:266) funkcji podca(cid:225)kowej na ko(cid:276)cu przyk(cid:225)adu 18. nale(cid:298)y zamieni(cid:252) na double funk(double x). Nast(cid:266)pnie w main zamiast polecenia wywo(cid:225)uj(cid:261)cego funkcj(cid:266) ca(cid:225)kuj(cid:261)c(cid:261) wpisujemy calka = simpson(a, b, m, funk);. Kolejna zmiana dotyczy samej procedury ca(cid:225)kuj(cid:261)cej, w której nale(cid:298)y zast(cid:261)pi(cid:252) star(cid:261) nazw(cid:266) (o trzech argumentach) now(cid:261) (o czterech argumentach), a mianowicie: /////////////////////////////////////////////////////////////////Procedura ca(cid:225)kuj(cid:261)ca/////////////////////////////////////////////////////// double simpson(double a, double b, int m, double fcn(double x)) { // Bez zmian } ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// gdzie samo wn(cid:266)trze tej procedury jest identyczne jak w przyk(cid:225)adzie 18. Wywo(cid:225)uj(cid:261)c w programie funkcj(cid:266) ca(cid:225)kuj(cid:261)c(cid:261) calka = simpson(a, b, m, funk);, powodujemy, (cid:298)e wyst(cid:266)puj(cid:261)ce wewn(cid:261)trz nowej funkcji simpson wywo(cid:225)ania fcn(a), fcn(b) i fcn(x) (porów- naj wn(cid:266)trze procedury w przyk(cid:225)adzie 18.) b(cid:266)d(cid:261) funkcjonowa(cid:225)y identycznie jak odpo- wiednio funk(a), funk(b) i funk(x), bo funk zast(cid:266)puje teraz wsz(cid:266)dzie fcn. W listingu A.1 umieszczonym w dodatku A podajemy pe(cid:225)ny tekst ulepszonej wersji 2, aby (przez porównanie z wersj(cid:261) 1) naj(cid:225)atwiej mo(cid:298)na by(cid:225)o prze(cid:286)ledzi(cid:252) wszystkie zmiany dokonane przy przej(cid:286)ciu od wersji 1 do wersji 2. Poleć książkęKup książkę 90 J(cid:246)zyk C/C++ i obliczenia numeryczne Poleć książkęKup książkę Skorowidz A adres, 63 funkcji, 68 tablicy, 64 zmiennej, 63 akumulator, 32 architektura programu, 39 argumenty funkcji, 45, 46 automatyzacja oblicze(cid:276), 31 B biblioteki specjalistyczne, 39 biblioteki standardowe, 39 complex , 76, 78 float.h , 45, 80 iostream , 79 limits.h , 45, 80 math.h , 44 stdio.h , 44 bisekcja, 60, 85 blok instrukcji, 38 break, 27, 37 C ca(cid:225)kowanie metod(cid:261) Gaussa – Legende’a, 59, 84 Simpsona, 57, 83 case,27 complex , 76, 78 const, 14 cout, 79 D definicja (deklaracja) funkcji, 45, 46 sta(cid:225)ej, 14 struktury, 72, 73 tablicy, 17 wska(cid:296)nika, 63 zmiennej, 14 dekrementacja, 32 dereferencja, 63 double, 13 drukowanie wyników, 52, 53, 79 dyrektywa #define, 14, 48 #include, 39 dzielenie liczb ca(cid:225)kowitych, 21 else, 24 else if, 24 E F fclose, 54 float, 13 float.h , 45, 80 fopen, 53 for, 31 fprintf, 54 funkcje z prze(cid:225)adowanym operatorem, 73 - 75 zwracaj(cid:261)ce warto(cid:286)(cid:252), 45, 46 funkcje typu inline, 48 main, 48 standardowe, 19, 20 void, 46, 48 Poleć książkęKup książkę 92 J(cid:246)zyk C/C++ i obliczenia numeryczne getch, 35, 36 getchar, 35, 36 goto, 36, 37 G I #include, 39, 40 inkrementacja, 32 inline, 48, 49 instrukcje warunkowe, 23, 37 do…while, 33 if…else if, 24, 25 if, 23 if…else, 24 switch, 27 while, 33 K klucz do przestrzeni nazw, 77 kropka dziesi(cid:266)tna, 9, 11 L liczby ca(cid:225)kowite, 12 zespolone, 73 zmiennopozycyjne, 13 licznik p(cid:266)tli, 32 limits.h , 45, 80 (cid:225)a(cid:276)cuchy symboli, 12 (cid:224) M main, 48 makroinstrukcje, 48 math.h , 44 metoda bisekcji, 60, 85 Gaussa – Legendre’a, 59, 84 Newtona, 60, 61, 86 Simpsona, 57, 83 miejsce zerowe funkcji, 60 N napisy i ich umieszczanie, 51 nazwy sta(cid:225)ych, 11–14 struktur, 71, 72 zmiennych, 11–14 O obliczanie ca(cid:225)ki, 57, 59, 83, 84 operacje arytmetyczne, 19 logiczne, 26 porównywanie liczb, 26 przypisania, 14 operatory, 21 prze(cid:225)adowania, 73 - 75 otwarcie pliku, 53 P parametry funkcji, 45, 46 p(cid:266)tla do…while, 33 for, 31 while, 33 pliki nag(cid:225)ówkowe, 39 precyzja podwójna, 13 pojedyncza, 13 printf, 52 przekazywanie parametrów, 45 tablic, 67 wska(cid:296)ników, 65, 66 przestrzenie nazw, 77 puts, 47, 51 R reszta z dzielenia, 21 return, 40, 45 równanie kwadratowe, 7 S schemat programu, 39, 40 s(cid:225)owa kluczowe, 12 sta(cid:225)a, 14 stdio.h , 44 Poleć książkęKup książkę Skorowidz sterowanie prac(cid:261) programu, 23 sterowanie wydrukiem, 51 - 55 struktury, 72, 73 switch, 27 symbole //, 7 /*…*/, 41 (cid:286)rednik, 10 (cid:263) T tablice, 17 typy danych ca(cid:225)kowite, 12 char, 12 (cid:225)a(cid:276)cuchowe, 12 zmiennopozycyjne, 13 U using namespace std, 78 utrata dok(cid:225)adno(cid:286)ci, 41 V void, 46, 48 93 W warunek, 25, 26 wektory, 17, 72 wska(cid:296)niki, 63 wy(cid:225)uskiwanie, 63 wyra(cid:298)enie logiczne, 26 wywo(cid:225)ywanie funkcji, 46 funkcji z funkcji, 68, 69 Z zakresy wielko(cid:286)ci, 12, 13, 45, 80 zamkni(cid:266)cie pliku, 54 zapisywanie do pliku, 53, 54 zatrzymanie zmienne p(cid:266)tli, 33, 34 programu, 35, 36 globalne, 40, 47 lokalne, 47 (cid:225)a(cid:276)cuchowe, 12 zwracanie warto(cid:286)ci, 45, 46 Poleć książkęKup książkę 94 J(cid:246)zyk C/C++ i obliczenia numeryczne Poleć książkęKup książkę
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Język C/C++ i obliczenia numeryczne. Krótkie wprowadzenie
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: