19
[email protected] Metody numeryczne, i Zmiennoprzecinkowe: float i double int unsigned i signed, z long, short char i typ logiczny bool string) i wektor (vector Komentarze // /* */" const double pi=3.14159; // stala pi /* ten komentarz zaczyna sie tu i konczy sie tu */ Przypisanie a porównanie =) i porównania (== :="). Drugi z nich (==), który odpowiada pascalowskiemu "= bool: true false, w a=b; // teraz a rowne jest b przypisanie c=d+3; // teraz c rowne jest d+3 przypisanie a=b=c=5; // teraz a, b i c rowne sa 5 przypisanie wielokrotne if(a==3) ... // zrob cos, jesli a rowne jest 3 porównanie if(a=3) ... // niedobrze. Zamiast porownac a z 3, przypisalismy 3 do a...

:VW S G R& - mif.pg.gda.pl · • metody numeryczne, • $ojr u\wp\uyzq r ohjáh • =d vwrvrzdqlhu y * q\fk urgrzl v nn r psxwhurz\fkgrreol f ]h qxp h u\ f ]q \ fk 8zdjlu y * qh

Embed Size (px)

Citation preview

Page 1: :VW S G R& - mif.pg.gda.pl · • metody numeryczne, • $ojr u\wp\uyzq r ohjáh • =d vwrvrzdqlhu y * q\fk urgrzl v nn r psxwhurz\fkgrreol f ]h qxp h u\ f ]q \ fk 8zdjlu y * qh

Y����������±�������-DFHN�']LHG]LF��)7L06��3ROLWHFKQLND�*GD�VND��� [email protected]

:VWS�GR�&����±SUDNW\F]QH�ZVND]yZNL�XáDWZLDM�FH�SUDF�QD�]DMFLDFK�]�SU]HGPLRWyZ

• 2ELHNWRZH�M]\NL�SURJUDPRZDQLD�• 3URJUDPRZDQLH�ZVSyáELH*QH�L�UyZQROHJáH�• Metody numeryczne,• $OJRU\WP\�UyZQROHJáH�• =DVWRVRZDQLH�Uy*Q\FK��URGRZLVN�NRPSXWHURZ\FK�GR�REOLF]H��QXPHU\F]Q\FK�

8ZDJL�Uy*QH&��� UR]Uy*QLD�PDáH� L� ZLHONLH� OLWHU\�� .D*GD� LQVWUXNFMD� NR�F]\� VL� �UHGQLNLHP�� 'RSXV]F]DOQH� MHVWSLVDQLH� NLONX� LQVWUXNFML� Z� MHGQ\P� ZLHUV]X�� MH�OL� ND*GD� NR�F]\� VL� �UHGQLNLHP�� 2GVWS\� �VSDFMH�WDEXODWRU\�� ]QDNL� QRZHM� OLQLL�� PLG]\� LQVWUXNFMDPL�� RSHUDWRUDPL� L� Z\UD*HQLDPL� V�� LJQRURZDQH�6áRZR� �IXQNFMD�� PD� Z�M]\NX� &��� ]QDF]HQLH� EDUG]LHM� ]EOL*RQH� GR� VáyZ� �SRGSURJUDP�i��SURFHGXUD��QL*�GR�IUD]\��Z\UD*HQLH�PDWHPDW\F]QH��1DMZD*QLHMV]H�W\S\�GDQ\FKZmiennoprzecinkowe: float i double �� FDáNRZLWH� �int �� ]� SRG]LDáHP� QD� unsigned i signed ,z�SRG]LDáHP�QD� long , short � L� ]Z\NáH���W\S�]QDNRZ\�char i typ logiczny bool �±�RPyZLáHP�SU]\WDEOLF\��7\S\�áD�FXFKRZ\��string ) i wektor (vector ��RPDZLDP\�Sy(QLHM�Komentarze

:� &��� Z\VWSXM�� GZD� URG]DMH� NRPHQWDU]\�� .RPHQWDU]� UR]SRF]\QDM�F\� VL� RG� SRGZyMQHJRXNR�QLND��// ��UR]FL�JD�VL�GR�NR�FD�OLQLL��.RPHQWDU]�UR]SRF]\QDM�F\�VL�RG��/* ��D�NR�F]�F\��*/ "PR*H� UR]FL�JDü� VL� QD� NLOND� OLQLL�� =DZDUWR�ü� NRPHQWDU]D� MHVW� ±� QDWXUDOQLH� ±� LJQRURZDQD�.RPHQWDU]\�QLH�PR*QD�]DJQLH*G*Dü��V��Z\M�WNL��DOH�XGDMHP\�*H�QLH�PD���3U]\NáDG\�NRPHQWDU]\�const double pi=3.14159; // stala pi/* ten komentarz zaczyna sie tu���UR]FL�JD�VL�WX i konczy sie tu */

Przypisanie a porównanie

1DOH*\� ]ZUyFLü� V]F]HJyOQ�� XZDJ� QD� Uy*QLF� PLG]\� RSHUDWRUDPL� SU]\SLVDQLD� �=) i porównania(==��� 3LHUZV]\� ]� QLFK� VáX*\� GR� SU]\SLV\ZDQLD� ZDUWR�FL� VWRM�FHM� SR� SUDZHM� VWURQLH� GR� ]PLHQQHMVWRM�FHM�SR� OHZHM�VWURQLH��RGSRZLHGQLN�SDVFDORZVNLHJR��:= "). Drugi z nich (==), który odpowiadapascalowskiemu "=�� VáX*\� GR� SRUyZQ\ZDQLD� L� ]ZUDFD�ZDUWR�ü� W\SX� bool : true �� E�G(� false , w]DOH*QR�FL�RG�Z\QLNX�SRUyZQDQLD��3U]\NáDGRZR�a=b; // teraz a rowne jest b przypisaniec=d+3; // teraz c rowne jest d+3 przypisaniea=b=c=5; // teraz a, b i c rowne sa 5 przypisanie wielokrotneif(a==3) ... // zrob cos, jesli a rowne jest 3 porównanieif(a=3) ... // niedobrze . Zamiast porownac a z 3, przypisalismy 3 do a...

-H�OL�RP\áNRZR�]DPLDVW�SRUyZQDQLD�]DVWRVXMHP\�SU]\SLVDQLH��MHVW�V]DQVD�*H�NRPSLODWRU�]ZUyFL�QDPQD�WR�XZDJ�Z\SLVXM�F�RVWU]H*HQLH��DOH�JZDUDQFML�QLH�PD��OHSLHM�VL�SLOQRZDü�

Page 2: :VW S G R& - mif.pg.gda.pl · • metody numeryczne, • $ojr u\wp\uyzq r ohjáh • =d vwrvrzdqlhu y * q\fk urgrzl v nn r psxwhurz\fkgrreol f ]h qxp h u\ f ]q \ fk 8zdjlu y * qh

Y����������±�������-DFHN�']LHG]LF��)7L06��3ROLWHFKQLND�*GD�VND��� [email protected]

=PLHQQH��VWDáH=PLHQQH� GHNODUXMHP\� SRGDM�F� QDMSLHUZ� W\S� ]PLHQQHM�� SRWHP� MHM� QD]Z�� 'RSXV]F]DOQH� MHVW� WH*GHNODURZDQLH�NLONX�]PLHQQ\FK�WHJR�VDPHJR�W\SX��]D�MHGQ\P�]DPDFKHP���3U]\NáDG�LQW�D�������������������GHNODUXMH�]PLHQQ��D�W\SX�FDáNRZLWHJRIORDW�F�����������������GHNODUXMH�]PLHQQ��F�W\SX�]PLHQQRSU]HFLQNRZHJRXQVLJQHG�ORQJ�LQW�S�����GHNODUXMH�]PLHQQ��S�W\SX�FDáNRZLWHJR��GáXJLHJR� // bez-znakudouble a,b,c,d; // deklaruje zmienne a, b, c, d, wszystkie typu // zmiennoprzecinkowego podwójnej precyzji

'HNODUDFMD� MHVW� LQIRUPDFM�� GOD� NRPSLODWRUD�� LQIRUPXMH� JR� R� W\P�� FR� PDP\� QD� P\�OL� NRU]\VWDM�FSy(QLHM�]�QD]Z\�WHM�]PLHQQHM��.D*GD�]PLHQQD�PXVL�E\ü�JG]LH��]DGHNODURZDQD� Uwaga: ZmienneLQWHUHVXM�F\FK� QDV� W\SyZ� SR� ]DGHNODURZDQLX� nie V�� ]HURZDQH�� D� PDM�� ZDUWR�FL� SU]\SDGNRZH1.:DUWR� R� W\P� SDPLWDü�� LQLFMDOL]XM�F� �SU]\SLVXM�F�� XVWDZLDM�F�� ]PLHQQH� SU]HG� LFK� SLHUZV]\PX*\FLHP�� 'RSXV]F]DOQH� MHVW� á�F]HQLH� LQLFMDOL]DFML� ]PLHQQHM� ]� MHM� GHNODUDFM��� FR� ]DEH]SLHF]D� QDVSU]HG�NáRSRWDPL�]ZL�]DQ\PL�]�QLH]DLQLFMDOL]RZDQLHP��R�WDN�LQW�D �����������GHNODUXMH�]PLHQQ��D�W\SX�FDáNRZLWHJR��XVWDZLD�M��QD��GRXEOH�E ��������M�Z��W\SX�GRXEOH��XVWDZLD�M��QD�����

-]\N� &��� SR]ZDOD� QD� GHNODURZDQLH� ]PLHQQ\FK� SUDZLH� Z� ND*G\P� PLHMVFX� SURJUDPX�� 1LH� PDNRQLHF]QR�FL� �MDN� Z� 3DVFDOX� F]\� )RUWUDQLH�� GHNODURZDQLD� ]PLHQQ\FK� Z� �FL�OH� RNUH�ORQ\FKmiejscach. Zmienne deklarujemy tam, gdzie nam wygodnie.

.D*GD�]PLHQQD�PD�VZyM��F]DV�*\FLD��±�F]\OL�SHZLHQ�]DVLJ�Z�SURJUDPLH��Z�NWyU\P�MHVW�ZLGRF]QD�1D�SU]\NáDG�]PLHQQD�]DGHNODURZDQD�ZHZQ�WU]�IXQNFML�EG]LH�ORNDOQD�GOD�WHM�IXQNFML���QLH�EG]LH�MHMZLGDü��SR]D�W�� IXQNFM���3RGREQLH�]PLHQQD�]DGHNODURZDQD�Z�SWOL� MHVW�SR]D� W�� SWO�� QLHZLGRF]QD�8PR*OLZLD� WR� RV]F]GQH� JRVSRGDURZDQLH� QD]ZDPL�� =PLHQQD� ]DGHNODURZDQD� SR]D� MDN�NROZLHNIXQNFM�� MHVW� ]PLHQQ�� JOREDOQ��� WM�� ZLG]LDOQ�� Z� ND*G\P� SXQNFLH� SURJUDPX�� 'REU\� VW\O� QDND]XMHXQLNDQLH� ]PLHQQ\FK� JOREDOQ\FK�� SUDJPDW\ND� QDND]XMH� VWRVRZDQLH� LFK� EH]� ]DKDPRZD��� MH�OL� V�QDSUDZG�NRQLHF]QH��]ZáDV]F]D�Z�SURVW\FK�SURJUDPDFK���1DOH*\�]DFKRZDü�UyZQRZDJ�:).6WDáH�Uy*QL��VL�W\P�RG�]PLHQQ\FK��*H�SU]HG�QD]Z�� W\SX�GRGDMHP\�modyfikator const . InformujeRQ� NRPSLODWRU�� *H� GHNODUXMHP\� QLH� ]PLHQQ��� D� VWDá��� :DUWR�FL� VWDá\FK� QLH� PR*QD� ]PLHQLü�SU]\QDMPQLHM�QLH�Z�VSRVyE�EH]SR�UHGQL���6WDáH�WU]HED� LQLFMDOL]RZDü�SU]\�GHNODUDFML��ER�SRWHP� MX*QLH�PR*QD�QLF�GR�QLFK�SU]\SLVDü��Z�NR�FX�V��VWDá\PL�2���6WDáH�Z�&���V��EDUG]R�SRGREQH�GR�VWDá\FKZ� 3DVFDOX�� V�� WH*� EDUG]LHM� F\ZLOL]RZDQ�� IRUP�� NRQVWUXNFML� 3$5$0(7(5� Z\VWSXM�FHM� ZFortranie.3U]\NáDG\�const �IORDW�SL ��������������GHNODUXMH�L�GHILQLXMH�VWDá��SLconst �LQW�W\VLDF ������������GHNODUXMH�L�GHILQLXMH�VWDá��W\VLDF... // gdzies dalej, w programie...GRXEOH�SROH SL U U�����REOLF]D�SROH�MDNLHJR��RNUJX��NRU]\VWDM�F�]H�VWDáHMSL ���������SUyED�]PRG\ILNRZDQLD�VWDáHM��WR�QLH�SU]HMG]LH�

']LNL� WHPX�� *H� MDZQLH� R]QDF]\OL�P\� SL� L� W\VLDF� MDNR� VWDáH�� NRPSLODWRU� QLH� SR]ZROL� QDP� LFK]PLHQLü��JG\E\�P\�SU]H]�SU]\SDGHN�FKFLHOL�WR�]URELü���PR*H�UyZQLH*�Z\NRU]\VWDü�IDNW��*H�ZDUWR�FLVWDá\FK�QLH�]PLHQLDM��VL�GR�WHJR��DE\�]RSW\PDOL]RZDü�QDV]�SURJUDP�:QLRVHN��VWDáH�V��GREUH. 1��FL�OH�U]HF]�ELRU�F��]PLHQQH�lokalne typów wbudowanych nie V��]HURZDQH��D�]PLHQQH�JOREDOQH�V��±�VáX*\�WR]ZLNV]HQLX�Z\GDMQR�FL��VNáDGDM�F�RGSRZLHG]LDOQR�ü�]D�LQLFMDOL]DFM�]PLHQQ\FK�QD�EDUNL�SURJUDPLVW\�2�1LH�GR�NR�FD�SUDZGD�

Page 3: :VW S G R& - mif.pg.gda.pl · • metody numeryczne, • $ojr u\wp\uyzq r ohjáh • =d vwrvrzdqlhu y * q\fk urgrzl v nn r psxwhurz\fkgrreol f ]h qxp h u\ f ]q \ fk 8zdjlu y * qh

Y����������±�������-DFHN�']LHG]LF��)7L06��3ROLWHFKQLND�*GD�VND��� [email protected]

'R�VWDá\FK�RGQRV]�� VL� WH�VDPH�UHJXá\��F]DVX�*\FLD���FR�GR�]PLHQQ\FK��-H�OL� ]DGHNODUXMHP\� VWDá�QLH�Z� WUH�FL� MDNLHMNROZLHN� IXQNFML� �R� IXQNFMDFK� ]DUD]��� DOH� SR]D� IXQNFM�� �QD� SU]\NáDG� QD� VDP\PSRF]�WNX�SURJUDPX���VWDáD�WD�EG]LH�JOREDOQD�±�ZLG]LDOQD�]�ND*GHJR�SXQNWX�SURJUDPX�2�LOH�JOREDOQH�]PLHQQH�V��SUDZLH�]�QDWXU\�]áH��WR�JOREDOQH�VWDáH�V��QLHJáXSLP�SRP\VáHP��3R]ZDODM�Z� MHGQ\P� PLHMVFX� SURJUDPX� �QS�� QD� SRF]�WNX�� ]HEUDü� ZD*QH� VWDáH�� NWyU\PL� SURJUDP� RSHUXMH�Z�GUXJLHM�VWURQ\��VWDáH��NWyUH�V��QLH� LVWRWQH�]�SXQNWX�ZLG]HQLD�SURJUDPX��D�V�� MHG\QLH�QD�SRWU]HE\MDNLHM��IXQNFML�ZDUWR�XNU\ZDü�ZHZQ�WU]�WDNLHM�IXQNFML�

3U]\NáDG��7$.�URELü):���SRF]�WHN�SURJUDPXconst double pi=3.141592653589793238462643383; // } <- widziane wconst double obwod_ziemi=40000000; // } calym programieconst unsigned int rozmiar_tablicy=999; // }

// ... cos dalej

// przykladowa funkcja, z malo wazna stala ukryta wewnatrz funkcjiint odliczanie_do_10() { const unsigned int limit=10; for(int i=1;i<=limit;++i) rob_cos();}

// ... cos dalej

:�SRZ\*V]\P� SU]\NáDG]LH� VNRU]\WDOL�P\� MX*� ]� funkcji� L� ]� SWOL� for�� R� NWyU\FK� EG]LH� ]D� FKZLO�ZDUWR�SRWHP�ZUyFLü�GR�WHJR�SU]\NáDGX�Podstawowe operatory

Dwuargumentowe operatory dodawania (+), odejmowania (- ���PQR*HQLD��* ) i dzielenia (/ ��G]LDáDM�]JRGQLH�]�LQWXLFM���0R*QD�VWRVRZDü�MH�]DUyZQR�GR�OLF]E�]PLHQQRSU]HFLQNRZ\FK��MDN�L�FDáNRZLW\FK�SU]\�F]\P�QDOH*\�SDPLWDü�R�SXáDSNDFK�]ZL�]DQ\FK�]�G]LHOHQLHP�FDáNRZLW\P�double a; // 1 jest typu int, b jest typu int, wiec i wynik 1/b bedzie typuint b=2; // int. Ale typ int nie moze przechowac wartosci 0.5, nawet jeslia=1/b; // za chwile zostanie zamieniony na double. Dlatego a==0...

=�SR]RVWDá\FK�RSHUDWRUyZ�LVWRWQH�PRJ��E\ü�PLQXV�MHGQRDUJXPHQWRZ\��- ) i plus jednoargumentowy(+), ten drugi jest ignorowany.

double a=7.3; double b;a=-a; // a teraz równe -7.3b=+a; // + zignorowany, czyli b teraz równe a, czyli -7.3

Operator modulo (reszty z dzielenia) (%���W\ONR�GOD�OLF]E�FDáNRZLW\FK�int p=10 % 3; // p rowne jest reszcie z dzielenia 10/3, czyli 1.

&���� WDN� MDN� 3DVFDO�� QLH� PD� RSHUDWRUD� SRWJRZDQLD� Z� VW\OX� )RUWUDQX�� 3RWJRZDQLH� PR*QDUHDOL]RZDü�]D�SRPRF�� IXQNFML�pow() � ]GHILQLRZDQHM� Z� SOLNX� QDJáyZNRZ\P� cmath � �EG]LH� R� W\PSy(QLHM���E�G(�WH*��UF]QLH���MH�OL�MHVW�QLHVNRPSOLNRZDQH�GRXEOH�D SRZ��������������D�URZQH�MHVW�����GR�SRWJL����GRXEOH�E D D D������������E�URZQH�MHVW�D�GR�WU]HFLHM��REOLF]RQH�UF]QLH

Page 4: :VW S G R& - mif.pg.gda.pl · • metody numeryczne, • $ojr u\wp\uyzq r ohjáh • =d vwrvrzdqlhu y * q\fk urgrzl v nn r psxwhurz\fkgrreol f ]h qxp h u\ f ]q \ fk 8zdjlu y * qh

Y����������±�������-DFHN�']LHG]LF��)7L06��3ROLWHFKQLND�*GD�VND��� [email protected]

2EOLF]DQLH��UF]QH��SU]HVWDMH�VL�RSáDFDü��ZLFHM�SLVDQLD��ZROQLHM�G]LDáD��SU]\�SRWJDFK�ZLNV]\FKod 4.

2SHUDWRU\� SRUyZQDQLD� L� SU]\SLVDQLD� RPyZLOL�P\� MX*� ZF]H�QLHM�� =� EDUG]LHM� LVWRWQ\FK� RSHUDWRUyZPR*QD� ZVSRPQLHü� MHGQRDUJXPHQWRZH� RSHUDWRU\� LQNUHPHQWDFML� �++�� �]ZLNV]DQLD� R� ��� Ldekrementacji "-- " (zmniejszania o 1):

int a=7;a++; // a teraz rowne 8. Dziala szybciej niz zwykle a=a+1a--; // a znowu rowne 7. Dziala szybciej niz zwykle a=a-1++a; // a znowu rowne 8. Dziala co najmniej nie wolniej niz "a++"--a; // a znowu rowne 7. Dziala co najmniej nie wolniej niz "a--"

:�SU]\SDGNX�� JG\�Z\QLN� ]DVWRVRZDQLD� RSHUDWRUD� FKFHP\� ]DSLVDü� Z� WHM� VDPHM� ]PLHQQHM�� PR*QDSRVáX*\ü� VL� QRWDFM�� VNUyFRQ�� �L� HIHNW\ZQLHMV]���� Z� NWyUHM� SR� ]QDNX� RSHUDWRUD� SLV]H� VL� ]QDNUyZQR�FL��R�WDN�a+=6; // to samo, co a=a+6a*=3; // to samo, co a=a*3a/=7; // to samo, co a=a/7a%=4; // to samo, co a=a%4

1RWDFMD�WD�PR*H�Z\GDZDü�VL�QLHF]\WHOQD�SRF]�WNXM�FHPX��DOH�]�F]DVHP�ZFKRG]L�Z�QDZ\N�*G\�VWRVXMHP\�ZLFHM�RSHUDWRUyZ��Z\UD*HQLH�REOLF]DQH�MHVW�]JRGQLH�]�LFK�SULRU\WHWDPL��QD�SU]\NáDGPQR*HQLH�Z\NRQ\ZDQH�MHVW�SU]HG�GRGDZDQLHP��-H�OL�FKFHP\�LQDF]HM��VWRVXMHP\�QDZLDV\�int a=2+2*2; // a teraz rowne 6int b=(2+2)*2; // b teraz rowne 8

Operatory logiczne (&&, || , ! ) i operator nie-równe (!= ) (odpowiednik "<>��]�QLHNWyU\FK�M]\NyZ�]RVWDQ��RPyZLRQH�Z�F]�FL�SR�ZLFRQHM�NRQVWUXNFMRP�ZDUXQNRZ\P�']LDáDQLH�RSHUDWRUyZ�SRUyZQDQLD��>", "<", ">=", "<=" jest intuicyjnie oczywiste, przynajmniej dlatypów wbudowanych.

Konstrukcje warunkowe

3RGVWDZRZ��NRQVWUXNFM��ZDUXQNRZ��MHVW�NRQVWUXNFMD�if-else ��SR]ZDODM�FD�QD�Z\NRQDQLH�Uy*Q\FKLQVWUXNFML�Z�]DOH*QR�FL�RG� VSHáQLHQLD�±�E�G(� QLH� ±� SHZQHJR�ZDUXQNX�� 6NáDGQLD� WHM� LQVWUXNFML� MHVWQDVWSXM�FD�if(warunek) instrukcja1;else instrukcja2;

:�SU]\SDGNX�VSHáQLHQLD�ZDUXQNX��Z\NRQ\ZDQD�MHVW�LQVWUXNFMD���:�SU]HFLZQ\P�UD]LH�Z\NRQ\ZDQDMHVW� LQVWUXNFMD���&]�ü� �els e�� MHVW�RSFMRQDOQD�� WM�� MH�OL� ]DOH*\� QDP� QD�Z\NRQDQLX� F]HJR��Z� UD]LHVSHáQLHQLD�ZDUXQNX�L�QLFQLHURELHQLX�Z�UD]LH�QLHVSHáQLHQLD�ZDUXQNX��Z\VWDUF]\�QDSLVDüif(warunek) instrukcja1;

&]VWR� EG]LH� ]GDU]Dü� VL� WDN�� *H� LQVWUXNFMD�� E�G(� LQVWUXNFMD��� E�G(� RE\GZLH� EG�� LQVWUXNFMDPL]áR*RQ\PL�

Page 5: :VW S G R& - mif.pg.gda.pl · • metody numeryczne, • $ojr u\wp\uyzq r ohjáh • =d vwrvrzdqlhu y * q\fk urgrzl v nn r psxwhurz\fkgrreol f ]h qxp h u\ f ]q \ fk 8zdjlu y * qh

Y����������±�������-DFHN�']LHG]LF��)7L06��3ROLWHFKQLND�*GD�VND��� [email protected]

if(warunek) { instrukcja1a; instrukcja1b; instrukcja1c;}else { instrukcja2a; instrukcja2b; instrukcja2c;}

.ODPU\� SHáQL�� WX� SRGREQ�� URO� MDN� NRQVWUXNFMD� �begin "/"end�� Z\VWSXM�FD� Z� ZLHOX� M]\NDFKSURJUDPRZDQLD�� ,QVWUXNFMH� XMWH� Z� NODPU\� XGDM�� SRMHG\QF]�� LQVWUXNFM�� &]DV� *\FLD� ]PLHQQ\FK]DGHNODURZDQ\FK�ZHZQ�WU]�NODPU�NR�F]\�VL�]�RSXV]F]HQLHP�W\FK*H�NODPU�:DUXQHN�SRZLQLHQ�E\ü�W\SX�ORJLF]QHJR��boo l ��E�G(�FDáNRZLWHJR��:�SLHUZV]\P�Z\SDGNX�ZDUXQHNX]QDMHP\�]D�VSHáQLRQ\��JG\�PD�RQ�ZDUWR�ü�true ��Z�GUXJLP�SU]\SDGNX��JG\�ZDUWR�ü�MHVW�QLH]HURZD�3U]\NáDGRZR�int a,b,c;LI�D E��F ���HOVH�F ������MH�OL�D�UyZQH�MHVW�E��WR�D E�MHVW�WUXH�L���������������������������Z\NRQXMH�VL�F ���:�SU]HFLZQ\P�UD]LH�F ��LI�F��D ���HOVH�D ���������MH�OL�F�MHVW�QLH]HURZH��WR�D�EG]LH�UyZQH��

1DOH*\�]ZUyFLü�XZDJ�QD�IDNW��*H�ZDUXQHN�GOD�LQVWUXNFML�if �PXVL�E\ü�XPLHV]F]RQ\�Z nawiasach. WEXGRZDQLX� EDUG]LHM� VNRPSOLNRZDQ\FK� ZDUXQNyZ� SU]\GDWQH� V�� RSHUDWRU\� ORJLF]QHJR�L� �&&",logicznego-lub "|| ", negacji-logicznej "! ��RUD]�RSHUDWRU�QLH�UyZQD�VL��!= ":

LI�D ���E �������������Z\NRQDM�MH�OL�D�UyZQH�MHVW���i b równe jest 4LI�D ��__�E �������������Z\NRQDM��MH�OL�D�UyZQH�MHVW���lub b równe jest 4LI���D ��__�E �����������Z\NRQDM��MH�OL�QLHSUDZG��MHVW��*H��D ��OXE�E ��LI�D� ���������������������Z\NRQDM��MH�OL�D�MHVW�Uy*QH�RG��

&���RIHUXMH�MHV]F]H�DOWHUQDW\ZQ��NRQVWUXNFM�ZDUXQNRZ���WUyMDUJXPHQWRZ\�RSHUDWRU�?: ���NWyU��QLHEG]LHP\� VL� ]DMPRZDü�� -HV]F]H� LQQ�� NRQVWUXNFM�ZDUXQNRZ�� �Z\ERUX�ZLHORNURWQHJR�� ]DSHZQLDinstrukcja switch �� SR� RSLV� NWyUHM� RGV\áDP� GR� OLWHUDWXU\� �SHáQL� SRGREQ�� URO� GR� case w innychM]\NDFK��3WOH=D� SRPRF�� SWOL� PR*HP\� Z\NRQ\ZDü� SHZQH� LQVWUXNFMH� ZLHORNURWQLH�� &��� RIHUXMH� WU]\� URG]DMHSWOL��SWO�while ��SWO�do-while �L�SWO�for ��6NáDGQLD�SLHUZV]HM�]�QLFK�MHVW�QDVWSXM�FD�while(warunek) instrukcja1;

,QVWUXNFMD�� EG]LH� Z\NRQ\ZDQD� GRSyW\�� GRSyNL� VSHáQLRQ\� EG]LH� ZDUXQHN�� -H�OL� ZDUXQHN� QLHEG]LH�VSHáQLRQ\��QD�G]LH��GREU\���SU]HG�ZHM�FLHP�GR�SWOL��� LQVWUXNFMD��nie zostanie wykonanaani razu��3U]\NáDG\�SWOL�ZKLOH�ZKLOH�D�E��D�������]ZLNV]DM�D�WDN�GáXJR��MDN�GáXJR�D�E�int p=4;while(p>0) { // ponizsze operacje wykonuja sie cztery razy (dla p=4, 3, 2 i 1). c=2*a+7-b; p--; // tu "recznie" zmniejszamy p};

Page 6: :VW S G R& - mif.pg.gda.pl · • metody numeryczne, • $ojr u\wp\uyzq r ohjáh • =d vwrvrzdqlhu y * q\fk urgrzl v nn r psxwhurz\fkgrreol f ]h qxp h u\ f ]q \ fk 8zdjlu y * qh

Y����������±�������-DFHN�']LHG]LF��)7L06��3ROLWHFKQLND�*GD�VND��� [email protected]

3RGREQ�� VNáDGQL� L� G]LDáDQLH� PD� SWOD� do-while �� ]� W�� Uy*QLF��� *H� ZDUXQHN� VSUDZG]DQ\� MHVW� poZ\NRQDQLX�LQVWUXNFML�Z�SWOL��D�nie przed�LFK�Z\NRQDQLHP��:�]ZL�]NX�]�W\P�LQVWUXNFMH�]DZDUWH�Zdo-while � EG�� Z\NRQDQH� FR� QDMPQLHM� UD]� �D� GRNáDGQLH� UD]�� NLHG\� ZDUXQHN� QLH� MHVW� VSHáQLRQ\��3U]\NáDGRZR�int p=0;do { // instrukcje tu zostana wykonane raz, mimo ze p nie jest wieksze od 0 c=2*a+b-c;`�ZKLOH�S!�������SR�SLHUZV]\P�VSUDZG]HQLX�ZDUXQNX�SWOD�MHVW�RSXV]F]DQD

-DN�ZLGDü��SRGREQLH�MDN�Z�LQVWUXNFML�if ��PR*QD�]DPLDVW�LQVWUXNFML�SURVW\FK�NRU]\VWDü�WX�]�LQVWUXNFML]áR*RQHM�^`�1DMEDUG]LHM�HODVW\F]Q��D�WDN*H�VNáDGQLRZR�QLHFR�VNRPSOLNRZDQ�� MHVW�SWOD�for ��.RU]\VWD�VL�]�QLHMQD�RJyá�Z� V\WXDFML�� NLHG\� OLF]ED� RELHJyZ� SWOL� MHVW�znana z góry�� FKRü� QLHNRQLHF]QLH�� 3WOD� for

w�M]\NX� &��� RIHUXMH� ]QDF]QLH� ZLNV]H� PR*OLZR�FL�� QL*� MHM� RGSRZLedniki w Pascalu (for ) czyFortranie (do���-HM�VNáDGQLD�MHVW�QDVWSXM�FD�for(inicjalizacja; warunek; operacja) instrukcja1;

3U]HG�ZHM�FLHP�GR�SWOL�Z\NRQ\ZDQD�MHVW�LQLFMDOL]DFMD��1DVWSQLH�LQVWUXNFMD��MHVW�Z\NRQ\ZDQD�WDNGáXJR�� MDN� VSHáQLRQ\� MHVW� ZDUXQHN�� :DUXQHN� VSUDZG]DQ\� MHVW� SU]HG� Z\NRQDQLHP� LQVWUXNFML�� 3RND*G\P�RELHJX�SWOL�Z\NRQ\ZDQD�MHVW�RSHUDFMD��3U]\NáDGRZR�for(i=1; i<=10; i++) cout << i; // wypisuje liczby od 1 do 10for(i=10; i>=1; i--) cout << i; // wypisuje liczby od 10 do 1for(i=1; i<=10;i=i+2) cout << i; // wypisuje liczby 1, 3, 5, 7, 9for(i=2; i<30; i=i*2) cout << i; // wypisuje 2, 4, 8, 16IRU�L ��L���L����FRXW����L�����QLF�QLH�Z\SLVXMH��ER�ZDUXQHN�QLH�VSHáQLRQ\

2�W\P��*H��cout << i ��Z\SLVXMH�]PLHQQ��L�QD�HNUDQ�EG]LH�ZNUyWFH�-DN�ZLGDü�QD�SU]\NáDGDFK����L�����RSHUDFMD��NWyUD�MHVW�Z\NRQ\ZDQD�SU]\�ND*G\P�RELHJX�PR*H�E\üEDUG]LHM� VNRPSOLNRZDQD� QL*� ]Z\NáH� ]ZLNV]DQLH� OXE� ]PQLHMV]DQLH� OLF]QLND�� :LHNV]R�ü� LQQ\FKM]\NyZ�WHJR�QLH�SRWUDIL�:\UD*HQLD�Z�SWOL�IRU�V��RSFMRQDOQH�L�PR*QD�MH�SRPLMDü�]�Uy*Q\P�VNXWNLHP�for(i=1;i<10;) ... // pominieto operacje, wiec 'i' nie jest automatycznie zwiekszane

for(i=1;;i++) ... // pominieto warunekfor(;;) ... // pominieto wszystko, petla nieskonczona

5yZQLH*�L�Z�SWOL�IRU�F]VWR�NRU]\VWD�VL�]�LQVWUXNFML�]áR*RQHM�^`�Z�PLHMVFH�LQVWUXNFML�SURVWHM��&]�üLQLFMDOL]DF\MQD� SWOL� IRU� PR*H� Z\M�WNRZR� ]DZLHUDü� UyZQLH*� GHNODUDFM� ]PLHQQHM� ±� ZyZF]DV]PLHQQD�WD�SU]HVWDMH�E\ü�ZLG]LDQD�SR�RSXV]F]HQLX�SWOL��Z�SRSU]HGQLP�VWDQGDUG]LH�M]\ND�&���QLHE\áR�WDN����3U]\NáDGRZR�for(int i=5;i<10;i++) { cout << i; // wypisuje 5, 6, 7, 8, 9}FRXW����L�����QLHSUDZLGáRZH��]PLHQQD�L�QLH�LVWQLHMH�SR]D�SHWO�

1LHNWyUH� �VWDUH�� NRPSLODWRU\� GRSXV]F]DM�� WDNLH� QLHSRSUDZQH� RGZRá\ZDQLH� VL� SR]D� SWO�� GR]PLHQQHM�]DGHNODURZDQHM�ZHZQ�WU]�SWOL�±�QLH�QDOH*\�QD�W\P�SROHJDü�

Page 7: :VW S G R& - mif.pg.gda.pl · • metody numeryczne, • $ojr u\wp\uyzq r ohjáh • =d vwrvrzdqlhu y * q\fk urgrzl v nn r psxwhurz\fkgrreol f ]h qxp h u\ f ]q \ fk 8zdjlu y * qh

Y����������±�������-DFHN�']LHG]LF��)7L06��3ROLWHFKQLND�*GD�VND��� [email protected]

:�RGUy*QLHQLX�RG�QLHNWyU\FK� LQQ\FK� M]\NyZ��QS��3DVFDO��&���]H]ZDOD�QD�GRZROQH�PDQLSXODFMH]PLHQQ�� NRQWUROQ�� Z� SWOL� for �� 2]QDF]D� WR�� *H� PR*HP\� M�� UF]QLH� ]ZLNV]Dü�� ]PQLHMV]Dü� F]\]PLHQLDü�MHM�ZDUWR�ü�ZHZQ�WU]�SWOL�Funkcje

)XQNFMH�Z� M]\NX� &��� SHáQL�� URO� WDN�� VDP��� MDN� IXQNFMH� L� SURFHGXU\�Z� 3DVFDOX� L� SRGREQ�� MDNSRGSURJUDP\� Z� )RUWUDQLH�� )XQNFMD� SU]\MPXMH� RNUH�ORQ�� OLF]E� DUJXPHQWyZ�� RNUH�ORQ\FK� W\SyZi�]ZUDFD� ZDUWR�ü�� UyZQLH*� RNUH�ORQHJR� W\SX�� 3U]\NáDGDPL� IXQNFML� �GHNODUDFML� IXQNFML�� V�� QDSU]\NáDG�double pierwiastek(double a);int wieksza_z_liczb(int a, int b);double podnies_do_potegi_calkowitej(double podstawa, int wykladnik);

Pierwsza z tych funkcji przyjmuje jeden argument typu double i zwraca wynik typu double .0R*QD� VSRG]LHZDü� VL��*H� VáX*\�GR�REOLF]DQLD�SLHUZLDVWND� ]� OLF]E\� U]HF]\ZLVWHM��'UXJD� ] funkcjiSU]\MPXMH� GZD� DUJXPHQW\� W\SX� FDáNRZLWHJR� L� ]ZUDFD� Z\QLN� UyZQLH*� W\SX� FDáNRZLWHJR�� 0R*QDVSRG]LHZDü� VL�� *H� WD� IXQNFMD� ]ZUDFD�ZLNV]�� ]� GZyFK� OLF]E�� 7U]HFLD� ] funkcji przyjmuje jedenargument typu double , jeden typu int i zwraca wynik typu double �� :VSRPQLDQH� Z\*HMNRQVWUXNFMH�E\á\�deklaracjami IXQNFML�� F]\OL� LQIRUPDFMDPL�GOD�NRPSLODWRUD��*H� LVWQLHM�� IXQNFMH�RWDNLFK� QD]ZDFK�� RGSRZLHGQLFK� DUJXPHQWDFK� L� RGSRZLHGQLP� W\SLH� Z\QLNX�� *G\� FKFHP\� SRGDüGHILQLFM�IXQNFML��SRND]Dü�SU]HSLV�QD�MHM�Z\NRQDQLH���PXVLP\�GRVWDUF]\ü�FLDáR funkcji (instrukcje,NWyUH� VNáDGDM�� VL� QD�QL���� NWyUH�XPLHV]F]DP\�PLG]\� QDZLDVDPL� NODPURZ\PL� ^`��'OD� SU]\NáDGXdefinicja�IXQNFML�ZLHNV]DB]BOLF]E���PR*H�Z\JO�GDü�QDVWSXM�FR�int wieksza_z_liczb(int a, int b) { if(a>b) return a; else return b; // zakladamy, ze jesli a==b, to wynikiem jest b}

:\QLN�]ZUDFDP\�]D�SRPRF��LQVWUXNFML�return ��SR�NWyUHM�SRGDMHP\�ZDUWR�ü��NWyU��FKFHP\�]ZUyFLü�Wykonanie ret ur n�RSXV]F]D�IXQNFM�)XQNFMD�PR*H�QLH�PLHü�DUJXPHQWyZ�int aktualna_godzina(); // funkcja bez argumentów

)XQNFMD� PR*H� QLH� ]ZUDFDü� *DGQHM� ZDUWR�FL�� ]D]QDF]DP\� WR� SLV]�F�� *H� IXQNFMD� ]ZUDFD� W\S� void

(pusty):

void czekaj(int jak_dlugo);

Taka funkcja jest analogiem pascalowskiej procedury – pozwala ona na wykonanie operacji , któreQLH�]ZUDFDM��*DGQHJR�Z\QLNX�Poza zadeklarowaniem i zdefiniowaniem� IXQNFML� PR*HP\� MHV]F]H� IXQNFMH�Z\ZRá\ZDü (po tow�NR�FX�V����6NáDGQLD�Z\ZRáDQLD�MHVt intuicyjnie oczywista:

int p,q,r;p=3; q=7;r=wieksza_z_liczb(p,q); // wywolanie funkcji z argumentami p i q

Page 8: :VW S G R& - mif.pg.gda.pl · • metody numeryczne, • $ojr u\wp\uyzq r ohjáh • =d vwrvrzdqlhu y * q\fk urgrzl v nn r psxwhurz\fkgrreol f ]h qxp h u\ f ]q \ fk 8zdjlu y * qh

Y����������±�������-DFHN�']LHG]LF��)7L06��3ROLWHFKQLND�*GD�VND��� [email protected]

:DUWR�]DXZD*\ü��*H�IXQNFMD�NRU]\VWD�z kopii �VZRLFK�SDUDPHWUyZ��QLH]DOH*QLH�RG�WHJR��MDN�]RVWDQ�RQH�QD]ZDQH��QS��Z�SRQL*V]\P�SU]\NáDG]LH�void zeruj(double x) { x=0; cout << x; // wypisze 0}

int x=4;zeruj(x);cout << x; // wypisze 4

:DUWR�ü� [� QD�NWyUHM�RSHUXMH� IXQNFMD� MHVW� NRSL��ZDUWR�FL� [� ]DGHNODURZDQHM�SRQL*HM� �L� UyZQHM����3UyE\� ]PLDQ\� [� ZHZQ�WU]� IXQNFML� VNXWNXM�� ]PLDQDPL� NRSLL�� RU\JLQDá� SR]RVWDMH� QLHWNQLW\�=DFKRZDQLH� WDNLH�PR*H� ]�SRF]�WNX�G]LZLü�� JG\E\� MHGQDN�E\áR� LQDF]HM� FR�PLDáDE\� ]URELü� IXQNFMD]HUXM�Z\ZRáDQD�MDN�SRQL*HM��]�DUJXPHQWHP��NWyU\�QLH�MHVW�]PLHQQ��D�ZDUWR�FL��]HUXM��������MDN�SU]\SLVDü�� �"

0R*HP\� ]PLHQLü� SRZ\*V]�� NRQZHQFM� SU]HND]XM�F� SDUDPHWU\� SU]H]� UHIHUHQFM� �RGV\áDP� GROLWHUDWXU\�� ±� ZyZF]DV� IXQNFMD� RSHUXMH� EH]SR�UHGQLR� QD� RU\JLQDáDFK� VZRLFK� SDUDPHWUyZ�� QLH� QDkopiach.

Uwaga��1LH�PR*QD�IXQNFML�Z\ZRáDü�SU]HG�MHM�GHILQLFM���FK\ED�*H�]RVWDáD�XSU]HGQLR�]DGHNODURZDQD�1D�SU]\NáDG�// -----------------------------------------double pierwiastek(double a) { return sqrt(a);}

double pierwiastek_z_pi() { const double pi=3.14159;��UHWXUQ�SLHUZLDVWHN�SL�������Z�SRU]�GNX��)XQNFMD�SLHUZLDVWHN��������������������������������E\OD�]GHILQLRZDQD�ZF]H�QLHM�}

7HUD]�LQQ\�SU]\NáDG�// -----------------------------------------double pierwiastek_z_pi() { const double pi=3.14159; return pierwiastek(pi); // Niedobrze . Kompilator nie wie (jeszcze) // czym jest pierwiastek().}

double pierwiastek(double a) { return sqrt(a);}

3RZ\*V]\�IUDJPHQW�SURJUDPX�PR*QD�SRSUDZLü�QD�GZD�VSRVRE\��DOER�SU]HQRV]�F�GHILQLFM� IXQNFMLSLHUZLDVWHN���SU]HG�GHILQLFM�IXQNFML�SLHUZLDVWHNB]BSL����DOER�GDM�F�GHNODUDFM�IXQNFML�SLHUZLDVWHN��SU]HG�IXQNFM��SLHUZLDVWHNB]BSL����WDN�MDN�WX�// -----------------------------------------double pierwiastek(double a); // deklaracja

double pierwiastek_z_pi() { const double pi=3.14159;

Page 9: :VW S G R& - mif.pg.gda.pl · • metody numeryczne, • $ojr u\wp\uyzq r ohjáh • =d vwrvrzdqlhu y * q\fk urgrzl v nn r psxwhurz\fkgrreol f ]h qxp h u\ f ]q \ fk 8zdjlu y * qh

Y����������±�������-DFHN�']LHG]LF��)7L06��3ROLWHFKQLND�*GD�VND��� [email protected]

return pierwiastek(pi); // W porzadku. Dzieki deklaracji kompilator wie // czym jest pierwiastek().}

double pierwiastek(double a) { return sqrt(a);}

Specjalne znaczenie ma w programach C++ funkcja o nazwie main ��NWyUD�]ZUDFD�ZDUWR�ü�W\SX�int .)XQNFMD� WD� MHVW� JáyZQ�� IXQNFM�� SURJUDPX� L� MHVW� Z\ZRá\ZDQD� DXWRPDW\F]QLH� SU]\� XUXFKRPLHQLXSURJUDPX��&LDáHP�WHM� IXQNFML� MHVW� QDV]� �SURJUDP�JáyZQ\���'OD�SU]\NáDGX� EDUG]R�SURVW\� �DOH� QDV]SLHUZV]\�NRPSOHWQ\��SURJUDP�Z�&���PR*H�Z\JO�GDü�WDN�int main() { int a=3; a=2*a-7; return 0;}

3RZ\*V]\�SURJUDP�REOLF]D�ZDUWR�ü�� �����SR�F]\P���� LJQRUXMH�Z\QLN�:)��D�QDVWSQLH�NR�F]\�SUDF�RSXV]F]DM�F�IXQNFM�PDLQ���]D�SRPRF��LQVWUXNFML�return ��:DUWR�ü�]ZUyFRQD�SU]H]�IXQNFM�main()

]ZUDFDQD�MHVW�GR�V\VWHPX�RSHUDF\MQHJR�L�JHQHUDOQLH�QLH�EG]LH�QDV�REFKRG]LáD��2ERZL�]XMH�XPRZD�*H� ]ZUyFHQLH� Z� IXQNFML� main � ZDUWR�FL� �� R]QDF]D� SRP\�OQ\� SU]HELHJ� SURJUDPX�� D� ND*GHM� LQQHMZ\VW�SLHQLH� EáGX3�� DOH� QLH� PXVLP\� VL� WHM� XPRZ\� WU]\PDü�� )XQNFMD�main() � MHVW� MHG\Q�� IXQNFM�]ZUDFDM�F��Z\QLN��Z�NWyUHM�PR*HP\�SR]ZROLü�VRELH�QD�HNVWUDZDJDQFM� L�Z\QLNX�WHJR�QLH�]ZUyFLü�QS�� SRPLQ�ü� LQVWUXNFM� return � Z� SRZ\*V]\P� SU]\NáDG]LH��� -H�OL� WHJR� QLH� ]URELP\�� NRPSLODWRU]ZUyFL�]D�QDV�ZDUWR�ü����Uwaga�� WDND� HNVWUDZDJDQFMD�Z�SU]\SDGNX� LQQ\FK� IXQNFML� ]ZUDFDM�F\FKZ\QLN�PR*H�VNR�F]\ü�VL�*DáR�QLH�int brzydka_funkcja() { // cos tu robimy, ale zapomnielismy o return}

int a;D EU]\GNDBIXQNFMD�������D�PD�WHUD]�ZDUWR�ü�QLHRNUH�ORQ�

Dawno temu funkcja main() �PRJáD�E\ü�IXQNFM���NWyUD�QLH�]ZUDFDáD�Z\QLNX��WM��PR*QD�E\áR�SLVDü�void main() { // <- bleeeee! // moj program}

2EHFQLH�MHVW�WR�QLHGRSXV]F]DOQH��MHVW�SU]HMDZHP�]áHJR�VW\OX�L�MHVW�QLHSRSUDZQH�]�IRUPDOQHJR�SXQNWXZLG]HQLD�� 1RZRF]HVQH� NRPSLODWRU\� RVWU]HJ�� QDV� SU]\� SUyELH� WDNLHJR� XEOL*DQLD� M]\NRZL� :) alboZUF]�X]QDM��WDNL�SURJUDP�]D�QLHSRSUDZQ\��PDM�F�UDFM��Funkcja main() �PR*H�SRELHUDü���FL�OH�RNUH�ORQH��DUJXPHQW\��NWyUH�GRVWDUF]D�V\VWHP�RSHUDF\MQ\�QDSRGVWDZLH�SDUDPHWUyZ��NWyUH�SU]HND]DOL�P\�QDV]HPX�SURJUDPRZL�Z\ZRáXM�F�JR��:UyFLP\�GR�WHJRQLHGáXJR�

3� )DQDW\F\� VWDQGDUGX�PRJ�� VL� ]� W\P� QLH� ]JRG]Lü�� WZLHUG]�F� *H� SRUD*N� WU]HED� ]DV\JQDOL]RZDü� ]ZUDFDM�F� ZDUWR�üEXIT_FAILURE.

Page 10: :VW S G R& - mif.pg.gda.pl · • metody numeryczne, • $ojr u\wp\uyzq r ohjáh • =d vwrvrzdqlhu y * q\fk urgrzl v nn r psxwhurz\fkgrreol f ]h qxp h u\ f ]q \ fk 8zdjlu y * qh

Y����������±�������-DFHN�']LHG]LF��)7L06��3ROLWHFKQLND�*GD�VND��� [email protected]

Strumienie

:VWSQH� FKRüE\� RPyZLHQLH� NRQFHSFML� VWUXPLHQL� Z\NUDF]D� SR]D� UDP\� WHJR� GRNXPHQWX�� WDN� *HSRZLHP\�VRELH�W\ONR�NLOND�VáyZ�L�WR�Z�ZLHONLP�XSURV]F]HQLX��6WUXPLH��WR�WDNLH�]ZLHU]��GR�NWyUHJRPR*QD�Z\VáDü�GDQH��VWUXPLH��Z\M�FLRZ\��E�G(�SREUDü�]�QLHJR�GDQH��VWUXPLH��ZHM�FLRZ\���&R�VLG]LHMH� ]� GDQ\PL� Z\VáDQ\PL� GR� VWUXPLHQLD� DOER� VN�G� SRFKRG]�� GDQH� SREUDQH� ]H� VWUXPLHQLD"� 7R]DOH*\� ]� F]\P� WHQ� VWUXPLH�� MHVW� VWRZDU]\V]RQ\�� 1DV� QDMEDUG]LHM� EG�� LQWHUHVRZDü� GZDpredefiniowane��F]\OL�WDNLH��NWyUH�NWR��]URELá�]D�QDV��VWUXPLHQLH�cout �±�Z\M�FLRZ\��GRP\�OQLH�VWRZDU]\V]RQ\�]�NRQVRO���PRQLWRU�cin �±�ZHM�FLRZ\��GRP\�OQLH�VWRZDU]\V]RQ\�]�NRQVRO���NODZLDWXUD�:\V\áDQLH� GDQ\FK� GR� VWUXPLHQLD� cout � SRZRGXMH� SRMDZLDQLH� VL� LFK� QD� PRQLWRU]H�� 3RELHUDQLHdanych ze strumienia cin powoduje, ze program oczekuje na wprowadzenie danych z klawiatury.2SHUDWRUHP�Z\VáDQLD�F]HJR��GR�VWUXPLHQLD�MHVW��<<", a operatorem pobrania ze strumienia jest ">>"..LOND�SU]\NáDGyZ�cout << "Ala ma kota"; // wypisuje tekst na ekranFRXW�����2WR�VLyGHPND�������������Z\SLVXMH�QD�HNUDQ�WHNVW�L�OLF]EFRXW�����=PLHQQD�D�PD�ZDUWR�ü�����D����Z\SLVXMH�QD�HNUDQ�WHNVW��OLF]E����������D�]PLHQQD�E������E�����������L�MHV]F]H�MHGHQ�WHNVW�L�OLF]Ecout << "Oto pierwiastek z pi" << sqrt(pi);

int a;double b;float c;FLQ�!!�D�����ZSURZDG]D�OLF]E�FDáNRZLW��D�]�NODZLDWXU\FLQ�!!�E�����ZSURZDG]D�OLF]E�]PLHQQRSU]HFLQNRZ��]�NODZLDWXU\cin >> a >> b >> c; // wprowadza kolejne liczby z klawiatury

,VWRWQ��]DOHW��VWUXPLHQL�MHVW�WR��*H�MH�OL�QLH�FKFHP\��QLH�PXVLP\�GEDü�DQL�R�IRUPDW�Z\SURZDG]DQ\FKGDQ\FK�� DQL� R� LFK� W\S� ±�PDUWZL� VL� R� WR� ]D� QDV� M]\N�&����'OD� SRUyZQDQLD�� MH�OL� NRU]\VWDP\� ]HVNáDGQL�W\SRZHM�GOD�&�printf("Oto liczba %d",liczba);

L� ]GHF\GXMHP\� VL� ]PLHQLü� W\S� ]PLHQQHM� OLF]ED� ]� FDáNRZLWHM� QD� ]PLHQQRSU]HFLQNRZ��� ]PLDQD� WDSRFL�JQLH�]D�VRE��UyZQLH*�]PLDQ� IRUPDWX��%d" na "%f���:�&���QLH�PXVLP\�PDUWZLü�VL�R�WDNLHV]F]HJyá\��MH�OL� QLH�FKFHP\���&HQ��� NWyU�� ]D� WR�SáDFLP\� MHVW� QLHQDMOHSV]D�Z\GDMQR�ü�PHFKDQL]PXVWUXPLHQL�� 6�� MHGQDN� V\WXDFMH��Z� NWyU\FK� EDUG]R� ]DOH*\� QDP� QD� W\P�� *HE\�Z\SLV\ZDQH�ZDUWR�FLE\á\�RGSRZLHGQLR�VIRUPDWRZDQH��V]F]HJyOQLH�QD� ODERUDWRULXP�]�0HWRG�1XPHU\F]Q\FK���0R*HP\QD� SU]\NáDG� *\F]\ü� VRELH�� *HE\�ZV]\VWNLH� OLF]E\� E\á\� Z\SLV\ZDQH� ]� GRNáDGQR�FL�� GR� �� F\IU� SRSU]HFLQNX��*HE\�SU]HG�ZDUWR�FLDPL�GRGDWQLPL�SRMDZLDá�VL�]QDN������PLPR�WHJR�*H� MHVW�QLHLVWRWQ\�*HE\� OLF]E\� E\á\� Z\UyZQ\ZDQH� Z� SUDZR� F]\� Z� OHZR�� HWF��� HWF�� 0HFKDQL]P� VWUXPLHQL� SR]ZDODUyZQLH*� QD� WR� �QLHGáXJR� VRELH� R� W\P� SRZLHP\��� MHGQDN� JG\� QDP� QLH� ]DOH*\� QD� IRUPDWRZDQLX�PR*HP\� NRU]\VWDü� ]� EDUG]R� SURVWHM� VNáDGQL�� MDN� SRZ\*HM�� 7DNLH� SRVWDZLHQLH� VSUDZ\� VWDZLD� &��w�OHSV]HM� V\WXDFML� QL*� M]\NL�Z�NWyU\FK� DOER�SU]\ZL�]XMH� VL�PDQLDNDOQ�� XZDJ� GR� IRUPDWRZDQLD(Fortran), albo nie ma w zasadzie kontroli nad formatowaniem (Pascal), albo formatowanie jestGR�ü�QLHZ\JRGQH��&���1LHVWHW\�VWUXPLHQLH�V��QLHQDMV]\EV]H�*G\E\�VWUXPLHQLH�VáX*\á\�W\ONR�GR�SLVDQLD�QD�HNUDQ�L�F]\WDQLD�]�NODZLDWXU\��QLH�E\á\E\�V]F]HJyOQLHX*\WHF]QH��-HGQ��]�FHFK�SU]HV�G]DM�F\FK�R�LFK��SRWG]H��MHVW�WR��*H�PR*QD�MH�VWRZDU]\V]\ü�]�F]\P�]XSHáQLH�LQQ\P��QD�SU]\NáDG�]�SOLNLHP��]�áD�FXFKHP�]QDNyZ�F]\�REV]DUHP�SDPLFL��1D�SU]\NáDG�

Page 11: :VW S G R& - mif.pg.gda.pl · • metody numeryczne, • $ojr u\wp\uyzq r ohjáh • =d vwrvrzdqlhu y * q\fk urgrzl v nn r psxwhurz\fkgrreol f ]h qxp h u\ f ]q \ fk 8zdjlu y * qh

Y����������±�������-DFHN�']LHG]LF��)7L06��3ROLWHFKQLND�*GD�VND��� [email protected]

ofstream plik; // deklaruje 'plik' jako strumien wyjsciowyplik.open("mojplik.txt"); // otwiera goplik << "Wlasnie pisze do pliku ile wynosi pi: " << 3.14159;plik.close(); // zamyka

0QLHMV]D�Z�WHM�FKZLOL�R�V]F]HJyá\�LPSOHPHQWDF\MQH�±�R�W\P�MDN�RWZLHUD�L�]DP\ND�VL�SOLNL� MHV]F]HEG]LHP\�PyZLü�±�LVWRWQH�MHVW�WR��*H�WHQ�VDP�PHFKDQL]P��FR�QD�HNUDQ��SR]ZDOD�QD�SLVDQLH�GR�SOLNX�3RGREQLH�EG]LH�]�F]\WDQLHP��']LNL� �PDJLF]Q\P��ZáDVQR�FLRP�VWUXPLHQL� �G]LNL� WHPX��*H�GEDM�RQH�R�NRQZHUVM�W\SyZ��PR*QD�]�QLFK�NRU]\VWDü�QD�SU]\NáDG�GR�]DPLDQ\�WHNVWX�QD�OLF]E��OLF]E\�QDtekst, etc., ale o tym kiedy indziej.

Istotna uwaga�� $E\� PyF� VNRU]\VWDü� ]� PHFKDQL]PX� VWUXPLHQL�� WU]HED� SRLQIRUPRZDü� R� W\PNRPSLODWRU�� Zá�F]DM�F� RGSRZLHGQL� SOLN�� -DN� WR� G]LDáD� MHVW� Z� WHM� FKZLOL� QLHLVWRWQH�� RGSRZLHGQLH�]DNOFLH��PD�SRVWDü#include <iostream>

L� SRZLQQR� SRMDZLü� QD� VDP\P� SRF]�WNX� SURJUDPX�� 3URV]� ]DXZD*\ü�� *H� QLH� NR�F]\� VL� RQR�UHGQLNLHP��ER�]�IRUPDOQHJR�SXQNWX�ZLG]HQLD�QLH�MHVW�LQVWUXNFM���DOH�WR�QLHZD*QH��8ZDJD�GOD�W\FK��NWyU]\�NLHG\��SLVDOL�MX*�WURFK�Z��VWDU\P��&����LQFOXGH��LRVWUHDP�K!�����WDN�GDZQLHM��MX*�WDN�QLH�URELP\#include <iostream> // tak teraz

'RGDQLH���K��VSRZRGXMH�Zá�F]HQLH�VWDUHM�ZHUVML�SOLNyZ�QDJáyZNRZ\FK��FR�MHVW�QLHSR*�GDQH�Uwaga: w nowoczesnych kompilatorach4��QRZV]\FK�QL*�WHQ�QD�ODERUDWRULXP�Z�V��������VWUXPLHQLHV��GRGDWNRZR��VFKRZDQH��Z�przestrzeni nazw std �L�DE\�VL�GR�QLFK�GRVWDü�QDOH*\�SR�ZVSRPQLDQ\PMX*�]DNOFLX�GRGDü�MHV]F]H�IRUPXá�using namespace std;

Na tym etapie nieistotne jest dla nas co to robi, jak to robi i po co to robi. :)��Z�LJQRUDQFML�VLáD�±�QDrazie!

Tablice

3U]HGH�ZV]\VWNLP�ZDUWR�]DXZD*\ü��*H� WDEOLFH�V��PHFKDQL]PHP�QLHFR�SU]HVWDU]Dá\P�±� M]\N�&��RG]LHG]LF]\á� MH� Z� VSDGNX� SR� &�� 1RZV]��� EDUG]LHM� F\ZLOL]RZDQ�� IRUP�� V�� ZHNWRU\�� R� NWyU\FKSRNUyWFH�Z�QDVWSQ\P�UR]G]LDOH��'ZLH�JáyZQH�FHFK\��NWyUH�RGUy*QLDM��ZHNWRU\�RG�WDEOLF� �in plusGOD�ZHNWRUD��WR�PR*OLZR�ü�NRQWUROL�]DNUHVX��Z\áDS\ZDQLD�SU]\SDGNyZ�Z\M�FLD�SR]D�WDEOLF��RUD]HODVW\F]Q\�UR]PLDU��WDEOLFH�PDM��UR]PLDU�XVWDORQ\��-H�OL�PDV]�PDáR�F]DVX��QLH�F]\WDM�R�WDEOLFDFK�D�F]\WDM�R�ZHNWRUDFK�7DEOLFH�GHNODUXMH�VL�Z�&���SRGDM�F�LFK�UR]PLDU�Z�QDZLDVDFK�NZDGUDWRZ\FK�SR�QD]ZLH�]PLHQQHM�QLH�SR�QD]ZLH�W\SX����QD�SU]\NáDG�LQW�OLF]E\>���@������������VWXHOHPHQWRZD�WDEOLFD�OLF]E�FDáNRZLW\FK 4�-H�OL�PRZD�R�NRPSLODWRU]H�J����WR�SU]H]��VWDUH��UR]XPLHP\�VWDUV]H�RG������D�SU]H]��QRZH������L�QRZV]H��:HUVMNRPSLODWRUD�PR*HP\�VSUDZG]Lü�SLV]�F��g++ --version ".

Page 12: :VW S G R& - mif.pg.gda.pl · • metody numeryczne, • $ojr u\wp\uyzq r ohjáh • =d vwrvrzdqlhu y * q\fk urgrzl v nn r psxwhurz\fkgrreol f ]h qxp h u\ f ]q \ fk 8zdjlu y * qh

Y����������±�������-DFHN�']LHG]LF��)7L06��3ROLWHFKQLND�*GD�VND��� [email protected]

double macierz[15][15]; // macierz 15x15 liczb rzeczywistychchar lancuch[256]; // 256-elementowa tablica znaków

7DEOLFH� ZLHORZ\PLDURZH� GHNODUXMH� VL� SRZWDU]DM�F� QDZLDV� NZDGUDWRZ\� ZLHORNURWQLH� �WDN� MDN� ZSU]\NáDG]LH�����QLHGRSXV]F]DOQH� MHVW�SLVDQLH�QD�SU]\NáDG��SRGREQLH� MDN�Z�3DVFDOX��macierz[x,y]

zamiast macierz[x][y] – przecinek ma w C++ znaczenie specjalne.

'RVWS�GR�HOHPHQWyZ�WDEOLF\�X]\VNXMHP\�]D�SRPRF��RSHUDWRUD�LQGHNVRZDQLD��[] ���SRGDM�F�QXPHUHOHPHQWX�ZHZQ�WU]�QDZLDVyZ�NZDGUDWRZ\FK��'OD�SU]\NáDGX�p=liczby[5]; // przypisz do 'p' element tablicy o indeksie 5macierz[3][3]=4.0; // ustaw jeden z elementow macierzylancuch[i]='k'; // ustaw i-ty znak lancucha na 'k'

Uwaga:�:�&���HOHPHQW\�WDEOLF\�LQGHNVRZDQH�V��RG����QLH�RG���MDN�QD�SU]\NáDG�Z�)RUWUDQLH��,�WDNtablica[0] reprezentuje pierwszy element, tablica[1] drugi, itd. Wobec tego tablica, która man elementów zawiera elementy o indeksach 0..n-1, NIE 1..n��3UyED�VNRU]\VWDQLD�]�QLHLVWQLHM�FHJRHOHPHQWX� WDEOLF\� �R� LQGHNVLH� VSR]D� ]DNUHVX�� QD� RJyá� NR�F]\� VL� *DáR�QLH� L� EG]LH� SU]\F]\Q�WUXGQ\FK�GR�Z\�OHG]HQLD� EáGyZ��7DEOLFH� QLH� ]DSHZQLDM�� *DGQHJR�PHFKDQL]PX� NRQWUROL� ]DNUHVX�GODWHJR�QDOH*\�VL�SLOQRZDü�7DEOLFH� ]DGHNODURZDQH� ZH� ZVSRPQLDQ\� VSRVyE� PXV]�� PLHü� UR]PLDU� ]QDQ\� ]� JyU\� �WM�� SRGF]DVkompilacji programu). Niedopuszczalne jest zatem deklarowanie tablic, rozmiar których jest]PLHQQ���'OD�SU]\NáDGX�SRQL*V]D�SUyED�VWZRU]HQLD� WDEOLF\�R�UR]PLDU]H�]DGDQ\P�]�NODZLDWXU\�QLHSRZLHG]LH�VL�int rozmiar;cin >> rozmiar; // 'rozmiar' nie jest znany podczas kompilacjiint tablica[rozmiar]; // wiec nie da rady

1LHNWyUH� NRPSLODWRU\� SR]ZDODM�� QD� FR�� WDNLHJR�� WU]HED� MHGQDN� SDPLWDü� *H� MHVW� WR� UR]V]HU]HQLHM]\ND�RIHURZDQH�SU]H]�NRPSLODWRU��QLH�F]�ü�M]\ND�&���7DEOLFH� R� QLH]QDQ\FK� ]� JyU\� UR]PLDUDFK�PR*QD� WZRU]\ü� G\QDPLF]QLH� ]D� SRPRF�� RSHUDWRUD� new.7DEOLFDPL�WDNLPL�UDF]HM�QLH�EG]LHP\�VL�]DMPRZDOL�Wektory

=DQLP�VNRU]\VWDV]�]�ZHNWRUyZ��PXVLV]�Zá�F]\ü�SOLN�QDJáyZNRZ\��YHFWRU��#include <vector>

2� ZHNWRUDFK� QDOH*\� P\�OHü� MDN� R� WDEOLFDFK� MHGQRZ\PLDURZ\FK�� SRPLPR� VZRMHM� QLHFR� P\O�FHMQD]Z\�QLH�PDM��RQH�*DGQ\FK�NRQRWDFML�IL]\F]Q\FK�F]\�PDWHPDW\F]Q\FK��.UyWNR�PyZL�F�±�ZHNWRUto n�HOHPHQWRZ\�FL�J��(OHPHQW\�ZHNWRUD�PRJ��E\ü�GRZROQHJR�W\SX5�±�PR*HP\�PLHü�ZHNWRU�OLF]EU]HF]\ZLVW\FK�� ZHNWRU� OLF]E� FDáNRZLW\FK�� ZHNWRU� QD]ZLVN�� HWF��:HNWRU� GHNODUXMHP\� SRGDM�F� W\SHOHPHQWyZ� SU]HFKRZ\ZDQ\FK� Z� ZHNWRU]H�� QD]Z� ZHNWRUD� RUD]� RSFMRQDOQLH� OLF]E� HOHPHQWyZZHNWRUD��XPLHV]F]RQ��Z�QDZLDVDFK�RNU�Já\FK��LQDF]HM�QL*�Z�SU]\SDGNX�WDEOLF\��vector<int> wek1(100); // wektor 100 elementów intvector<double> wek2(1000); // wektor 1000 elementów doublevector<bool> wek3; // pusty (inicjalnie) wektor elementów bool

5�1R�� SUDZLH� GRZROQHJR�� 3HZQH� W\S\� GHILQLRZDQH� SU]H]� X*\WNRZQLND�PRJ�� QLH� VSHáQLDü� Z\PDJD�� QDNáDGDQ\FK� QDHOHPHQW\�ZHNWRUD��NWyUH�PXV]��E\ü�QS��NRSLRZDOQH��1D�UD]LH�RJUDQLF]HQLH�WR�MHVW�GOD�QDV�QLHLVWRWQH�

Page 13: :VW S G R& - mif.pg.gda.pl · • metody numeryczne, • $ojr u\wp\uyzq r ohjáh • =d vwrvrzdqlhu y * q\fk urgrzl v nn r psxwhurz\fkgrreol f ]h qxp h u\ f ]q \ fk 8zdjlu y * qh

Y����������±�������-DFHN�']LHG]LF��)7L06��3ROLWHFKQLND�*GD�VND��� [email protected]

:V]\VWNLH�HOHPHQW\�ZHNWRUD�V��GRP\�OQLH�]HURZDQH��F]HJR�QLH�PR*QD�SRZLHG]LHü�R�WDEOLFDFK�:�ND*GHM� FKZLOL� PR*HP\� VSUDZG]Lü� UR]PLDU� ZHNWRUD� �OLF]E� HOHPHQWyZ� SU]HFKRZ\ZDQ�� Z� QLPw�GDQ\P�PRPHQFLH��±�DE\�WR�]URELü�Z\ZRáXMHP\�QD�U]HF]�ZHNWRUD�PHWRG�size() :

cout << wek1.size(); // wypisze 100int rozm = wek3.size(); // rozm jest teraz rowny 0

'RVWS� GR� HOHPHQWyZ�ZHNWRUD� MHVW� UHDOL]RZDQ\� WDN� VDPR� MDN� GOD� WDEOLF\� ±� ]D� SRPRF�� RSHUDWRUDindeksowania [] ��JG]LH�ZHZQ�WU]�QDZLDVyZ�SRGDMHP\�QXPHU�HOHPHQWX�p=wek1[5]; // przypisz do 'p' element wektora o indeksie 5wek2[i]=7; // ustaw i-ty element wektora na 7

*G\�NRU]\VWDP\� ]� WDNLHM� QRWDFML�PXVLP\�GEDü�R� WR�� DE\� QLH� SU]HNURF]\ü� ]DNUHVX�ZHNWRUD�� WM�� QLHSUyERZDü�GRVWSX�GR�QLHLVWQLHM�F\FK�HOHPHQWyZ��QS��SUyED�Z\ZRáDQLDwek2[2314]=7; // ale on ma tylko 1000 elementów!

VNR�F]\�VL�*DáR�QLH6��$E\�XQLNQ�ü�SRGREQ\FK�NáRSRWyZ��ZHNWRU�XPR*OLZLD�GRVWS�NRQWURORZDQ\]D�SRPRF��PHWRG\�at() ��]�NWyUHM�PR*QD�NRU]\VWDü�MDN�SRQL*HM�S ZHN��DW�����������SU]\SLV]�GR�S�HOHPHQW�ZHNWRUD�R�LQGHNVLH����]�NRQWURO�ZHN��DW�L� ���������XVWDZ�L�W\�HOHPHQW�ZHNWRUD�QD����]�NRQWURO�

W przypadku przekroczenia zakresu przy korzystaniu z metody at() � PDP\� JZDUDQFMQDW\FKPLDVWRZHJR�]DNR�F]HQLD�SURJUDPX7��FR�áDWZR�SR]ZDOD�Z\�OHG]Lü�EáG\��&HQ���NWyU��SáDFLP\]D�WHQ�NRPIRUW�MHVW�SRJRUV]HQLH�Z\GDMQR�FL��SU]\�ND*G\P�GRVWSLH�GR�ZHNWRUD�SURJUDP�NRQWUROXMHzakres). Dobrym nawykiem jest stosowanie at() � ]DZV]H�� GRSyNL� QLH� RND*H� VL�� *H� SRJRUV]HQLHZ\GDMQR�FL� MHVW� ]DXZD*DOQH�� 'RSyNL� QLH� Z\NRQXMHP\� PLOLRQyZ� RSHUDFML� QD� ZHNWRUDFK� PR*QD]DNáDGDü��*H�QLH�]DXZD*\P\�Uy*QLF\�Uwaga:� 3RGREQLH� MDN� WDEOLFH�� ZHNWRU\� Z� &��� LQGHNVRZDQH� V�� RG� ��� QLH� RG� �� MDN� QD� SU]\NáDGw Fortranie. I tak wektor[0] reprezentuje pierwszy element, wektor[1] drugi, itd. Wobec tegowektor, który ma n elementów zawiera elementy o indeksach 0..n-1, NIE 1..n.

:HNWRU�PD�WDNLH�VDPH�SUDZD� MDN��]Z\NáH�� W\S\�±�PR*QD�JR�SU]HND]\ZDü� MDNR�DUJXPHQW� IXQNFML�]ZUDFDü� MDNR� Z\QLN� IXQNFML�� SU]\SLV\ZDü�� HWF�� ±� QLH� PR*QD� WHJR� SRZLHG]LHü� R� WDEOLFDFK�3U]\NáDGRZR����IXQNFMD��NWyUD�ELHU]H�DUJXPHQW\��NWyUH�V��ZHNWRUDPL�L�]ZUDFD�ZHNWRUvector<double> dodaj_wektory( vector<double> pierwszy, vector<double> drugi) { vector<double> wynik; // wykonaj dodawanie element po elemencie return wynik;}

vector<double> wekt1(100);vector<double> wekt2(40);// ... inne operacje, np. ustawienie elementów wektora 'wekt2'wekt1=wekt2; // nadpisanie wektora pierwszego drugim

6 Próba taka skutkuje tzw. zachowaniem niezdefiniowanym�� 3U]\� RGURELQLH� V]F]�FLD� SURJUDP� QDW\FKPLDVW� VL]DNR�F]\�� DOH� WDN� QDSUDZG� QLH� ZLDGRPR� FR� VL� VWDQLH�� WM�� M]\N� &��� QLH� SUHF\]XMH� MDN� WUDJLF]QH� EG�� VNXWNL�W�V]F]HJyOQR�FL�SURJUDP�PR*H��Z\GDZDü�VL�G]LDáDü���FR�QLH�]QDF]\�*H�G]LDáD����7� =DDZDQVRZDQL� SURJUDPL�FL�PRJ�� Z\áDSDü� Z\M�WHN�� NWyU\� MHVW� ZWHG\� ]JáDV]DQ\� L� XVWU]HF� VL� SU]HG� ]DNR�F]HQLHPSURJUDPX��SRGHMPXM�F�Z�]DPLDQ�MDNLH��DPELWQLHMV]H�G]LDáDQLD�

Page 14: :VW S G R& - mif.pg.gda.pl · • metody numeryczne, • $ojr u\wp\uyzq r ohjáh • =d vwrvrzdqlhu y * q\fk urgrzl v nn r psxwhurz\fkgrreol f ]h qxp h u\ f ]q \ fk 8zdjlu y * qh

Y����������±�������-DFHN�']LHG]LF��)7L06��3ROLWHFKQLND�*GD�VND��� [email protected]

-HGQ�� ]� LVWRWQ\FK� FHFK� RGUy*QLDM�F\FK� ZHNWRU� RG� WDEOLF� MHVW� RIHURZDQD� SU]H]� QLHJR� PR*OLZR�ü]PLDQ\�UR]PLDUX��NWyU��PR*HP\�RVL�JQ�ü�NRU]\VWDM�F�]�PHWRG\�resize() ��SRGDM�F�QRZ\�UR]PLDUwektora:

vector<double> wektor(100); // wektor ma rozmiar 100 elementówZHNWRU�UHVL]H������������������MX*�PD�����HOHPHQWyZwektor.resize(0); // a teraz jest pusty

3U]\� SRZLNV]DQLX� ZHNWRUD�� QD� MHJR� NR�FX� ]RVWDM�� GRSLVDQH� SXVWH� HOHPHQW\�� 3U]\� VNUDFDQLXZHNWRUD�RVWDWQLH�HOHPHQW\�JLQ��EH]SRZURWQLH�:HNWRU� XPR*OLZLD� MHV]F]H� RSHUDFM� GRGDQLD� HOHPHQWX� QD� NR�FX�� push_back() – skutkuje onaSRZLNV]HQLHP�GáXJR�FL�ZHNWRUD�R���L�XVWDZLHQLHP�RVWDWQLHJR�HOHPHQWX�QD�]DGDQ��ZDUWR�ü�vector<int> wektor(3); // wektor jest pustywektor[0]=3; wektor[1]=1; wektor[2]=4; // wektor ma 3 elementy: 3, 1, 4wektor.push_back(5); // wektor ma 4 elementy: 3, 1, 4, 5

:EUHZ� WHPX�� FR�PR*QDE\� SU]\SXV]F]Dü�ZHNWRU\� QLH� RIHUXM�� *DGQ\FK� RSHUDFML� DU\WPHW\F]Q\FK� ±JG\� FKFHP\� GRGDü� GR� VLHELH� GZD�ZHNWRU\� �Z� VHQVLH� SLHUZV]\� HOHPHQW� GR� SLHUZV]HJR�� GUXJL� GRGUXJLHJR��HWF����PXVLP\��UF]QLH��GRNRQDü�GRGDZDQLD�HOHPHQW�SR�HOHPHQFLH��-HVW�WR�SRG\NWRZDQHW\P�� *H�ZHNWRU\� PRJ�� SU]HFKRZ\ZDü� HOHPHQW\� QLHEG�FH� OLF]EDPL� �MHV]F]H� UD]� SRGNUH�ODP� LFK�QLHPDWHPDW\F]Q��� QDWXU�� ±� MDN� PLDáRE\� E\ü� ]UHDOL]RZDQH� GRGDQLH� GZyFK� ZHNWRUyZ�� NWyU\FKHOHPHQWDPL�V��QXPHU\�3(6(/�DOER�QD]ZLVND"�2GSRZLHGQLH�IXQNFMH�áDWZR�QDSLVDü�VDPHPX�:HNWRU\�V��]�QDWXU\� MHGQRZ\PLDURZH��*G\�SRWU]HEXMHP\�F]HJR��QD�NV]WDáW� WDEOLF\�GZXZ\PLDUR�ZHM� �PDFLHU]\��� PR*HP\� VWZRU]\ü���� ZHNWRU� ZHNWRUyZ�� -H�OL� FKFHP\� WDEOLF\� WUyMZ\PLDURZHM�WHQVRUD���PR*HP\�SRVáX*\ü�VL�ZHNWRUHP�ZHNWRUyZ�ZHNWRUyZ��3U]\NáDGRZR�vector< vector< double > > macierz(30,40); // macierz 30x40vector< vector< vector< bool> > > kostka; // tensor trójwymiarowy

2�WDN�XWZRU]RQHM�PDFLHU]\�P\�OLP\�MDN�R�ZHNWRU]H��NWyUHJR�ND*G\�HOHPHQW�MHVW�ZHNWRUHP��:REHFtego np. macierz[4 ] �R]QDF]D�SL�W\�ZLHUV]��SL�W\�ZHNWRU���D�macierz[4][7] oznacza ósmy elementWHJR�ZLHUV]D��SDPLWDP\�R�QXPHURZDQLX�RG�]HUD����3U]\�WDEOLFDFK�R�OLF]ELH�Z\PLDUyZ�ZLNV]HM�QL*GZD� QLH� PR*HP\� QLHVWHW\� ]DGDü� UR]PLDUX� SU]\� GHNODUDFML� ±� PR*OLZH� MHVW� W\ONR� WZRU]HQLH� WDEOLFSXVW\FK��D�SRWHP�XVWDZLDQLH�UR]PLDUyZ�]D�SRPRF��resize() .

Uwaga:�WZRU]�F�ZHNWRU\�ZHNWRUyZ�QDOH*\�]DGEDü��DE\� ]QDNL� �!�� ]QDMGXM�FH� VL�Z� MHJR�GHILQLFMLRGG]LHOLü�RG�VLHELH�]QDNLHP�VSDFML�±�Z�SU]HFLZQ\P�SU]\SDGNX�NRPSLODWRU�SRWUDNWXMH�GZD�VNOHMRQH]H� VRE�� ]QDNL� �!�� MDNR� RSHUDWRU� ZF]\WDQLD� ]H� VWUXPLHQLD� �!!�� L� �]JáXSLHMH��� -HVW� WR� ]QDQHQLHGRSUDFRZDQLH�M]\ND�7DN�XWZRU]RQH�PDFLHU]H� QLH�RIHUXM�� W\SRZ\FK� �PDWHPDW\F]Q\FK�� RSHUDFML� �PQR*HQLD�� REOLF]DQLDZ\]QDF]QLND�� GLDJRQDOL]DFML�� HWF��� ±� ]QRZX� SU]\SRPLQD� VL� �QLHPDWHPDW\F]QD�� QDWXUD� ZHNWRUD� ±PRJ��RQH�SU]HFLH*�SU]HFKRZ\ZDü�QLH�W\ONR�OLF]E\��DOH�QS�� OLWHU\��QXPHU\�NRQW�F]\�QD]ZLVND��*G\SRWU]HEXMHP\� ]DDZDQVRZDQ\FK� RSHUDFML� PDWHPDW\F]Q\FK�� NRU]\VWDP\� QD� RJyá� ]� ELEOLRWHNVWZRU]RQ\FK�SU]H]�NRJR�� LQQHJR��NWyUH�XGRVWSQLDM�� IXQNFMH�Z� URG]DMX�SRPQy*���� GLDJRQDOL]XM���Z\]QDF]QLN��� LWS�� 3U]\NáDGHP� EDUG]R� F]VWR� Z\NRU]\VW\ZDQHM� ELEOLRWHNL� MHVW� /$3$&.�� NWyUDXGRVWSQLD� PQyVWZR� RSHUDFML� SU]\GDWQ\FK� Z� DOJHEU]H� OLQLRZHM� ±� QLH� SUDFXMH� RQD� FR� SUDZGDEH]SR�UHGQLR�]�ZHNWRUDPL��MHVW�QDSLVDQD�Z�)RUWUDQLH���DOH�PR*QD�M��GR�WHJR�SU]\VWRVRZDü�

Page 15: :VW S G R& - mif.pg.gda.pl · • metody numeryczne, • $ojr u\wp\uyzq r ohjáh • =d vwrvrzdqlhu y * q\fk urgrzl v nn r psxwhurz\fkgrreol f ]h qxp h u\ f ]q \ fk 8zdjlu y * qh

Y����������±�������-DFHN�']LHG]LF��)7L06��3ROLWHFKQLND�*GD�VND��� [email protected]

Strumienie – c.d.

:LHP\� MX*��*H�]H�VWUXPLHQLD�ZHM�FLRZHJR�PR*HP\�F]\WDü�GDQH�]D�SRPRF��RSHUDWRUD�>>. PodczasF]\WDQLD� NROHMQ\FK� GDQ\FK� LJQRURZDQH� V�� DXWRPDW\F]QLH� ZV]\VWNLH� ELDáH� ]QDNL�WM��]QDNL�VSDFML��NR�FD�ZLHUV]D��NR�FD�VWURQ\��WDEXODFML���=DWHP�SRGF]DV�F]\WDQLD�W\P�VSRVREHP�QLHPR*HP\�Z\NU\ü�NR�FD�ZLHUV]D�� ER� ]RVWDQLH� RQ� SRPLQLW\� L� F]\WDQLH� SU]HMG]LH� DXWRPDW\F]QLH� GRQDVWSQHJR�ZLHUV]D�$OWHUQDW\Z�� GR� F]\WDQLD� ]D� SRPRF�� RSHUDWRUD� >>� MHVW� F]\WDQLH� ]H� VWUXPLHQLD� FDá\PL� OLQLDPL�0R*HP\� WHJR� GRNRQDü� ]D� SRPRF�� PHWRG\� �IXQNFML�� VWUXPLHQLD� R� QD]ZLH� getline() �� NWyU�Z\ZRáXMHP\�QDVWSXM�FR�cin.getline(bufor,rozmiar,'\n');

3RZ\*V]D� NRQVWUXNFMD� QDND]XMH� ZF]\WDQLH� MHGQHM� OLQLL� ]H� VWUXPLHQLD� cin do tablicy znaków onazwie bufor i rozmiarze rozmiar ��=RVWDQLH�ZF]\WDQH�ZV]\VWNLH� ]QDNL�� D*� GR� QDSRWNDQLD� ]QDNX'\ n ��NR�FD�ZLHUV]D���FK\ED�*H�OLQLD�EG]LH�]E\W�GáXJD��E\�]PLH�FLü�VL�Z�WDEOLF\�bufor – wówczaswczytane zostanie tylko (rozmiar-��� ]QDNyZ� L� WDEOLFD� QLH� ]RVWDQLH� SU]HSHáQLRQD�� D� UHV]WD� OLQLLSR]RVWDQLH� Z� VWUXPLHQLX� GR� NROHMQHJR� RGF]\WX�� 7DEOLF� ]QDNyZ� EXIRU� PXVLP\� RF]\ZL�FLH]DGHNODURZDü� ZF]H�QLHM�� Uwaga na marginesie�� WDEOLFH� ]QDNyZ� V�� QLHZ\JRGQ\P� VSRVREHPSU]HFKRZ\ZDQLD� áD�FXFKyZ� ]QDNyZ� L� V�� SR]RVWDáR�FL�� SR� M]\NX� &�� =QDF]QLH� Z\JRGQLHMV]\PUR]ZL�]DQLHP� MHVW� VWRVRZDQLH� ]PLHQQHM� áD�FXFKRZHM� �W\S� string ). Niestety parametr dlagetline() � PXVL� E\ü� WDEOLF�� ]QDNyZ�� QLH� PR*H� E\ü� áD�FXFKHP�� 7DEOLFH� ]QDNyZ� PR*QD� MHGQDNSU]\SLV\ZDü�GR�áD�FXFKyZ��]DWHP�PR*HP\�SLVDü�WDN�char bufor[256]; // zakladamy, ze linie nie moga miec wiecej niz 255 znakowstring linia;cin.getline(bufor,256,'\n');linia=bufor;

2G�WHJR�PRPHQWX�Z�]PLHQQHM�áD�FXFKRZHM�linia �PDP\�MHGQ��OLQL�SREUDQ��]H�VWUXPLHQLD�Prostszym sposobem poradzenia sobie z czytaniem pliku po linii jest skorzystanie z globalnej8

funkcji getline �� NWyUD� MDNR� SLHUZV]\� SDUDPHWU� SRELHUD� QD]Z� VWUXPLHQLD�� D� MDNR� GUXJL� ]PLHQQ�typu string :

string linia;getline(cin,linia);

3RGHM�FLH� WDNLH� ]ZDOQLD� QDV� RG� GHF\GRZDQLD� MDN� GáXJD� PDNV\PDOQLH� PR*H� E\ü� OLQLD� ±� UR]PLDUQDV]HM�]PLHQQHM�áD�FXFKRZHM�OLQLD�VDP�GRVWRVXMH�VL�GR�GáXJR�FL�OLQLL�Z�SOLNX�&��� XPR*OLZLD� VWZRU]HQLH� VWUXPLHQLD� Z� SDPLFL�� NWyU\� QLH� MHVW� ]ZL�]DQ\� DQL� ]� NRQVRO��� DQL� ]*DGQ\P� IL]\F]Q\P� SOLNLHP� G\VNRZ\P�� 6WUXPLH�� WDNL� SR]ZDOD� QDP� LQWHUSUHWRZDü� XSU]HGQLRZF]\WDQ��OLQL�MDN�LQQ\�VWUXPLH���3U]\NáDGRZR�GRSLVDQLH�GR�SRZ\*V]HJR�NRGX�stringstream linia_jako_strumien; // zadeklaruj strumien w pamiecilinia_jako_strumien << linia; // wyslij linie do strumienialinia_jako_strumien >> a >> b >> c; // odczytaj a, b i c z tego strumienia

8��FL�FOH�U]HF]�ELRU�F�IXQNFMD�WD�MHVW�]DGHNODURZDQD�Z�SU]HVWU]HQL�QD]Z�std .

Page 16: :VW S G R& - mif.pg.gda.pl · • metody numeryczne, • $ojr u\wp\uyzq r ohjáh • =d vwrvrzdqlhu y * q\fk urgrzl v nn r psxwhurz\fkgrreol f ]h qxp h u\ f ]q \ fk 8zdjlu y * qh

Y����������±�������-DFHN�']LHG]LF��)7L06��3ROLWHFKQLND�*GD�VND��� [email protected]

SR]ZDOD�QDP�F]\WDü�]PLHQQH�a, b i c �]H�VWUXPLHQLD��NWyU\�]DZLHUD�MHGQ��OLQL��ZF]\WDQ��XSU]HGQLR�]LQQHJR� VWUXPLHQLD��� 7DNLH� UR]ZL�]DQLH� SR]ZDOD� á�F]\ü� F]\WDQLH� ]� SOLNX� SR� OLQLL� ] wygodnymF]\WDQLHP�]D�SRPRF��RSHUDWRUD�>>.

6WUXPLH��Z�SDPLFL�SR]ZDOD�QDP� WDN*H� GRNRQ\ZDü� NRQZHUVML� PLG]\� UHSUH]HQWDFMDPL� OLF]E��1DSU]\NáDGstring lancuch="1.23456"; // mamy zmienna lancuchowadouble liczba; // i liczbestringstream strumien; // deklarujemy strumien w pamiecistrumien << lancuch; // wysylamy lancuchstrumien >> liczba; // a pobieramy liczbe

SR]ZDOD� QD� NRQZHUVM� string → double �� $QDORJLF]QLH� PR*HP\� SU]HSURZDG]Lü� NRQZHUVM� ZGUXJ��VWURQ�Uwaga:� $E\� VNRU]\VWDü� ]H� VWUXPLHQL� SDPLFLRZ\FK� QDOH*\� GR� SURJUDPX� GRá�F]\ü� SOLNQDJáyZNRZ\� sstream � ]D� SRPRF�� G\UHNW\Z\� #include<sstream> � QD� SRF]�WNX� SURJUDPX�3RGREQLH� DE\� NRU]\VWDü� ]� W\SX� áD�FXFKRZHJR� string � QDOH*\� ]DVWRVRZDü� G\UHNW\Z#include<string> .

:VSRPQLHOL�P\� MX*�� *H� MHGQ�� ]� ]DOHW� VWUXPLHQL� MHVW� PR*OLZR�ü� Z\SURZDG]DQLD� ]D� LFK� SRPRF�GDQ\FK� EH]� GEDQLD� R� IRUPDW�� Z� MDNLP� ]RVWDQ�� Z\SURZDG]RQH�� =GDU]DM�� VL� MHGQDN� V\WXDFMH�V]F]HJyOQLH� SRGF]DV� REFRZDQLD� ]� 0HWRGDPL� 1XPHU\F]Q\PL��� Z� NWyU\FK� FKFHP\� GRNáDGQLHVSUHF\]RZDü� IRUPDW� Z\SURZDG]DQLD� GDQ\FK�� -DN� PR*QD� WR� ]URELü"� 3HZQH� SDUDPHWU\� VWUXPLHQLD�RNUH�ODM�FH� P�LQ�� IRUPDW�� PR*QD� ]PLHQLDü� Z\ZRáXM�F� PHWRG� �IXQNFM�� VWUXPLHQLD� setf() iSU]HND]XM�F�MHM�RGSRZLHGQLH�DUJXPHQW\��0R*QD�UyZQLH*�GR�VWUXPLHQLD�Z\V\áDü�W]Z��PDQLSXODWRU\�NWyUH�G]LDáDM��MDN�VHNZHQFMH�NRQWUROQH�XVWDZLDM�F�SHZQH�SDUDPHWU\�VWUXPLHQLD��'UXJD�]�W\FK�PHWRGMHVW� HOHJDQWV]D�� MHGQDN� ]� XZDJL� QD� QLHV]F]HJyOQ�� DNWXDOQR�ü� NRPSLODWRUD� g++ stosowanego na]DMFLDFK� F]DVHP� �F]VWR�� EG]LHP\� SRVáXJLZDü� VL� PHWRG�� SLHUZV]��� .LOND� QDMF]�FLHM]PLHQLDQ\FK� SDUDPHWUyZ�� ]D� SRPRF�� PHWRG\� SLHUZV]HM� Z� ]DVWRVRZDQLX� GR� VWUXPLHQLD� cout

SRND]DQR�SRQL*HM�cout.setf(ios:: left, LRV��DGMXVWILHOG�������Zá�F]D�Z\UyZQ\ZDQLH�GR�OHZHMcout.setf(ios:: right �LRV��DGMXVWILHOG������Zá�F]D�Z\UyZQ\ZDQLH�GR�SUDZHMcout.setf(ios:: fixed, ios::floatfield); // przechodzi do trybu fixedcout.setf(ios:: scientific ,ios::floatfield); // przechodzi do trybu notacji // naukowej (scientific)cout.setf(ios:: showpoint �������Z\PXV]D�SRND]\ZDQLH�NURSNL�G]LHVLWQHM�za wszecout.setf(ios:: showpos ); // wymusza znak '+' przed liczbami dodatnimi

:\UyZQ\ZDQLH� GR� OHZHM� E�G(� GR� SUDZHM� RGQRVL� VL� GR� SRáR*HQLD� OLF]E\� QD� Z\GUXNX�Z]JOGHPSROD��Z� NWyU\P� VL� RQD� ]QDMGXMH��:� WU\ELH� fixed � ZV]\VWNLH� OLF]E\�Z\SLV\ZDQH� V�� ]� WDN�� VDP��]DGDQ�� OLF]E�� F\IU� SR� SU]HFLQNX�� :� WU\ELH� QRWDFML� QDXNRZHM� �scientific ) wszystkie liczbyZ\SLV\ZDQH�V�� UD]HP�]�Z\NáDGQLNLHP��:�WU\ELH�GRP\�OQ\P��DQL� fixed , ani scientific ) liczbyZ\SLV\ZDQH�V��]H�]PLHQQ��OLF]E��F\IU�SR�SU]HFLQNX��QS��NR�FRZH�]HUD�V��REFLQDQH��E�G(�Z�QRWDFMLQDXNRZHM�� 7U\E� GRP\�OQ\� NLHSVNR� SDVXMH� GR� 0HWRG� 1XPHU\F]Q\FK�� QD� RJyá� EG]LHP\� ZLFSUDFRZDü�Z�WU\ELH�fixed �E�G(�scientific .

=D�SRPRF��PDQLSXODWRUD�setprecision() �PR*HP\�NRQWURORZDü�SUHF\]M�Z\SURZDG]DQ\FK� OLF]E�GRP\�OQLH�UyZQ������-HJR�LQWHUSUHWDFMD�]DOH*\�RG�WU\EX��Z�NWyU\P�MHVW�VWUXPLH���: trybach fixed iscientific XVWDODP\� OLF]E� F\IU�po przecinku jaka jest wyprowadzana. W�WU\ELH� GRP\�OQ\PPDQLSXODWRU� WHQ� RNUH�OD� PDNV\PDOQ�� OLF]E� F\IU� w ogóle (przed i po przecinku), jaka jestwyprowadzana. =�PDQLSXODWRUD�NRU]\VWDP\�Z\V\áDM�F�JR�GR�VWUXPLHQLD:

Page 17: :VW S G R& - mif.pg.gda.pl · • metody numeryczne, • $ojr u\wp\uyzq r ohjáh • =d vwrvrzdqlhu y * q\fk urgrzl v nn r psxwhurz\fkgrreol f ]h qxp h u\ f ]q \ fk 8zdjlu y * qh

Y����������±�������-DFHN�']LHG]LF��)7L06��3ROLWHFKQLND�*GD�VND��� [email protected]

cout << setprecision(10) << 1.43; // ustaw precyzje na 10

']LDáDQLH�SRZ\*V]HM�LQVWUXNFML�Z\SURGXNXMH�w trybie fixed : 1.4300000000w trybie scientifi c: 1.4300000000e+00Z�WU\ELH�GRP\�OQ\P��������ER�NR�FRZH�]HUD�V��REFLQDQH�=D�SRPRF��PDQLSXODWRUD�setw() �PR*HP\�NRQWURORZDü�V]HURNR�ü�SROD��GR�NWyUHJR�Z\SURZDG]DQDMHVW�GDQD��:� W\P�SROX�GDQD� ]RVWDQLH�Z\UyZQDQD�GR�SUDZHM�� E�G(� GR� OHZHM��Uwaga: manipulatorsetw() �G]LDáD� W\ONR�GOD�GDQHM�Z\SURZDG]DQHM� EH]SR�UHGQLR�SR� MHJR�]DVWRVRZDQLX��]DWHP�QD�RJyáWU]HED�JR�VWRVRZDü�ZLHORNURWQLH��3U]\NáDGRZR�FRXW�VHWI�LRV��IL[HG�����������������������Zá�F]�WU\E�IL[HGcout.setf(ios:: left ,ios::adjustfield); // wyrównuj do lewejcout << setprecision(4); // 4 cyfry po przecinkucout << setw(10) << 1.43 << endl; // szerokosc pola 10, wypiszcout.setf(ios:: right ,ios::adjustfield); // wyrównuj do prawejcout << setw(10) << 1.43 << endl; // szerokosc pola 10, wypisz

Z\SURGXNXMH���B�R]QDF]D�VSDFM��1.4300 _ _ _ __ _ _ _ 1.4300

3ROH�PD�Z�SRZ\*V]\P�SU]\NáDG]LH�V]HURNR�ü�G]LHVLFLX�]QDNyZ��D�SUHF\]M�XVWDZLOL�P\�QD���F\IU\po przecinku.

3UyED�Z\SURZDG]HQLD�]PLHQQHM��NWyUD�QLH�PLH�FL� VL�Z�SROX�NR�F]\� VL� SRZLNV]HQLHP�SROD� WDN�*HE\� OLF]ED� PLH�FLáD� VL� Z� QLP� �]DVDGD� PyZL�FD�� *H� OHSLHM� Z\SURZDG]Lü� GREUH� GDQH� Z brzydkiVSRVyE��SVXM�F�UR]PLDU�SROD���QL*�]áH�GDQH�áDGQH��ZFLVNDM�F�OLF]E�Z�SROH���Manipulator setfill( ) �SR]ZDOD�QD�]PLDQ�]QDNX��NWyU\P�GRSHáQLDQH�MHVW�SROH��GRP\�OQLH�MHVW�QLPVSDFMD���3U]\NáDGRZR�GRSLVDQLHcout << setfill('#');

SU]HG�SRSU]HGQLP�SU]\NáDGHP�]PLHQLáRE\�Z\GUXN�QD�1.4300########1.4300

Uwaga:�$E\�VNRU]\VWDü�]�PDQLSXODWRUyZ�QDOH*\�GR�SURJUDPX�GRá�F]\ü�SOLN�QDJáRZNRZ\�iomanip

]D�SRPRF��G\UHNW\Z\�#include<iomanip> �QD�SRF]�WNX�SURJUDPX�6WUXPLHQLH� V�� LQWHOLJHQWQH� SRQLHZD*� SR]ZDODM�� ZF]\W\ZDü� GDQH� Z� Uy*Q\FK� IRUPDWDFK� Z]DOH*QR�FL�RG�W\SX�ZF]\W\ZDQ\FK�]PLHQQ\FK��1D�SU]\NáDGint a; double b; string c;cin >> a >> b >> c;

ZF]\WD�]PLHQQ��FDáNRZLW��a��]PLHQQRSU]HFLQNRZ��b�L�áD�FXFK�]QDNyZ�c ��&R�VL�MHGQDN�VWDQLH��MH�OLX*\WNRZQLN� EG]LH� FKFLDá� SRSVXü� QDP� SODQ\� L� ZSLV]H� ]� NODZLDWXU\� QD� SU]\NáDG� WHNVW� ���DOD� PDNRWD�"�3LHUZV]D�Z�NROHMQR�FL�GR�ZF]\WDQLD� MHVW�]PLHQQD�FDáNRZLWD� a��=H�VWUXPLHQLD�SRELHUDQH�V�znaki '3' i '2' i zmienna 'a � SU]\ELHUD� ZDUWR�ü� ���� 1DVWSQLH� SRGHMPRZDQD� MHVW� SUyED� ZF]\WDQLDliczby zmiennoprzecinkowej 'b ��OHF]�Z�VWUXPLHQLX�QLH�PD�MX*�OLF]E\��OHF]�WHNVW��DOD�PD�NRWD��

Page 18: :VW S G R& - mif.pg.gda.pl · • metody numeryczne, • $ojr u\wp\uyzq r ohjáh • =d vwrvrzdqlhu y * q\fk urgrzl v nn r psxwhurz\fkgrreol f ]h qxp h u\ f ]q \ fk 8zdjlu y * qh

Y����������±�������-DFHN�']LHG]LF��)7L06��3ROLWHFKQLND�*GD�VND��� [email protected]

:�V\WXDFML��Z�NWyUHM�GDQH�ZHM�FLRZH�QLH�SDVXM��GR�RF]HNLZDQHJR�IRUPDWX��VWUXPLH��SU]HFKRG]L�Zstan zepsuty��:�VWDQLH�]HSVXW\P�ZV]\VWNLH�SUyE\�RGF]\WX�]H�VWUXPLHQLD�V�� LJQRURZDQH��SRGREQLH]�]DSLVHP���=DWHP�Z�QDV]\P�SU]\NáDG]LH�SR�ZF]\WDQLX�]PLHQQHM� a� VWUXPLH��SU]HFKRG]L�GR�VWDQXzepsutego i zmienne 'b' i 'c �QLH�]PLHQLDM�� VZRMHM�ZDUWR�FL��ER�VWUXPLH�� ]HSVXW\� LJQRUXMH�*�GDQLD�NWyUH� GR� QLHJR�Z\V\áDP\�� 7R�� F]\� VWUXPLH�� MHVW� Z� VWDQLH� GREU\P� �ZV]\VWNR� 2.��� F]\� Z� VWDQLH]HSVXW\P��FR��SRV]áR�QLH�WDN��PR*HP\�VSUDZG]Lü�ZRáDM�F�PHWRG��IXQNFM��good() , np:

if(cin.good()) cout << "strumien cin jest w stanie dobrym";else cout << "strumien cin jest w stanie zepsutym";

MH�OL� SR� ND*G\P� RGF]\FLH� ]H� VWUXPLHQLD� EG]LHP\� VSUDZG]Dü�� F]\� QLH� MHVW� RQ� ]HSVXW\� EG]LHP\PLHü�NRQWURO�QDG�SRSUDZQR�FL��RSHUDFML�RGF]\WX��SRGREQLH�GOD�]DSLVX��if( ! PRMBVWUXPLHQ�JRRG�����������MH�OL�FR��SRV]áR�QLH�WDN��WR���

&R� GDOHM� ]H� VWUXPLHQLHP�� NWyU\� MHVW� ]HSVXW\"� 6WUXPLH�� PR*HP\� QDSUDZLü� Z\ZRáXM�F� PHWRGclear() , np.

cin.clear(); // cin jest teraz w stanie dobrym

1LHVWHW\�� QDZHW� SR� QDSUDZLHQLX� VWUXPLHQLD� GDQH�� NWyUH� VSRZRGRZDá\� MHJR� SU]HM�FLH� GR� VWDQX]HSVXWHJR�QDGDO�SR]RVWDM��Z�VWUXPLHQLX��WDN�ZLF�SUyED�SRQRZQHJR�LFK�RGF]\WDQLD�]QyZ�]DNR�F]\VL� QLHSRZRG]HQLHP� �L� ]HSVXFLHP� VWUXPLHQLD��� FK\ED� *H� ]PLHQLP\� W\S�ZF]\W\ZDQ\FK� GDQ\FK� QDRGSRZLHGQL�� 'DQH� EG�FH� SU]\F]\Q�� NáRSRWX� WH� SRZLQQL�P\� ]H� VWUXPLHQLD� XVXQ�ü�� FR� MHGQDNRND]XMH�VL�]DGDQLHP�QLHWU\ZLDOQ\P��ER�QLH�ZLDGRPR�ile�WU]HED�LFK�XVXQ�ü���1D�UD]LH�QLH�EG]LHP\VL�]DMPRZDü�W\P�]DJDGQLHQLHP��Z\VWDUF]\�QDP�SRGHM�FLH��Z�NWyU\P�SU]\�QDSRWNDQLX�NáRSRWyZ�SRSURVWX�NR�F]\P\�SUDF�DZDU\MQLH��QLH�SU]HMPXM�F�VL�W\P��*H�VWUXPLH��SR]RVWDá�]HSVXW\�3RGF]DV� F]\WDQLD� PR*HP\� QDWUDILü� QD� NRQLHF� SOLNX� ]ZL�]DQHJR� ]H� VWUXPLHQLHP�� 7R�� F]\w�VWUXPLHQLX�QLH�PD�MX*�GDQ\FK�PR*HP\�VSUDZG]Lü�]D�SRPRF��PHWRG\�eof() :

LI�PRMBVWUXPLHQ�HRI�����������QLH�PD�MX*�GDQ\FK�Z�VWUXPLHQLX�PRMBVWUXPLHQ

1DOH*\�WX�MHGQDN�Z\ND]Dü�VSRUR�RVWUR*QR�FL�±�R�W\P��*H�Z�VWUXPLHQLX�QLH�PD�MX*�GDQ\FK�PR*QD�VLSU]HNRQDü� W\ONR� po� SUyELH� ZF]\WDQLD� GDQ\FK�� ,QQ\PL� VáRZ\�� VSUDZG]HQLH eof() nie mówi nico tym, czy odczyt kolejnej danHM�SRZLHG]LH�VL��F]\�QLH�����±�PRJáRE\�VL�QD�SU]\NáDG�]GDU]\ü�WDN�*H� MHVWH�P\� QD� NR�FX� SOLNX�� D� Z� XáDPHN� VHNXQG\� Sy(QLHM� NWR�� LQQ\� FR�� GR� WHJR� SOLNX� GRSLV]H�:REHF�SRZ\*V]HJR�MHG\Q\� VáXV]Q\�sposób korzystania z eof() to taki, w którym po wczytaniuGDQHM�VSUDZG]DP\��F]\�SUyED�VL�SRZLRGáD�moj_strumien >> dana;if(moj_strumien.eof()) ... // 'dana' nie ma sensu, bo E\OL�P\ QD�NR�FX�VWUXPLHQLDHOVH��������GDQD�RGF]\WDQD�Z�SRU]�GNX

Uwaga:� VWUXPLH��� Z� NWyU\P� RVL�JQOL�P\� MX*� NRQLHF� SU]HFKRG]L� UyZQLH*� Z� VWDQ� ]HSVXW\� �PR*HQLH]JRGQLH� ]� LQWXLFM���� ]DWHP� WR�� *H� VWUXPLH�� MHVW� ]HSVXW\� QLH� PXVL� MHV]F]H� R]QDF]Dü� NáRSRWyZ� ±ZDUWR�WH*�VSUDZG]Lü�ZWHG\��F]\�VWUXPLH��QLH�MHVW�F]DVHP�eof() ��3RGVXPRZXM�F�good() eof() co to oznaczafalse false VWDáR�VL�FR��QLHGREUHJR��VWUXPLH��]HSVXW\�L�QLH�QD�NR�FX�SOLNXfalse true VWUXPLH��]HSVXW\��DOH�GODWHJR�*H�GRWDUOL�P\�GR�NR�FD�SOLNXtrue false ZV]\VWNR�GREU]H��VWUXPLH��Z�SRU]�GNX��QLH�MHVWH�P\�QD�NR�FX�SOLNX

Page 19: :VW S G R& - mif.pg.gda.pl · • metody numeryczne, • $ojr u\wp\uyzq r ohjáh • =d vwrvrzdqlhu y * q\fk urgrzl v nn r psxwhurz\fkgrreol f ]h qxp h u\ f ]q \ fk 8zdjlu y * qh

Y����������±�������-DFHN�']LHG]LF��)7L06��3ROLWHFKQLND�*GD�VND��� [email protected]

true true V\WXDFMD�QLHPR*OLZD1D� UD]LH� ]DMPRZDOL�P\� VL� JáyZQLH� VWUXPLHQLDPL� SUHGHILQLRZDQ\PL� cin i cout �� 1D� FR� G]LH�EG]LHP\� NRU]\VWDü� ]H� VWUXPLHQL� ]ZL�]DQ\FK� ]� SOLNDPL�� 6WUXPLHQLH� WDNLH� PRJ�� E\ü� ZHM�FLRZH�F]\WDQLH� SOLNyZ��� Z\M�FLRZH� �]DSLV\ZDQLH� GR� SOLNyZ�� E�G(� ZHM�FLRZH�L�Z\M�FLRZH�� 6WUXPLHQLHWDNLH�GHNODUXMHP\�MDN�Z�SU]\NáDG]LH�ifstream plik_we("plik1.txt"); // plik do odczytuofstream plik_wy("plik2.txt"); // plik do zapisufstream plik_wewy("plik3.txt"); // plik do odcz./zapisu [ QLH�]DG]LDáD�Z�J�������@

:�WHQ�VSRVyE�]DGHNODURZDOL�P\�VWUXPLH��ZHM�FLRZ\�R�QD]ZLH�plik_we stowarzyszony z plikiemG\VNRZ\P� �SOLN��W[W��� VWUXPLH�� Z\M�FLRZ\� plik_wy stowarzyszony z plikiem dyskowym�SOLN��W[W�� L� VWUXPLH��ZH�Z\�VWRZDU]\V]RQ\�]�SOLNLHP�G\VNRZ\P� �SOLN��W[W���=H� VWUXPLHQL� WDNLFKPR*HP\�F]\WDü�L�SLVDü�GR�QLFK�WDN��MDN�]�GR�SUHGHILQLRZDQ\FK�VWUXPLHQL��QS�plik_we >> a >> b; // odczytaj 'a' i 'b' z plik1.txtplik_wy << "Pi wynosi " << 3.14 << endl; // zapisz do plik2.txt

3OLNL� ]ZL�]DQH� ]H� VWUXPLHQLDPL� V�� RWZLHUDQH� Z� PRPHQFLH� XWZRU]HQLD� ]PLHQQHM� VWUXPLHQLDi�]DP\NDQH�DXWRPDW\F]QLH�Z�PRPHQFLH��Z�NWyU\P�F]DV�*\FLD�]PLHQQHM�VWUXPLHQLD�NR�F]\�VL��*G\FKFHP\� Z\PXVLü� ZF]H�QLHMV]H� ]DPNQLFLH� VWUXPLHQLD�� NRU]\VWDP\� ]� PHWRG\� close() .3U]\NáDGRZR�SRQL*V]D�IXQNFMD�]DSLVXM�FD�MHGQ��OLF]E�GR�SOLNX��]DSLV�W[W��RWZLHUD�L�]DP\ND�WHQ�SOLN]D�ND*G\P�Z\ZRáDQLHP��ZLF�]D�ND*G\P�UD]HP�WZRU]RQ\�MHVW�RQ�QD�QRZR��GRP\�OQH�]DFKRZDQLHSOLNyZ�Z\M�FLRZ\FK��void zapis(int liczba) {��RIVWUHDP�SOLN��]DSLV�W[W�������WX�SOLN�MHVW�WZRU]RQ\�]D�ND*G\P�UD]HP��LI��SOLN�JRRG����UHWXUQ��������F]\�NáRSRW\�]�RWZDUFLHP" plik << liczba << endl; // zapisujemy`����WX�SOLN�MHVW�]DP\NDQ\��ER�]PLHQQD�SOLN�NR�F]\�*\FLH

Uwaga:� $E\� VNRU]\VWDü� ]H� VWUXPLHQL� ]ZL�]DQ\FK� ]� SOLNDPL� QDOH*\� GR� SURJUDPX� GRá�F]\ü� SOLNQDJáyZNRZ\�fstream �]D�SRPRF��G\UHNW\Z\�#include<fstream> �QD�SRF]�WNX�SURJUDPX�