Wstęp do C++ - praktyczne wskazówki ułatwaiające prace.pdf - C, C#, C++ - katwer

Y – -DFHN ’]LHG]LF )7L06 3ROLWHFKQLND *GD VND jaca@kdm.task.gda.pl

:VW S GR & –

SUDNW\F]QH ZVND]yZNL XÆDWZLDM FH SUDF QD ]DM FLDFK ] 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 MHVW

SLVDQLH NLONX LQVWUXNFML Z MHGQ\P ZLHUV]X MH OL ND*GD NR F]\ VL UHGQLNLHP 2GVW S\ VSDFMH

WDEXODWRU\ ]QDNL QRZHM OLQLL PL G]\ 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\FK

Zmiennoprzecinkowe: 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\VW SXM GZD URG]DMH NRPHQWDU]\ .RPHQWDU] UR]SRF]\QDM F\ VL RG SRGZyMQHJR

XNR 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 PL G]\ RSHUDWRUDPL SU]\SLVDQLD = ) i porównania

( == 3LHUZV]\ ] QLFK VÆX*\ GR SU]\SLV\ZDQLD ZDUWR FL VWRM FHM SR SUDZHM VWURQLH GR ]PLHQQHM

VWRM FHM SR OHZHM VWURQLH RGSRZLHGQLN SDVFDORZVNLHJR := "). Drugi z nich ( == ), który odpowiada

pascalowskiemu " = 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 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...

-H OL RP\ÆNRZR ]DPLDVW SRUyZQDQLD ]DVWRVXMHP\ SU]\SLVDQLH MHVW V]DQVD *H NRPSLODWRU ]ZUyFL QDP

QD WR XZDJ Z\SLVXM F RVWU]H*HQLH DOH JZDUDQFML QLH PD OHSLHM VL SLOQRZD ü

Y – -DFHN ’]LHG]LF )7L06 3ROLWHFKQLND *GD VND jaca@kdm.task.gda.pl

=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ÆNRZLWHJR

IORDW F GHNODUXMH ]PLHQQ F W\SX ]PLHQQRSU]HFLQNRZHJR

XQVLJQHG ORQJ LQW S GHNODUXMH ]PLHQQ S W\SX FDÆNRZLWHJR GÆXJLHJR

// bez-znaku

double 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 F

Sy(QLHM ] QD]Z\ WHM ]PLHQQHM .D*GD ]PLHQQD PXVL E\ ü JG]LH ]DGHNODURZDQD Uwaga : Zmienne

LQWHUHVXM F\FK QDV W\SyZ SR ]DGHNODURZDQLX nie V ]HURZDQH D PDM ZDUWR FL SU]\SDGNRZH 1 .

:DUWR R W\P SDPL WD ü LQLFMDOL]XM F SU]\SLVXM F XVWDZLDM F ]PLHQQH SU]HG LFK SLHUZV]\P

X*\FLHP ’RSXV]F]DOQH MHVW Æ F]HQLH LQLFMDOL]DFML ]PLHQQHM ] MHM GHNODUDFM FR ]DEH]SLHF]D QDV

SU]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 PD

NRQLHF]QR FL MDN Z 3DVFDOX F]\ )RUWUDQLH GHNODURZDQLD ]PLHQQ\FK Z FL OH RNUH ORQ\FK

miejscach. Zmienne deklarujemy tam, gdzie nam wygodnie.

.D*GD ]PLHQQD PD VZyM F]DV *\FLD – F]\OL SHZLHQ ]DVL J Z SURJUDPLH Z NWyU\P MHVW ZLGRF]QD

1D SU]\NÆDG ]PLHQQD ]DGHNODURZDQD ZHZQ WU] IXQNFML E G]LH ORNDOQD GOD WHM IXQNFML QLH E G]LH MHM

ZLGD ü SR]D W IXQNFM 3RGREQLH ]PLHQQD ]DGHNODURZDQD Z S WOL MHVW SR]D W S WO QLHZLGRF]QD

8PR*OLZLD WR RV]F] GQH JRVSRGDURZDQLH QD]ZDPL =PLHQQD ]DGHNODURZDQD SR]D MDN NROZLHN

IXQNFM MHVW ]PLHQQ JOREDOQ WM ZLG]LDOQ Z ND*G\P SXQNFLH SURJUDPX ’REU\ VW\O QDND]XMH

XQLNDQLH ]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 . Informuje

RQ 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Æ\FK

Z 3DVFDOX V WH* EDUG]LHM F\ZLOL]RZDQ IRUP NRQVWUXNFML 3$5$0(7(5 Z\VW SXM FHM Z

Fortranie.

3U]\NÆDG\

const IORDW SL GHNODUXMH L GHILQLXMH VWDÆ SL

const LQW W\VLDF GHNODUXMH L GHILQLXMH VWDÆ W\VLDF

... // gdzies dalej, w programie...

GRXEOH SROH SL U U REOLF]D SROH MDNLHJR RNU JX NRU]\VWDM F ]H VWDÆHM

SL SUyED ]PRG\ILNRZDQLD VWDÆHM WR QLH SU]HMG]LH

’]L NL 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 FL

VWDÆ\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

]ZL NV]HQLX Z\GDMQR FL VNÆDGDM F RGSRZLHG]LDOQR ü ]D LQLFMDOL]DFM ]PLHQQ\FK QD EDUNL SURJUDPLVW\

2 1LH GR NR FD SUDZGD

Y – -DFHN ’]LHG]LF )7L06 3ROLWHFKQLND *GD VND jaca@kdm.task.gda.pl

’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\P

SRF] WNX SURJUDPX VWDÆD WD E G]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 SURJUDPX

const double pi=3.141592653589793238462643383; // } <- widziane w

const double obwod_ziemi=40000000; // } calym programie

const unsigned int rozmiar_tablicy=999; // }

// ... cos dalej

// przykladowa funkcja, z malo wazna stala ukryta wewnatrz funkcji

int 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 ] S WOL for R NWyU\FK E G]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*\ SDPL WD ü 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 typu

int b=2; // int. Ale typ int nie moze przechowac wartosci 0.5, nawet jesli

a=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.3

b=+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 SRW JRZDQLD Z VW\OX )RUWUDQX 3RW JRZDQLH PR*QD

UHDOL]RZD ü ]D SRPRF IXQNFML pow() ]GHILQLRZDQHM Z SOLNX QDJÆyZNRZ\P cmath E G]LH R W\P

Sy(QLHM E G( WH* U F]QLH MH OL MHVW QLHVNRPSOLNRZDQH

GRXEOH D SRZ D URZQH MHVW GR SRW JL

GRXEOH E D D D E URZQH MHVW D GR WU]HFLHM REOLF]RQH U F]QLH

Y – -DFHN ’]LHG]LF )7L06 3ROLWHFKQLND *GD VND jaca@kdm.task.gda.pl

2EOLF]DQLH U F]QH SU]HVWDMH VL RSÆDFD ü ZL FHM SLVDQLD ZROQLHM G]LDÆD SU]\ SRW JDFK ZL NV]\FK

od 4.

2SHUDWRU\ SRUyZQDQLD L SU]\SLVDQLD RPyZLOL P\ MX* ZF]H QLHM = EDUG]LHM LVWRWQ\FK RSHUDWRUyZ

PR*QD ZVSRPQLH ü MHGQRDUJXPHQWRZH RSHUDWRU\ LQNUHPHQWDFML ++ ]ZL NV]DQLD R L

dekrementacji " -- " (zmniejszania o 1):

int a=7;

a++; // a teraz rowne 8. Dziala szybciej niz zwykle a=a+1

a--; // 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*QD

SRVÆX*\ ü VL QRWDFM VNUyFRQ L HIHNW\ZQLHMV] Z NWyUHM SR ]QDNX RSHUDWRUD SLV]H VL ]QDN

UyZQR FL R WDN

a+=6; // to samo, co a=a+6

a*=3; // to samo, co a=a*3

a/=7; // to samo, co a=a/7

a%=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\ ZL FHM RSHUDWRUyZ Z\UD*HQLH REOLF]DQH MHVW ]JRGQLH ] LFK SULRU\WHWDPL QD SU]\NÆDG

PQR*HQLH Z\NRQ\ZDQH MHVW SU]HG GRGDZDQLHP -H OL FKFHP\ LQDF]HM VWRVXMHP\ QDZLDV\

int a=2+2*2; // a teraz rowne 6

int 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 ZL FRQHM NRQVWUXNFMRP ZDUXQNRZ\P

’]LDÆDQLH RSHUDWRUyZ SRUyZQDQLD > ", " < ", " >= ", " <= " jest intuicyjnie oczywiste, przynajmniej dla

typów wbudowanych.

Konstrukcje warunkowe

3RGVWDZRZ NRQVWUXNFM ZDUXQNRZ MHVW NRQVWUXNFMD if-else SR]ZDODM FD QD Z\NRQDQLH Uy*Q\FK

LQVWUXNFML Z ]DOH*QR FL RG VSHÆQLHQLD – E G( QLH – SHZQHJR ZDUXQNX 6NÆDGQLD WHM LQVWUXNFML MHVW

QDVW SXM FD

if(warunek) instrukcja1;

else instrukcja2;

: SU]\SDGNX VSHÆQLHQLD ZDUXQNX Z\NRQ\ZDQD MHVW LQVWUXNFMD : SU]HFLZQ\P UD]LH Z\NRQ\ZDQD

MHVW LQVWUXNFMD &] ü else MHVW RSFMRQDOQD WM MH OL ]DOH*\ QDP QD Z\NRQDQLX F]HJR Z UD]LH

VSHÆQLHQLD ZDUXQNX L QLFQLHURELHQLX Z UD]LH QLHVSHÆQLHQLD ZDUXQNX Z\VWDUF]\ QDSLVD ü

if(warunek) instrukcja1;

&] VWR E G]LH ]GDU]D ü VL WDN *H LQVWUXNFMD E G( LQVWUXNFMD E G( RE\GZLH E G LQVWUXNFMDPL

]ÆR*RQ\PL

Y – -DFHN ’]LHG]LF )7L06 3ROLWHFKQLND *GD VND jaca@kdm.task.gda.pl

if(warunek) {

instrukcja1a;

instrukcja1b;

instrukcja1c;

}

else {

instrukcja2a;

instrukcja2b;

instrukcja2c;

}

.ODPU\ SHÆQL WX SRGREQ URO MDN NRQVWUXNFMD begin "/" end Z\VW SXM FD Z ZLHOX M ]\NDFK

SURJUDPRZDQLD ,QVWUXNFMH XM WH 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 bool E G( FDÆNRZLWHJR : SLHUZV]\P Z\SDGNX ZDUXQHN

X]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 E G]LH UyZQH

1DOH*\ ]ZUyFL ü XZDJ QD IDNW *H ZDUXQHN GOD LQVWUXNFML if PXVL E\ ü XPLHV]F]RQ\ Z nawiasach. W

EXGRZDQLX 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 4

LI D __ E Z\NRQDM MH OL D UyZQH MHVW lub b równe jest 4

LI 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 QLH

E G]LHP\ VL ]DMPRZD ü -HV]F]H LQQ NRQVWUXNFM ZDUXQNRZ Z\ERUX ZLHORNURWQHJR ]DSHZQLD

instrukcja switch SR RSLV NWyUHM RGV\ÆDP GR OLWHUDWXU\ SHÆQL SRGREQ URO GR case w innych

M ]\NDFK

3 WOH

=D SRPRF S WOL PR*HP\ Z\NRQ\ZD ü SHZQH LQVWUXNFMH ZLHORNURWQLH & RIHUXMH WU]\ URG]DMH

S WOL S WO while S WO do-while L S WO for 6NÆDGQLD SLHUZV]HM ] QLFK MHVW QDVW SXM FD

while(warunek) instrukcja1;

,QVWUXNFMD E G]LH Z\NRQ\ZDQD GRSyW\ GRSyNL VSHÆQLRQ\ E G]LH ZDUXQHN -H OL ZDUXQHN QLH

E G]LH VSHÆQLRQ\ QD G]LH GREU\ SU]HG ZHM FLHP GR S WOL LQVWUXNFMD nie zostanie wykonana

ani razu 3U]\NÆDG\ S WOL ZKLOH

ZKLOH D E D ]ZL NV]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

};

Wstęp do C++ - praktyczne wskazówki ułatwaiające prace.pdf

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika: