Giáo Trình PH NG PHÁP L P TRÌNHGiáo trình PP lp trình TT.Công Ngh Thông Tin 4/127 Ch ng 1 T...

TTRR��NNGG ��II HH��CC CCÔÔNNGG NNGGHHII��PP TTPP//HHCCMM TTRRUUNNGG TTÂÂMM CCÔÔNNGG NNGGHH�� TTHHÔÔNNGG TTIINN

--oo00oo--

GGiiááoo TTrrììnnhh

PPHH��NNGG PPHHÁÁPP LL��PP TTRRÌÌNNHH

TTHHÁÁNNGG 88//22000088

Giáo trình PP l�p trình

TT.Công Ngh� Thông Tin 2/127

MC LC

Ch�ng 1: T�NG QUAN V NGÔN NG� L�P TRÍNH C/C++ ..... 4

1. L�ch s� c�a ngôn ng� l�p trình C/C++ .............................................4 2. Ph��ng pháp � gii quy�t m�t bài toán ..........................................4 3. Các b� c trong chu trình phát trin ch��ng trình ............................5 4. Kho sát m�t ch��ng trình C/C++ ��n gin ....................................7 5. Các chú thích (comments) .................................................................9 6. C�u trúc c�a m�t ch��ng trình C/C++ ...........................................10 7. Các t�p tin th� vi�n thông d�ng ......................................................11

Ch�ng 2: BI�U TH�C....................................................................... 12 1. Kiu d� li�u (data types) ................................................................12 2. Các ��nh danh (Identifier names) ...................................................13 3. T� khóa (keywords) ........................................................................14 4. Bi�n (variables) ..............................................................................14 5. T� khóa const .................................................................................17 6. H�ng (constants) .............................................................................17 7. H�ng chu�i ký t� (string constants) ...............................................18 8. H�ng ký t� ��c bi�t (escape sequences) .........................................18 9. Toán t� (operators) ........................................................................19 10. Các toán t� s� h�c (arithmetic operators) ....................................22 11. Toán t� ++ và -- (increment and decrement operators) ...............23 12. Toán t� quan h� & lu�n lý ...........................................................24 13. Toán t� ? (? operator) ..................................................................26 14. Toán t� sizeof ...............................................................................26 15. Toán t� d�u ph�y (comma operator) ............................................27 16. Biu th�c (expressions) ................................................................29 17. Chuyn ��i kiu trong các biu th�c ............................................29 18. Ép kiu (casting) ...........................................................................30 19. D�ng vi�t t�t c�a câu l�nh gán (shorthand assignments) .............31

Ch�ng 3: CÁC C�U TRÚC �I U KHI�N ..................................... 34 1. Gi i thi�u ........................................................................................34 2. C�u trúc l�a ch�n if ........................................................................35 3. C�u trúc l�a ch�n switch...case ......................................................39 4. Các c�u trúc l�p (Loop structures) ..................................................44 5. Các l�nh r� nhánh và nhy ..............................................................50

Ch�ng 4: M�NG ................................................................................ 61 1. Gi i thi�u Mng ..............................................................................61 2. Mng 1 chi�u ..................................................................................61



3. Mng nhi�u chi�u ...........................................................................64 Ch�ng 5: CON TR� ........................................................................... 71

1. Gi i thi�u Con tr� ...........................................................................71 2. Bi�n con tr� (pointer variables) ......................................................72 3. M�t s� ví d� v� con tr� ...................................................................75 4. C�p phát b� nh ��ng .....................................................................75 5. Con tr� void (void pointers) ...........................................................78 6. Con tr� null (Null pointers) ............................................................79 7. Con tr� và mng .............................................................................80 8. Mng con tr� ...................................................................................81

Ch�ng 6: HÀM ................................................................................... 83 1. Khái ni�m hàm................................................................................83 2. D�ng t�ng quát c�a hàm .................................................................84 3. Các qui t�c v� ph�m vi c�a hàm .....................................................85 4. Tham s� hình th�c và tham s� th�c ................................................85 5. Truy�n mng vào hàm ....................................................................88 6. �i s� c�a hàm main ......................................................................89 7. L�nh return .....................................................................................90 8. � qui .............................................................................................92 9. Nguyên m!u hàm (function prototypes) .........................................93 10. C�u trúc c�a m�t ch��ng trình vi�t d� i d�ng hàm .....................94

Ch�ng 7: CHU�I KÝ T� .................................................................. 96 1. Gi i thi�u Chu�i .............................................................................96 2. Khai báo và kh"i t�o chu�i .............................................................96 3. Nh�p chu�i ......................................................................................97 4. Xu�t chu�i.......................................................................................97 5. M�t s� hàm th� vi�n thao tác trên chu�i ........................................97 6. M�t s� ví d� v� chu�i .....................................................................98 7. Mng các chu�i ...............................................................................99 8. Mng con tr� ��n các chu�i ..........................................................101

Ch�ng 8: STRUCTURES – ENUM - typedef ................................ 105 1. Structures ......................................................................................105 2. Kiu li�t kê (Enumerations, enum) ...............................................111 3. typedef ..........................................................................................112

Ch�ng 9: T�P TIN ........................................................................... 114 1. Streams và Files ............................................................................114 2. Streams (dòng nh�p xu�t) .............................................................114 3. Files ..............................................................................................115 4. Truy xu�t file ng!u nhiên ..............................................................124 5. Các stream chu�n ..........................................................................124



Ch��ng 1

T�NG QUAN V NGÔN NG� L�P TRÌNH C/C++

1. L�ch s� c�a ngôn ng� l�p trình C/C++

C ��#c t�o b"i Dennis Ritchie " Bell Telephone Laboratories vào n$m 1972 � cho phép l�p trình viên phát trin các �ng d�ng hi�u qu h�n các ngôn ng� l�p trình hi�n có t�i th%i �im �ó.

im m�nh và m�m d&o c�a C cho phép các nhà phát trin " Bell Labs t�o nên các �ng d�ng ph�c t�p nh� h� �i�u hành Unix. Vào n$m 1983, h�c vi�n chu�n qu�c gia M' (American National Standards Institute - ANSI) thành l�p m�t tiu ban � chu�n hóa C ��#c bi�t ��n nh� ANSI Standard C. Ngày nay, t�t c trình biên d�ch C/C++ ��u tuân theo ANSI Standard C. C++ ��#c xây d�ng trên n�n tng c�a ANSI Standard C.

C++ là m�t ngôn ng� l�p trình h� ng ��i t�#ng mà bao hàm ngôn ng� C " trong nó. Trong giáo trình này ch�a kho sát ph(n l�p trình h� ng ��i t�#ng c�a C++.

2. Ph�ng pháp �� gi�i quy�t m�t bài toán

M�t ch��ng trình máy tính ��#c thi�t k� � gii quy�t m�t bài toán nào �ó. Vì v�y, nh�ng b� c c(n � tìm ki�m l%i gii cho m�t bài toán c)ng gi�ng nh� nh�ng b� c c(n � vi�t m�t ch��ng trình. Các b� c g*m:

- Xác ��nh yêu c(u c�a bài toán.

- Ngh+ ra m�t ph��ng cách (algorithm) � tìm l%i gii.

- Th�c hi�n ph��ng cách �ó.

- Kim tra k�t qu � xem l%i gii có �úng v i yêu c(u c�a bài toán.



Khi vi�t m�t ch��ng trình trong C/C++, �ây là nh�ng b� c ��#c �� ngh�:

1. Xác ��nh m�c �ích c�a ch��ng trình

2. Ngh+ ra thu�t toán phù h#p � gii quy�t bài toán (dùng mã gi, l�u �*, ...)

3. Cài ��t (vi�t) thu�t toán dùng ngôn ng� l�p trình C/C++

4. Th�c thi ch��ng trình và kim th� (testing).

3. Các b c trong chu trình phát tri�n ch�ng trình

Chu trình phát trin ch��ng trình (program development cycle) có nh�ng b� c sau �ây. 1. M�t trình so�n tho v$n bn ��#c dùng � nh�p mã ngu*n (source code). 2. Mã ngu*n ��#c biên d�ch (compile) � t�o nên t�p tin ��i t�#ng (object file). 3. Các t�p tin ��i t�#ng ��#c liên k�t (link) � t�o nên t�p tin có th th�c thi (executable file). 4. Th�c hi�n (run) ch��ng trình � ch, ra ch��ng trình có làm vi�c �úng nh� �ã ��nh không.

Use editor

Source code

Compile source file

Object code

Link object file

Library files

Executable program

(C-free, Borland C/C++ editor)

(.c; .cpp files)

(bc.exe)

(.h files) (.exe file)



3.1. So!n th�o mã ngu"n (source code editor)

Mã ngu*n là m�t t�p các l�nh dùng � ch, d!n máy tính th�c hi�n công vi�c mong mu�n. T�p tin mã ngu*n ��#c l�u tr� v i ph(n phân lo�i .c (C) ho�c .cpp (C++).

3.2. Biên d�ch (compile)

T�p tin mã ngu*n ��#c vi�t b�ng nh�ng t� gi�ng ti�ng Anh nên d- dàng � ��c và hiu. Tuy nhiên, máy tính không th hiu nh�ng t� này. Máy tính yêu c(u các ch, d!n nh� phân (binary) trong d�ng th�c c�a ngôn ng� máy (machine language). Tr� c khi m�t ch��ng trình ��#c vi�t b�ng ngôn ng� c�p cao nh� C/C++ có th th�c thi trên máy tính, nó phi ��#c biên d�ch t� mã ngu*n sang mã máy. Vi�c d�ch này ��#c th�c hi�n b"i m�t ch��ng trình g�i là trình biên d�ch (compiler).

Các ch, d!n ngôn ng� máy ��#c t�o b"i trình biên d�ch ��#c g�i là mã ��i t�#ng (object code) và t�p tin ch�a chúng g�i là t�p tin ��i t�#ng. T�p tin ��i t�#ng có cùng tên nh� t�p tin mã ngu*n nh�ng có ph(n phân lo�i .obj.

3.3. T!o t�p tin th#c thi (executable files)

C/C++ có m�t th� vi�n hàm ch�a mã ��i t�#ng cho nh�ng hàm �ã ��#c t�o s.n. Nh�ng hàm này th�c hi�n các tác v� th�%ng dùng nh� xóa màn hình (clrscr()), nh�p m�t chu�i ký t� t� bàn phím (gets()), tính c$n b�c hai (sqrt()), ... mà ch��ng trình ��#c vi�t có th s� d�ng mà không phi vi�t l�i.

T�p tin ��i t�#ng ��#c t�o ra b"i trình biên d�ch s� k�t h#p v i mã ��i t�#ng c�a các hàm th� vi�n � t�o nên t�p tin th�c thi. Quá trình này ��#c g�i là liên k�t (linking), ��#c th�c hi�n b"i m�t ch��ng trình g�i là b� liên k�t (linker).



3.4. Th#c thi ch�ng trình

Khi ch��ng trình ngu*n ��#c biên d�ch và liên k�t � t�o nên t�p tin th�c thi (có ph(n phân lo�i .exe), nó có th th�c thi trên máy tính t�i d�u nh�c h� th�ng.

N�u ch��ng trình ho�t ��ng không �úng nh� yêu c(u, v�n �� có th là do l�i l�p trình. Trong tr�%ng h#p này, ch,nh s�a ch��ng trình ngu*n, biên d�ch l�i và liên k�t l�i � t�o nên phiên bn m i c�a t�p tin ch��ng trình.

Quá trình b�n b� c này ��#c l�p �i l�p l�i cho ��n khi t�p tin th�c thi th�c hi�n �úng yêu c(u c�a bài toán.

4. Kh�o sát m�t ch�ng trình C/C++ ��n gi�n Kho sát m�t ch��ng trình ��n gin dùng � xu�t ra màn hình dòng ch� Hello World! // my first program in C/C++ #include <conio.h> #include <iostream.h> int main() { cout << "Hello World!"; //Output “Hello World!”

getche(); return 0; }

ây là ch��ng trình ��n gin nh�ng nó �ã bao hàm nh�ng thành ph(n c� bn mà m�i ch��ng trình C/C++ ��u có. V i ý ngh+a c�a t�ng dòng nh� sau:

// my first program in C/C++

ây là dòng chú thích, t�t c các dòng b�t �(u b�ng hai d�u // ��#c coi là các dòng chú thích, nó không nh h�"ng ��n ho�t ��ng c�a ch��ng trình, ch, dùng � gii thích mã ngu*n c�a ch��ng trình.



#include <iostream.h>

Các l�nh b�t �(u b�ng d�u # ��#c dùng cho các ch, th� ti�n x� lý (preprocessor). Trong ví d� này, câu l�nh #include báo cho trình biên d�ch bi�t c(n phi g�p th� vi�n iostream.h là t�p tin header chu�n c�a C/C++, ch�a các ��nh ngh+a v� nh�p và xu�t.

int main()

�nh ngh+a hàm main(). Hàm main() là �im mà t�t c các ch��ng trình C/C++ b�t �(u th�c hi�n. Nó không ph� thu�c vào v� trí c�a hàm, n�i dung c�a nó luôn ��#c th�c hi�n �(u tiên khi ch��ng trình th�c thi. M�t ch��ng trình C/C++ ��u phi t*n t�i m�t hàm main(). Hàm main() có th có ho�c không có tham s�. N�i dung c�a hàm main() ti�p ngay sau ph(n khai báo chính th�c ��#c ��t trong c�p d�u ngo�c { }.

cout << "Hello World!";

ây là m�t l�nh n�m trong ph(n thân c�a hàm main. cout là m�t dòng (stream) xu�t chu�n trong C/C++ ��#c ��nh ngh+a trong th� vi�n iostream.h. Khi dòng l�nh này ��#c th�c thi, k�t qu là chu�i "Hello World!" ��#c xu�t ra màn hình. Dòng l�nh ��#c k�t thúc b�ng d�u ch�m ph�y (;).

getche();

ây là m�t hàm th� vi�n dùng � ch% nh�p m�t ký t� t� bàn phím.

return 0;

L�nh return k�t thúc hàm main và tr v� giá tr� biu th�c �i sau nó, trong tr�%ng h#p này là 0. ây là m�t k�t thúc bình th�%ng c�a m�t ch��ng trình không có l�i trong quá trình th�c hi�n.

Ch��ng trình trên có th vi�t l�i nh� sau: int main() { cout << " Hello World! "; getch(); return 0;}

c)ng cho cùng m�t k�t qu.



5. Các chú thích (comments) Các chú thích ��#c các l�p trình viên s� d�ng � ghi chú hay mô t trong các ph(n c�a ch��ng trình. Trong C/C++ có hai cách � chú thích:

Chú thích dòng: dùng c�p d�u //. T� v� trí // ��n cu�i dòng ��#c xem là chú thích

Chú thích kh�i (chú thích trên nhi�u dòng) dùng c�p /* ... */. Nh�ng gì n�m gi�a c�p d�u này ��#c xem là chú thích.

Ví d�: /* My second program in C/C++ with more comments Author: Novice programmer Date: 01/01/2008 */ #include <conio.h> #include <iostream.h> int main() { cout << "Hello World! "; // output Hello World! cout << "I hate C/C++."; // output I hate C/C++. getche(); return 0; }

K�t qu� xu�t c�a ch��ng trình là: Hello World! I hate C/C++.



6. C$u trúc c�a m�t ch�ng trình C/C++ C�u trúc m�t ch��ng trình C/C++ bao g*m các thành ph(n nh�: Các ch, th� ti�n x� lý, khai báo bi�n toàn c�c, ch��ng trình chính (hàm main), ...

Kho sát ch��ng trình sau:

/* fact.c Purpose: prints the factorials of the numbers from 0 through 10 Author: Mr.Beginner Date: 01/01/2008 */


int factorial(int n);

int main() { int i; for(i=0; i<=10; i++) cout<<i<<“!=“<<factorial(i); return 0; }

/* This function computes the factorial of its parameter, returning it */ int factorial(int n) { int i, product; product = 1; for (i=2;i<=n;i++) prod *= i; return product; }

Ph�n này th�ng dùng � mô t� m�c ính ch��ng trình, tác gi�, ngày vi t, ... (Ph�n không b�t bu�c)

Khai báo các t�p tin th� vi�n

Khai báo prototype c�a các hàm t� t�o

Hàm chính c�a ch��ng trình

��nh ngh�a các hàm do ng�i dùng t� xây d�ng



7. Các t�p tin th vi%n thông d&ng ây là các t�p tin ch�a ��nh ngh+a các hàm thông d�ng khi l�p trình C/C++. Mu�n s� d�ng các hàm trong các t�p tin header này thì phi khai báo #include <FileName.h> " ph(n �(u c�a ch��ng trình, v i FileName.h là tên t�p tin th� vi�n. Các t�p tin th� vi�n thông d�ng g*m:

stdio.h(C), iostream.h(C++) T�p tin ��nh ngh+a các hàm vào/ra chu�n (standard input/output) g*m các hàm xu�t d� li�u (printf())/cout), nh�p giá tr� cho bi�n (scanf())/cin), nh�n ký t� t� bàn phím (getc()), in ký t� ra màn hình (putc()), nh�p m�t chu�i ký t� t� bàm phím (gets()), xu�t chu�i ký t� ra màn hình (puts()), xóa vùng ��m bàn phím (fflush()), fopen(), fclose(), fread(), fwrite(), getchar(), putchar(), ...

conio.h : T�p tin ��nh ngh+a các hàm vào ra trong ch� �� DOS (DOS console) g*m các hàm clrscr(), getch(), getche(), getpass(), cgets(), cputs(), putch(), clreol(), …

math.h: T�p tin ��nh ngh+a các hàm toán h�c g*m các hàm abs(), sqrt(), log(), log10(), sin(), cos(), tan(), acos(), asin(), atan(), pow(), exp(), …

alloc.h: T�p tin ��nh ngh+a các hàm liên quan ��n vi�c qun lý b� nh g*m các hàm calloc(), realloc(), malloc(), free(), farmalloc(), farcalloc(), farfree(), …

io.h: T�p tin ��nh ngh+a các hàm vào ra c�p th�p g*m các hàm open(), _open(), read(), _read(), close(), _close(), creat(), _creat(), creatnew(), eof(), filelength(), lock(), …



Ch��ng 2 BI�U TH�C (Expressions)

Biu th�c ��#c t�o thành t� nh�ng thành t� nh� d� li�u và toán t�. D� li�u có th ch�a trong bi�n ho�c h�ng. Toán t� trong các ngôn ng� l�p trình có cùng ý ngh+a nh� trong toán h�c. Có nhi�u lo�i toán t� nh� toán t� gán (=), toán t� s� h�c (+ - * / %), toán t� quan h� (== < <= > >= !=), toán t� lu�n lý (&& || !), ...

1. Ki�u d� li%u (data types) C/C++ có n$m kiu d� li�u c� s": ký t� (char), s� nguyên (int), s� th�c (float), s� th�c có �� chính xác g�p �ôi (double), và kiu vô ��nh (void). T�t c nh�ng kiu d� li�u khác ��u d�a trên 5 kiu c� s" này. Kích th� c và ph�m vi c�a nh�ng kiu d� li�u này có th thay ��i tùy theo lo�i CPU và trình biên d�ch.

Kiu char ��#c dùng � gi� các giá tr� c�a b� mã ASCII (Amercican Standard Code for Information Interchange). Kiu char chi�m 1 byte b� nh .

Kích th� c c�a kiu int là 16 bits (2 bytes) trên môi tr�%ng 16-bit nh� DOS, Windows 3.1. Môi tr�%ng 32-bit nh� Windows 95, kích th� c kiu int là 32 bits (4 bytes). Nói chung, tùy thu�c môi tr�%ng, kích th� c c�a kiu int có th khác nhau.

Chu�n C ch, ra ph�m vi t�i thiu c�a kiu d� li�u s� th�c (float, double) là 1E-37 ��n 1E+37.

Kiu void dùng � khai báo hàm không tr v� giá tr� ho�c t�o nên các con tr� t�ng quát (generic pointers).

Ngo�i tr� kiu void, các kiu d� li�u c� s" có th có các t� nh� signed, unsigned, long, short �i tr� c nó. Các t� này làm thay ��i ph�m vi t�i thiu m�i kiu c� s" có th ch�a. Bng sau trình bày t�t c các k�t h#p h#p l� c�a kiu d� li�u v i các t� trên.



Ki�u d� li%u Kích th c b'ng bits Ph!m vi t(i thi�u

char 8 -127 to 127 unsigned char 8 0 to 255 signed char 8 -127 to 127 int 16 or 32 -32,767 to 32,767 unsigned int 16 or 32 0 to 65,535 signed int 16 or 32 gi�ng nh� int short int ho�c short 16 -32,767 to 32,767 unsigned short int 16 0 to 65,535 signed short int 16 gi�ng nh� short int long int ho�c long 32 -2,147,483,647 to 2,147,483,647 signed long int 32 gi�ng nh� long int unsigned long int 32 0 to 4,294,967,295 float 32 � chính xác là 6 ký s� double 64 � chính xác là 10 ký s� long double 80 � chính xác là 10 ký s�

2. Các ��nh danh (Identifier names) Trong C/C++, tên c�a các bi�n, h�ng, hàm,... ��#c g�i là ��nh danh. Nh�ng ��nh danh này có th là 1 ho�c nhi�u ký t�. Ký t� �(u tiên phi là m�t ch� cái ho�c d�u _ (underscore), nh�ng ký t� theo sau phi là ch� cái, ch� s�, ho�c d�u _. Sau �ây là nh�ng ��nh danh �úng và sai: �úng Sai count 1count test23 hi!there

high_balance high...balance

C/C++ phân bi�t ký t� HOA và th�%ng. Vì v�y, count, Count, và COUNT là 3 danh ��nh khác nhau.



�nh danh không ��#c trùng v i các t� khóa (keywords) và không nên có cùng tên nh� các hàm th� vi�n c�a C/C++.

3. T) khóa (keywords) Là nh�ng t� �ã ��#c dành riêng b"i ngôn ng� l�p trình cho nh�ng m�c �ích riêng c�a nó. Không ��#c dùng t� khóa � ��t tên cho nh�ng ��nh danh nh� bi�n, h�ng, hàm, ... T�t c các t� khóa trong C/C++ ��u là ch� th�%ng (lowercase). Sau �ây là danh sách các t� khóa c�a C/C++: auto break case char const continue default do double else enum extern float for goto if int long register return short signed sizeof static struct switch typedef union unsigned void volatile while

4. Bi�n (variables) M�t bi�n là ��nh danh c�a m�t vùng trong b� nh dùng � gi� m�t giá tr� mà có th b� thay ��i b"i ch��ng trình. T�t c bi�n phi ��#c khai báo tr� c khi ��#c s� d�ng. D�ng khai báo bi�n t�ng quát là:

type variableNames;

type: phi là m�t trong các kiu d� li�u h#p l�.

variableNames: tên c�a m�t hay nhi�u bi�n phân cách nhau b"i d�u ph�y.

Ngoài ra, ta có th v�a khai báo v�a kh"i t�o giá tr� ban �(u cho các bi�n dùng cú pháp sau:

type varName1=value, ... , varName_n=value;

Ví d�: int i, j; // khai báo 2 bi�n i, j ki�u int

// khai báo ba bi�n day, month và year ki�u short int

short day, month, year;



char ch; // khai báo bi�n ch ki�u ký t�

// khai bao 4 bien kieu float, gán average giá tr� 0

float mark1, mark2, mark3, average = 0;

L�u ý: Khi khai báo bi n n u không cung c�p giá tr� kh�i t�o thì giá tr� c�a bi n là ch�a xác �nh. Do ó, vi�c dùng nh�ng bi n này trong các bi�u th�c là vô ngh�a.

Bi�n ��#c khai báo t�i ba n�i: bên trong hàm, trong ��nh ngh+a tham s� c�a hàm, và bên ngoài t�t c hàm. Nh�ng bi�n này ��#c g�i l(n l�#t là bi�n c�c b�, các tham s� hình th�c, và bi�n toàn c�c.

4.1. Bi�n c&c b� (local variables) Nh�ng bi�n ��#c khai báo bên trong m�t hàm g�i là bi�n c�c b�. Các bi�n c�c b� ch, ��#c tham chi�u ��n ch, b"i nh�ng l�nh n�m trong kh�i (block) có khai báo bi�n. M�t kh�i b�t �(u v i d�u { và k�t thúc v i d�u }.

Bi�n c�c b� ch, t*n t�i trong khi kh�i ch�a nó �ang th�c thi và b� h�y khi kh�i ch�a nó th�c thi xong.

Ví d�: Xem xét hai hàm sau: void func1(void) {

int x; x = 10;

} void func2(void) {

int x; x = -199;

}

Bi�n nguyên x ��#c khai báo 2 l(n, m�t trong hàm func1() và m�t trong hàm func2(). Bi�n x trong func1() không có quan h� gì v i bi�n x trong func2() b"i vì m�i x ch, t*n t�i trong kh�i ch�a nó.



4.2. Các tham s( hình th*c (formal parameters) N�u m�t hàm có nh�n các ��i s� truy�n vào hàm thì nó phi khai báo các bi�n � nh�n giá tr� c�a các ��i s� khi hàm ��#c g�i. Nh�ng bi�n này g�i là các tham s� hình th�c. Nh�ng bi�n này ��#c ��i x� gi�ng nh� các bi�n c�c b� khác ��#c khai báo trong hàm. Xem xét ví d� sau: int sum(int from, int to)

{

int total=0;

for(int i=from ; i<=to ; i++) total +=i;

return total;

}

Trong ví d� này, from và to là 2 tham s� hình th�c và ��#c ��i x� nh� bi�n c�c b� total c�a hàm sum. L�u ý bi�n i ��#c khai báo trong c�u trúc l�p for nên nó là bi�n c�c b� ch, t*n t�i trong c�u trúc for mà thôi. Nh�ng l�nh n�m ngoài c�u trúc for s� không tham chi�u ��#c bi�n i này.

4.3. Bi�n toàn c&c (global variables) Bi�n toàn c�c có ph�m vi là toàn b� ch��ng trình. Do �ó, t�t c các l�nh có trong ch��ng trình ��u có th tham chi�u ��n bi�n toàn c�c. Bi�n toàn c�c ��#c khai báo bên ngoài t�t c hàm.

Kho sát ch��ng trình sau: #include <iostream.h> void increase(); void decrease(); int gVar = 100; void main() { cout << “Value of gVar= “ << gVar; increase(); cout << “\nAfter increased, gVar= “ << gVar; decrease(); cout << “\nAfter decreased, gVar= “ << gVar; } void increase() { gVar = gVar + 1;}



void decrease() { gVar = gVar -1;}

Sau khi th�c thi ch��ng trình trên, k�t qu xu�t trên màn hình là:

Value of gVar= 100

After increased, gVar= 101;

After decreased, gVar= 100;

5. T) khóa const Giá tr� c�a bi�n có th thay ��i trong su�t quá trình th�c thi ch��ng trình. giá tr� c�a bi�n không b� thay ��i, ta ��t tr� c khai báo bi�n t� khóa const. T� khi bi�n �ã có giá tr�, giá tr� này s� không bao gi% b� thay ��i b"i b�t k/ l�nh nào trong ch��ng trình. Thông th�%ng ta dùng ch� HOA � ��t tên cho nh�ng bi�n này.

Ví d�: khai báo h�ng nguyên MAX có giá tr� 100 const int MAX = 200;

6. H'ng (constants) H�ng là nh�ng giá tr� c� ��nh (fixed values) mà ch��ng trình không th thay ��i. B�t k/ kiu d� li�u nào c)ng có h�ng t��ng �ng. H�ng còn ��#c g�i là literals.

H�ng ký t� ��#c bao quanh b"i c�p d�u nháy ��n. Ví d� 'a' và '%' là nh�ng h�ng ký t�.

H�ng nguyên là nh�ng s� mà không có ph(n th�p phân. Ví d� 100 và -100 là nh�ng h�ng nguyên.

H�ng s� th�c yêu c(u m�t d�u ch�m th�p phân phân cách ph(n nguyên v i ph(n th�p phân. Ví d� 123.45 là m�t h�ng s� th�c.

Ví d� v� cách vi�t các lo�i h�ng s�:

Ki�u d� li%u Các ví d& v+ h'ng Ghi chú int 1, 123, 21000, 234 long int 35000L, 34l Có ký t� l ho�c L " cu�i unsigned int 10000U, 987u, 40000U Có ký t� u ho�c U " cu�i float 123.23f, 4.34e-3F Có ký t� f ho�c F " cu�i double 123.23, 1.0, 0.9876324

long double 1001.2L Có ký t� l ho�c L " cu�i



7. H'ng chu,i ký t# (string constants) C/C++ cung c�p m�t l�ai h�ng khác g�i là chu�i. M�t chu�i là m�t t�p các ký t� ��#c bao quanh b"i c�p d�u nháy �ôi.

Ví d�, "This is a string" là m�t chu�i.

L�u ý phân bi�t h�ng chu�i và h�ng ký t�. M�t h�ng ký t� là m�t ký t� bao quanh b"i c�p d�u nháy ��n. Do �ó, 'a' là h�ng ký t� nh�ng "a" là h�ng chu�i.

8. H'ng ký t# �-c bi%t (escape sequences) C/C++ có nh�ng h�ng ký t� ��c bi�t mà không th biu di-n nh� nh�ng h�ng ký t� thông th�%ng. Nh�ng h�ng này còn g�i là escape sequences. Sau �ây là danh sách các h�ng ��c bi�t �ó:

Mã Ý ngh.a \b Lùi sang trái 1 ký t� \f V� �(u dòng \n Sang dòng m i \r Xu�ng dòng \t Tab theo chi�u ngang \" D�u nháy �ôi \' D�u nháy ��n \0 Null \\ D�u \ \v Tab theo chi�u ��ng \a Cnh báo \? D�u h�i \N H�ng bát phân (v i N là m�t h�ng bát phân) \xN H�ng th�p l�c phân (v i N là m�t h�ng th�p l�c phân)

Xem xét ví d� sau: #include <iostream.h> void main(void) { cout <<"Items:\n"; cout <<”\tItem1\n”; cout <<”\tItem2\n”; cout <<”\tItem3\n”;

}

Items: Item1 Item2 Item3

output

\n

\t tab

Enter



9. Toán t� (operators) C/C++ có b�n lo�i toán t�: s� h�c (arithmetic), quan h� (relational), lu�n lý (logical), và toán t� trên bit (bitwise).

9.1. Toán t� gán (assignment operator) D�ng t�ng quát c�a toán t� gán là

variableName = expression;

variableName: Tên bi�n

expression: Biu th�c

L�u ý, phía bên trái d�u b�ng phi là m�t bi�n hay con tr� và không th là hàm hay h�ng.

Ví d�: total = a + b + c + d;

9.2. Chuy�n �/i ki�u trong câu l%nh gán Khi nh�ng bi�n c�a m�t kiu k�t h#p v i nh�ng bi�n c�a m�t kiu khác thì m�t s� chuyn ��i kiu xy ra. �i v i câu l�nh gán, giá tr� c�a biu th�c bên phi d�u b�ng ��#c t� ��ng chuyn thành kiu d� li�u c�a bi�n bên trái d�u b�ng.

Ví d�: int i=100;

double d = 123.456;

N�u th�c thi l�nh i = d;

thì i s� có giá tr� là 123 vì 123.456 s� t� ��ng chuyn thành s� nguyên nên b� c�t b� ph(n th�p phân. S� chuyn ��i kiu này g�i là chuyn ��i kiu b� m�t mát thông tin.

N�u th�c thi l�nh



d = i;

thì d s� có giá tr� là 100.0. S� chuyn ��i kiu này g�i là chuyn ��i kiu không m�t mát thông tin.

Tóm l�i, khi chuyn ��i kiu t� kiu d� li�u có mi�n giá tr� nh� sang kiu d� li�u có mi�n giá tr� l n h�n thì vi�c chuyn ��i kiu này là an toàn vì không b� m�t mát thông tin. Th� t� t$ng d(n t� kiu d� li�u có mi�n giá tr� nh� ��n kiu d� li�u có mi�n giá tr� l n là char �� int �� long �� float �� double.

Khi chuyn ��i kiu d� li�u có mi�n giá tr� l n sang kiu d� li�u có mi�n giá tr� nh� h�n thì vi�c chuyn ��i kiu này là không an toàn vì có th m�t mát thông tin. Th� t� gim d(n t� kiu d� li�u có mi�n giá tr� l n ��n kiu d� li�u có mi�n giá tr� nh� là double �� float �� long �� int �� char.

Ví d�: int i = 100;

long l = 200;

float f = 123.456f;

double d = 1.23456789;

Kho sát các l�nh gán sau: int n; long m; float p; double q;

n = i + l + f + d; // (1)

m = i + l + f + d; // (2)

p = i + l + f + d; // (3)

q = i + l + f + d; // (4)



100 200 123.456 1.23456789

i l f d

double double double double 100.0 200.0 123.456 1.23456789

424.69056789

int n có giá tr� là 424

(1)

100 200 123.456 1.23456789

i l f d


424.69056789

float p có giá tr� là 424.690567

(3)



K�t lu�n: Tr�%ng h#p (1) và (3): m�t mát thông tin. Tr�%ng h#p (4) không m�t mát thông tin.

10. Các toán t� s( h0c (arithmetic operators) Các toán t� s� h�c g*m: + (c�ng), - (tr�), * (nhân), / (chia), và % (l�y ph(n d� c�a phép chia nguyên).

Khi t� s� và m!u s� c�a phép chia là s� nguyên thì �ó là phép chia nguyên nên ph(n d� c�a phép chia nguyên b� c�t b�. Ví d�, 5/2 thì k�t qu là 2.

Toán t� l�y ph(n d� % (modulus operator) ch, áp d�ng v i s� nguyên và tr v� ph(n d�. Ví d�, 7%2 thì k�t qu là 1.

100 200 123.456 1.23456789

i l f d


424.69056789

q có giá tr� là 424.69056789

(4)



11. Toán t� ++ và -- (increment and decrement operators)

C/C++ có hai toán t� r�t th�%ng dùng là ++ và --. Toán t� ++ c�ng 1 ��n toán h�ng c�a nó và toán t� -- thì tr� 1 t� toán h�ng c�a nó.

Ví d�: x++; // tuong duong x = x + 1;

x--; // tuong duong x = x - 1;

Toán t� ++ và -- có th ��t phía tr� c (prefix) ho�c phía sau (postfix) toán h�ng. S� khác nhau c�a 2 tr�%ng h#p này là khi toán t� ++ và -- ��ng tr� c toán h�ng, hành ��ng t$ng và gim trên toán h�ng ��#c th�c hi�n tr� c, sau �ó giá tr� m i c�a toán h�ng s� dùng � tham gia vào vi�c ��nh tr� c�a biu th�c.

Ví d�: Kho sát �o�n l�nh sau int x = 100;

int n,m;

N�u th�c hi�n l�nh: n = ++x + 1; // n s� có giá tr� là 102 (1)

N�u th�c hi�n l�nh: n = x++ + 1; // n s� có giá tr� là 101 (2)

Sau khi l�nh (1) hay (2) ��#c th�c thi xong thì x có giá tr� là 101

T��ng t�, n�u th�c hi�n l�nh: m = --x + 1; // n s� có giá tr� là 100 (3)

N�u th�c hi�n l�nh: m = x-- + 1; // n s� có giá tr� 101 (4)



Sau khi l�nh (3) hay (4) ��#c th�c thi thì x có giá tr� là 99

Khi các toán t� s� h�c xu�t hi�n trong m�t biu th�c, thì �� u tiên th�c hi�n nh� sau:

Cao nh�t ++ – – – (d�u âm) * / % Th�p nh�t + – Nh�ng toán t� trên cùng hàng thì có cùng �� u tiên. Khi biu th�c có nhi�u toán t� có cùng �� u tiên thì th� t� ��nh tr� biu th�c là t� trái sang phi.

12. Toán t� quan h% & lu�n lý (relational & logical operators) Toán t� quan h� liên quan ��n s� quan h� c�a hai giá tr�. Toán t� lu�n lý liên quan ��n s� n�i k�t c�a nh�ng quan h�.

Các biu th�c mà dùng toán t� quan h� và toán t� lu�n lý ��#c ��nh tr� là true (�úng) ho�c false(sai). Trong C/C++, giá tr� 0 (zero) ��#c xem là false và giá tr� khác 0 (non-zero) ��#c xem là true.

Các toán t� quan h� g*m:

Toán t� Ý ngh.a > L�n h�n >= L�n h�n hay b�ng < Nh h�n <= Nh h�n hay b�ng == B�ng (có 2 du =) != Không b�ng

Ví d� v� toán t� quan h�:

100 < 200 // true

200 == 300 // false

300 != 400 // true



400 >= 500 // false

Các toán t� lu�n lý:

Operator Action Ý ngh.a && AND Và || OR Ho�c (có 2 du |) ! NOT Ph� �nh

Bng chân tr� c�a các toán t� lu�n lý

p q p && q p || q !p 0 0 0 0 1 0 1 0 1 1 1 1 1 1 0 1 0 0 1 0

C hai toán t� quan h� và lu�n lý có �� u tiên th�p h�n toán t� s� h�c. Trong m�t biu th�c có th có nhi�u lo�i toán t�, th� t� � ��nh tr� biu th�c d�a vào �� u tiên c�a toán t�. thay ��i th� t� ��nh tr� trong m�t biu th�c, dùng c�p d�u ngo�c ��n () nh� trong các biu th�c s� h�c.

� �u tiên c�a toán t� quan h� và lu�n lý:

Cao nh$t ! > >= < <= == != && Th$p nh$t || Ví d�: biu th�c (10>9 && 8!=7) || (6<=5 || 5>4) ��#c ��nh tr� nh� sau:

(10>9 && 8!=7) && (6<=5 || 5>4)

1 1 0 1

1 1

1



K�t qu ��nh tr� biu th�c trên là 1 (true).

13. Toán t� ? (? operator) Toán t� ? là m�t toán t� ba ngôi do �ó có ba toán h�ng. D�ng t�ng quát c�a toán t� ? là:

Exp1 ? Exp2 : Exp3;

Exp1, Exp2, và Exp3 là các biu th�c.

Toán t� ? làm vi�c nh� sau: (u tiên Exp1 ��#c ��nh tr�. N�u k�t qu là true thì Exp2 ��#c ��nh tr� và giá tr� c�a nó tr" thành giá tr� c�a c biu th�c. N�u Exp1 là false thì Exp3 ��#c ��nh tr� và giá tr� c�a nó tr" thành giá tr� c�a c biu th�c.

Ví d�: x = 10;

y = x>9 ? 100*x : 200*x;

Vì x>9 là true nên giá tr� c�a biu th�c s� là 100*x. V�y y s� có giá tr� là 1000

14. Toán t� sizeof sizeof là toán t� m�t ngôi mà tr v� s� byte c�a kiu d� li�u chi�m trong b� nh . M�i môi tr�%ng (h� �i�u hành, lo�i CPU, ...) dùng s� byte khác nhau cho m�i kiu d� li�u. D�ng t�ng quát c�a toán t� sizeof

sizeof(operand)

operand: có th là tên kiu d� li�u, bi�n, biu th�c.

Ví d� sau cho bi�t s� byte c�a m�i kiu d� li�u #include <iostream.h> void main(void) { cout <<"Size of data types:\n"; cout <<"Size of char = " << sizeof(char) << “ bytes\n”; cout <<"Size of unsigned char = " << sizeof(unsigned char) << “ bytes\n”; cout <<"Size of signed char = " << sizeof(signed char) << “ bytes\n”; cout <<"Size of int = " << sizeof(int) << “ bytes\n”; cout <<"Size of unsigned int = " << sizeof(unsigned int) << “ bytes\n”; cout <<"Size of signed int = " << sizeof(signed int) << “ bytes\n”; cout <<"Size of short = " << sizeof(short) << “ bytes\n”;



cout <<"Size of unsigned short = " <<sizeof(unsigned short)<< “ bytes\n”; cout <<"Size of signed short = " << sizeof(signed short) << “ bytes\n”; cout <<"Size of long = " << sizeof(long) << “ bytes\n”; cout <<"Size of unsigned long = " << sizeof(unsigned long) << “ bytes\n”; cout <<"Size of signed long = " << sizeof(signed long) << “ bytes\n”; cout <<"Size of float = " << sizeof(float) << “ bytes\n”; cout <<"Size of double = " << sizeof(double) << “ bytes\n”; cout <<"Size of long double = " << sizeof(long double) << “ bytes\n”;

}

K�t qu khi th�c hi�n ch��ng trình trên:

15. Toán t� d$u ph1y (comma operator) Toán t� comma bu�c các biu th�c cùng v i nhau. Biu th�c bên trái c�a toán t� comma luôn luôn ��#c ��nh tr� nh� void, biu th�c bên phi ��#c ��nh tr� và tr" thành giá tr� c�a biu th�c. D�ng t�ng quát c�a toán t� comma:

(exp1, exp2, ..., expN)

Các biu th�c ��#c ��nh tr� t� trái sang phi, biu th�c cu�i cùng (expN) ��#c ��nh tr� và tr" thành giá tr� c�a toàn b� biu th�c.

Ví d�: x = (y=3, y+1);

(u tiên y ��#c gán giá tr� 3 và r*i x ��#c gán giá tri y+1 là 4.



B�ng tóm t2t �� u tiên c�a các toán t� Cao nh�t () [] -> . ! ~ ++ –– (type) * & sizeof * / % + - << >> < <= > >= == != & ^ | && || ?: = += -= *= /= %= Th�p nh�t ,



16. Bi�u th*c (expressions) M�t biu th�c trong C/C++ là s� k�t h#p c�a các thành ph(n nh� toán t�, h�ng, bi�n, và hàm có tr v� giá tr�.

Th� t� ��nh tr� c�a biu th�c tùy thu�c vào �� u tiên c�a các toán t�. Do �ó, � vi�t biu th�c rõ ràng và th�c hi�n vi�c ��nh tr� �úng theo yêu c(u c�a l�p trình viên ta nên dùng c�p d�u ngo�c tròn () � bao quanh các biu th�c con c�a biu th�c.

Ví d�: �nh tr� biu th�c sau: result = x * y - z % 10 + w/2;

vi�t l�i biu th�c trên rõ ràng d- ��c và th�c hi�n nh� mong mu�n, ta vi�t: result = (x * y) – (z % 10) + (w/2);

17. Chuy�n �/i ki�u trong các bi�u th*c Khi các h�ng và bi�n c�a nh�ng kiu khác nhau t*n t�i trong m�t biu th�c, giá tr� c�a chúng phi ��#c chuyn thành cùng kiu tr� c khi các phép toán gi�a chúng ��#c th�c hi�n. Trình biên d�ch s� th�c hi�n vi�c chuyn kiu (convertion) t� ��ng ��n kiu c�a toán h�ng có kiu l n nh�t. Vi�c chuyn kiu này g�i là th$ng c�p kiu (type promotion).

Ví d�: char ch;

result = x * y - z % 10 + w/2

1 2 3

4

5

6



int i; float f; double d;

18. Ép ki�u (casting) Casting dùng � ép m�t biu th�c thành m�t kiu theo ý mu�n c�a l�p trình viên. D�ng t�ng quát c�a casting là

(type)expression ho�c type(expression)

type: là tên m�t kiu d� li�u h#p l�.

Ví d�: float result;

result = 7/2;

Do 7/2 là phép chia nguyên nên k�t qu không có ph(n th�p phân. Sau l�nh trên result có giá tr� là 3.

phép chia trên là phép chia s� th�c dù r�ng toán h�ng có kiu nguyên ta th�c hi�n ép kiu t� s� ho�c m!u s� ho�c c hai. Các cách vi�t sau s� cho cùng k�t q�a:

result = (ch/i) + (f*d) – (f+i);

int double float

int double float

double

double

double



result = (float)7/2;

result = 7/(float)2;

result = (float)7/(float)2;

result = float(7)/float(2);

Nh� v�y, trong các l�nh trên, ta �ã ép m�t ho�c hai toán h�ng ��n kiu float. Do �ó, � ��nh tr� biu th�c, toán h�ng kia s� ��#c th$ng c�p (type promotion) thành kiu float t��ng �ng � th�c hi�n phép chia sau �ó. K�t qu c�a 4 l�nh trên là t��ng ��ng và result s� có giá tr� là 3.5

19. D!ng vi�t t2t c�a câu l%nh gán (shorthand assignments) Các d�ng vi�t t�t c�a câu l�nh gán v i các toán t� s� h�c g*m +=, -=, *=, /=, và %=. Nh�ng l�nh có d�ng:

variable = variable operator expression;

variable: Tên bi�n

operator: Toán t� s� h�c (+, -, *, /, %)

expression: Biu th�c

có th ��#c vi�t d� i d�ng ng�n g�n h�n nh� sau: variable operator= expression;

Ví d�:

x = x + 10; � x += 10;

x = x – 10; � x -= 10;

x = x * 10; � x *= 10;

x = x / 10; � x /= 10;

x = x % 10; � x %= 10;



Bài t�p Ch�ng 2

1. Nh�p bán kính ��%ng tròn r. Tính và xu�t chu vi, di�n tích ��%ng tròn t��ng �ng.

HD: cv=2*π*r và dt=π*r2

2. Nh�p c�nh a. Tính và xu�t chu vi, di�n tích hình vuông.

HD: cv=4*a và dt=a2

3. Nh�p c�nh a,b. Tính và xu�t chu vi, di�n tích hình ch� nh�t.

HD: cv=2*(a+b) và dt=a*b

4. Nh�p c�nh a,h1,h2. Tính và xu�t chu vi, di�n tích hình thoi.

HD: cv=4*a và dt=1.0/2*h1*h2

5. Nh�p c�nh a,b,c,d,h. Tính và xu�t chu vi, di�n tích hình thang.

HD: cv=(a+b+c+d) và dt=1.0/2*h*(a+b)

6. Nh�p c�nh a,b,c. Tính và xu�t chu vi, di�n tích hình tam giác.

HD: cv=a+b+c và dt= )(*)(*)(* cpbpapp −−− v i p=cv/2

7. Nh�p vào hai s� nguyên d��ng a,b. Tính và xu�t t�ng, hi�u, tích, th��ng.

8. Nh�p 2 s� nguyên a,b. Tính và xu�t ab.

HD: dùng hàm pow(x,y) �� xy

9. Nh�p 1 s� n. Tính và xu�t giá tr� tuy�t ��i.

HD: dùng hàm abs(a) �� |a| 10. Nh�p 1 s� n. Tính và xu�t c$n b�c hai c�a n.

HD: dùng hàm sqrt(a) �� a

11. Nh�p 1 góc x. Tính và xu�t sinx, cosx, tgx, cotgx.

HD: các hàm sin, cos, tan ch, tính theo ��n v� radian nên chúng ta phi ��i t� �� x sang �� radian t nh� sau: t=x*π/180 => sinx=sin(t), cosx=cos(t), tgx=tan(t), cotgx=1/tgx

12. Nh�p to� �� 2 �im A(xA,yA), B(xB,yB). Tính và xu�t �� dài �o�n AB.



HD: |AB|=dAB= ))()( 22ABAB yyxx −+−

13. Nh�p to� �� 2 �im A(xA,yA), B(xB,yB). Tính h� s� góc c�a ��%ng th0ng �i qua hai �im �ó theo công th�c:

H� s� góc = (yB - yA) /(xB - xA)

14. Vi�t ch��ng trình nh�p vào s� nguyên n và s� th�c x. Tính và in ra biu th�c nn xxxxA )1()1( 22 +−+++=

15. Nh�p vào s� giây b�t k/ t. Tính và xu�t ra d�ng Gi3:Phút:Giây

Ví d�: Nh�p 3750 thì xu�t ra 1:2:30 AM 16. Nh�p 51100 thì xu�t ra 2:11:40 PM

HD: hour=(t/3600)%24

minute=(t%3600)/60

second=(t%3600)%60

17. Vi�t ch��ng trình nh�p vào ngày, tháng, n$m. In ra ngày tháng n$m theo d�ng dd/mm/yy. (dd: ngày, mm: tháng, yy : n$m. Ví d�: 20/11/08 )

18. Vi�t ch��ng trình tính logax v i a, x là các s� th�c nh�p vào t� bàn phím, và x>0, a>0, a != 1( dùng logax=lnx/lna)

19. Vi�t ch��ng trình nh�p vào m�t ký t�:

In ra mã ASCII c�a ký t� �ó. In ra ký t� k� ti�p c�a nó.

20. Vi�t ch��ng trình nh�p vào �im ba môn Toán, Lý, Hóa c�a m�t h�c sinh. In ra �im trung bình c�a h�c sinh �ó v i hai s� l& th�p phân.

21. Vi�t ch��ng trình �o ng�#c m�t s� nguyên d��ng có �úng 3 ký s�.



Ch��ng 3

CÁC C�U TRÚC �I U KHI�N (Control structures)

1. GI4I THI�U T�t c các ch��ng trình máy tính dù ��n gin hay ph�c t�p ��u ��#c vi�t b�ng cách s� d�ng các c�u trúc �i�u khin. Có 3 lo�i c�u trúc �i�u khin c� bn là c�u trúc tu(n t� (sequence), c�u trúc l�a ch�n (selection), và c�u trúc l�p (repetition or loop). Các c�u trúc này �i�u khin th� t� th�c thi các l�nh c�a ch��ng trình.

C�u trúc tu�n t�: th�c hi�n các l�nh theo th� t� t� trên xu�ng d� i. C�u trúc l�a ch�n: d�a vào k�t qu c�a biu th�c �i�u ki�n. Tùy theo s� ��nh tr� c�a biu th�c này mà nh�ng l�nh t��ng �ng s� ��#c th�c hi�n. Các c�u trúc l�a ch�n g*m c�u trúc if, switch. C�u trúc l�p: l�p l�i 1 hay nhi�u l�nh cho ��n khi biu th�c �i�u ki�n là sai. Các c�u trúc l�p g*m for, while, do ... while.

Tuy nhiên, th� t� th�c hi�n các l�nh c�a ch��ng trình còn b� chi ph�i b"i các l�nh nhy nh� continue, break, goto.

L�nh (statement): m�t biu th�c k�t thúc b"i 1 d�u ch�m ph�y g�i là 1 l�nh. Ví d�: int a,b,c; a=10; a++;

Kh�i l�nh (block): m�t hay nhi�u l�nh ��#c bao quanh b"i c�p d�u {} ��#c g�i là m�t kh�i l�nh. V� m�t cú pháp, kh�i l�nh t��ng ��ng 1 câu l�nh ��n. Do �ó n�i �âu xu�t hi�n 1 l�nh thì n�i �ó có th xu�t hi�n 1 kh�i l�nh. Ví d�: if (a<b) { temp=a; a=b; b=temp; }



2. C�U TRÚC L�A CH�N IF C$u trúc if có các d!ng t/ng quát sau: Dng 1: if (expression)

statement; expression: Biu th�c lu�n lý (có giá tr� là true hay false) statement: Câu l�nh

L�u �* cú pháp:

Ý ngh+a: (u tiên expression ��#c ��nh tr�. N�u k�t qu là true (<>0) thì statement ��#c th�c thi. Ng�#c l�i, không làm gì c.

Ví d� 1: Vi�t ch��ng trình nh�p vào m�t s� nguyên a. In ra màn hình k�t qu kim tra a có phi là 1 s� d��ng không. #include <iostream.h> #include <conio.h> int main() { int a;

cout << "Input a = "; cin>>a; if(a>=0)

cout << a << " is a positive.”; getche(); return 0;

}

expression

statement

Exit

false

true



Gi�i thích: − N�u nh�p m�t s� a >=0 thì câu l�nh

cout << a << ” is a positive.”; s� ��#c th�c hi�n, ng�#c l�i câu l�nh này không ��#c th�c hi�n.

− L�nh getche() luôn luôn ��#c th�c hi�n vì nó không b� nh h�"ng b"i câu l�nh if.

Dng 2: if (expression)

statement1; else

statement2;

L�u �* cú pháp:

Ý ngha: (u tiên expression ��#c ��nh tr�. N�u k�t qu là true (<>0) thì statement1 ��#c th�c thi. Ng�#c l�i, thì statement2 ��#c th�c thi.

Ví d� 1: Vi�t ch��ng trình nh�p vào m�t s� nguyên a. In ra màn hình k�t qu kim tra a là s� âm hay d��ng.

expression

statement1

Exit

false

true

statement2



#include <iostream.h> #include <conio.h> int main() {

int a; cout << "Input a = "; cin >> a; if(a>=0)

cout << a << " is a positive.”; else

cout << a << " is a negative.”; getche(); return 0;

}

Ví d� 2: Vi�t ch��ng trình nh�p vào m�t s� nguyên d��ng là tháng trong n$m và in ra s� ngày c�a tháng �ó. Bi�t r�ng: - Tháng có 31 ngày: 1, 3, 5, 7, 8, 10, 12 - Tháng có 30 ngày: 4, 6, 9, 11 - Tháng có 28 ho�c 29 ngày : 2

#include <iostream.h> #include <conio.h> void main() { int m; cout << "Input month: "; cin >> m; if(m==1 || m==3 || m==5 || m==7 || m==8 || m==10 || m==12) cout << "Month “ << m << ” has 31 days."; else if(m==4 || m==6 || m==9 || m==11) cout << "Month “ << m << ” has 30 days."; else if(m==2) cout << "Month “ << m << ” has 28 or 29 days."; else cout << "This is not a valid month: ” << m; getche(); }

L�u ý:



- Ta có th s� d�ng các câu l�nh if… else l*ng nhau. Trong tr�%ng h#p if… else l*ng nhau thì else s� k t h�p v�i if g�n nh�t ch�a có else.

- Trong tr�%ng h#p câu l�nh if “bên trong” không có else thì phi vi�t nó trong c�p d�u {} (coi nh� là kh�i l�nh) � tránh s� k�t h#p else if sai.

Ví d�: if (ch >= '0' && ch <= '9')

kind = digit; else {

if (ch >= 'A' && ch <= 'Z') kind = upperLetter;

else {

if (ch >= 'a' && ch <= 'z') kind = lowerLetter;

else kind = specialLetter;

} }

cho d- ��c có th s� d�ng hình th�c sau: if (ch >= '0' && ch <= '9')

kind = digit; else if (ch >= 'A' && ch <= 'Z')

kind = upperLetter; else if (ch >= 'a' && ch <= 'z')

kind = lowerLetter; else

kind = specialLetter;



3. C�U TRÚC L�A CH�N switch

C�u trúc switch là m�t c�u trúc l�a ch�n có nhi�u nhánh. Khi có nhi�u s� l�a ch�n thi �ây là c�u trúc phù h#p thay vì phi dùng m�t chu�i l�nh if..else l*ng nhau.

D�ng t�ng quát c�a c�u trúc switch:

Cú pháp: switch(expression) {

case value1: statement1; [break;] … case valueN: statementN; [break;] [default : statement;]

}



L�u ��:

expression

expression = = value1 ?

Exit

false

statement1

expression = = value2 ?

statement2

expression = = valueN ?

statementN

false

true

true

true

statement

default:

false



Gi i thích: − Tr� c h�t ch��ng trình s� ��nh tr� c�a expression. − N�u giá tr� c�a expression b�ng value1 thì th�c hi�n

statement1 r*i thoát. − N�u giá tr� c�a expression khác value1 thì so sánh v i value2,

n�u b�ng value2 thì th�c hi�n statement2 r*i thoát… ., so sánh t i valueN.

− N�u t�t c các phép so sánh trên ��u sai thì th�c hi�n statement c�a tr�%ng h#p default.

L�u ý: − expression trong switch() phi có k�t qu là giá tr� kiu s�

nguyên (int, char, long). − Các giá tr� sau case phi là h�ng nguyên. − Không b�t bu�c phi có default. − Thông th�%ng m�i case có 1 câu l�nh break. Khi th�c hi�n l�nh

t��ng �ng c�a case có giá tr� b�ng expression, ch��ng trình th�c hi�n l�nh break � thoát kh�i c�u trúc switch.

Ví d� 1: Nh�p vào m�t s� nguyên, chia s� nguyên này cho 2 l�y ph(n d�. Kim tra n�u ph(n d� b�ng 0 thì in ra thông báo “là s� ch.n” , n�u s� d� b�ng 1 thì in thông báo “là s� l&” . #include <iostream.h> #include <conio.h> void main () {

int n, remainder; cout << ”Input an number: "; cin>>n; remainder = (n % 2); switch(remainder) {

case 0: cout << n << ” is an even."; break; case 1: cout << n << ” is an odd."; break;

} getche();

}



Ví d� 2: Nh�p vào 2 s� nguyên và 1 phép toán. − N�u phép toán là ‘+’, ‘-‘, ‘*’ thì in ra k�t qua là t�ng, hi�u, tích

c�a 2 s�. − N�u phép toán là ‘/’ thì kim tra xem s� th� 2 có khác không

hay không? N�u khác không thì in ra th��ng c�a chúng, ng�#c l�i thì in ra thông báo “Cannot divide by zero!” .

#include <iostream.h> #include <conio.h> int main() {

int a, b; char operation; cout << ”Input two numbers: "; cin >> a >> b; cout << ”Input operation(+ - * /): "; cin >> operation; switch(operation) {

case '+': cout << a << ” + “ << b << ” = ” << a+b; break;

case '-': cout << a << ” - “ << b << ” = ” << a-b; break;

case '*': cout << a << ” * “ << b << ” = ” << a*b; break;

case '/': if(b!=0)

cout << a << ” / “ << b << ” = ” << (float)a/b; else

cout << "Cannot divide by zero !"; break;

} getche();

}



Ví d� 3: Yêu c(u ng�%i th�c hi�n ch��ng trình nh�p vào m�t s� nguyên d��ng là tháng trong n$m và in ra s� ngày c�a tháng �ó. - Tháng có 31 ngày: 1, 3, 5, 7, 8, 10, 12 - Tháng có 30 ngày: 4, 6, 9, 11 - Tháng có 28 ho�c 29 ngày : 2 - N�u nh�p vào s� <1 ho�c >12 thì in ra câu thông báo “There is no month like this.“. #include <iostream.h> #include <conio.h> void main() { int month; cout << "Input month: "; cin >> month; switch(month) { case 1: case 3: case 5: case 7: case 8: case 10: case 12: cout<<"Month ” << month << ” has 31 days."; break; case 4: case 6: case 9: case 11: cout << "Month ” << month << ” has 30 days."; break; case 2: cout << "Month “ << month << “ has 28 or 29 days."; break; default : cout<<”There is no month like this.”; } getche(); }



4. CÁC C�U TRÚC L5P (Loop structures) C�u trúc l�p cho phép l�p l�i nhi�u l(n 1 câu l�nh hay 1 kh�i l�nh nào �ó cho ��n khi biu th�c �i�u ki�n còn th�a.

4.1. C$u trúc while C�u trúc while cho phép th�c hi�n statement trong khi expression v!n còn �úng. Cú pháp: while(expression)

statement;

L�u �� cú pháp: B� c 1: expression ��#c ��nh tr�. B� c 2: N�u k�t qu là true thì th�c hi�n statement r*i quay l�i b� c 1. B� c 3: N�u k�t qu là false thì thoát kh�i vòng l�p while.

expression

statement

Exit

false

true



Ví d� 1: Vi�t ch��ng trình tính t�ng các s� nguyên t� 1 t i n. #include <iostream.h> #include <conio.h> void main () {

int i, n, sum; cout << ”Input n= ”; cin >> n; i = 1; sum = 0; while(i<=n) {

sum += i; i++;

} cout << “Sum of 1 to “ << n << “ is “ << sum; getche();

}

Ví d� 2: Vi�t �o�n ch��ng trình in dãy s� nguyên t� 1 ��n 10.

#include <iostream.h> #include <conio.h> void main() {

int i; cout << ”Display one to ten: "; i=1; while (i<=10) {

cout << “\t” << i; i++;

} getche();

}

L�u ý: vòng l�p phi k�t thúc " m�t �im nào �ó, vì v�y bên trong vòng l�p phi cung c�p m�t cách th�c nào �ó � bu�c expression tr" thành false n�u không thì s� l�p vô t�n. Trong ví d� trên i++; là cách th�c t$ng bi�n i � ��n khi i=11 thì vòng l�p k�t thúc.



4.2. C$u trúc l-p do … while C�u trúc l�p do … while gi�ng nh� vòng l�p while, dùng � l�p l�i m�t statement trong khi expression là true. statement luôn luôn ��#c th�c hi�n ít nh�t 1 l(n.

Cú pháp:

do {

statement; }while(expression);

L�u ��:

B� c 1: statement ��#c th�c hi�n B� c 2: expression ��#c ��nh tr�. B� c 3: N�u expression là true thì quay l�i b� c 1 B� c 4: N�u expression là false thì thoát kh�i do ... while.

false

expression

statement

Exit

true



Ví d� 1: Vi�t �o�n ch��ng trình in dãy s� nguyên t� 1 ��n 10. #include <iostream.h> #include <conio.h> void main () {

int i; cout<<"Display one to ten: "; i=1; do {

cout << i << “\t”; i+=1;

} while(i<=10); getche();

}

Ví d� 2: Vi�t ch��ng trình nh�p vào m�t s� nguyên n. Tính t�ng c�a các s� nguyên t� 1 ��n n.

#include <iostream.h> #include <conio.h> void main () {

unsigned int n,i,sum; cout << ”Input a positive number: "; cin >> n; sum=0; i=1; do {

sum += i; i++;

} while(i<=n); cout << ”Sum of 1 to ” << n << ” = ” << sum; getche();

}



4.3. C$u trúc l-p for Ch�c n$ng chính c�a c�u trúc l�p for là l�p l�i m�t ��an l�nh nào �ó trong khi Exp2 còn là true. C�u trúc l�p for th�%ng s� d�ng trong nh�ng ch��ng trình mà s� l(n l�p l�i m�t ��an l�nh nào �ó ��#c bi�t tr� c.

Cú pháp:

for (Exp1; Exp2; Exp3) statement;

Cách ho�t ��ng c�a vòng l�p for nh� sau:

B� c 1: Exp1 là biu th�c kh"i t�o ��#c th�c hi�n. Thông th�%ng nó gán giá tr� kh"i t�o cho bi�n �i�u khin c�u trúc for. Biu th�c này ch, ��#c th�c hi�n ch, 1 l(n.

B� c 2: Exp2 là biu th�c �i�u ki�n ��#c ��nh tr�.

B� c 3: N�u giá tr� c�a Exp2 là true thì statement s� ��#c th�c thi, Exp3 ��#c th�c thi. Quay l�i b� c 2

B� c 4: N�u giá tr� c�a Exp2 là false thì thoát kh�i c�u trúc for.

L�u �� cú pháp:

Exp3

false Exp2

Exp1

Exit

true

statement



Ví d� 1: Vi�t ch��ng trình tính t�ng c�a các s� nguyên t� 1 t i n. #include <iostream.h> #include <conio.h> void main() { int i, n, sum; cout << ”Input a number:”; cin >> n; sum = 0; for (i=1 ; i<=n ; i++) sum += i; cout << ”Sum of 1 to “ << n << ” is: ” << sum; getche(); }

− C/C++ cho phép biu th�c �(u tiên trong vòng l�p for là m�t ��nh ngh+a bi�n. Ví d� trong vòng l�p trên thì i có th ��#c ��nh ngh+a bên trong vòng l�p:

for(int i=1; i<=n; ++i) sum += i;

− B�t k/ biu th�c nào trong 3 biu th�c c�a vòng l�p for ��u có th r�ng. Ví d�, xóa biu th�c �(u và biu th�c cu�i cho chúng ta d�ng gi�ng nh� vòng l�p while:

for(; i != 0;) statement; //t��ng ��ng v�i while(i != 0) statement;

− Xóa t�t c các biu th�c cho chúng ta m�t vòng l�p vô t�n.

for (;;) // vòng l�p vô h�n statement;



5. CÁC L�NH R6 NHÁNH VÀ L�NH NH�Y 5.1. L%nh break L�nh break th�%ng dùng trong ph(n case c�a c�u trúc switch � thoát kh�i c�u trúc switch sau khi các l�nh t��ng �ng c�a case �ã ��#c th�c hi�n. Ngoài ra, trong các c�u trúc l�p, n�u mu�n thoát kh�i 1 vòng l�p t�c thì mà không ch% cho ��n khi biu th�c �i�u ki�n (conditional expression) c�a c�u trúc ��#c ��nh tr� là false, ta dùng l�nh break. Khi break ��#c th�c hi�n bên trong 1 c�u trúc l�p, �i�u khin (control flow) t� ��ng nhy ��n l�nh �(u tiên ngay sau c�u trúc l�p �ó. L�nh break th�%ng liên � i v i m�t câu l�nh if trong nh�ng tr�%ng h#p này. Không s� d�ng l�nh break bên ngoài các c�u trúc l�p nh� while, do...while, for hay c�u trúc switch.

Ví d� 1: �c vào m�t m�t kh�u ng�%i dùng t�i �a attempts l(n

for (i=0; i<attempts ; ++i) {

cout << "Input a password: "; cin >> passWord; if (check(passWord)) // ki�m tra m�t kh�u úng hay sai

break; // thoát khi vòng l�p cout << "Password is wrong!\n";

}

1 �ây gi s� r�ng có m�t hàm check � kim tra m�t m�t kh�u và tr v� 1 (true) n�u nh� m�t kh�u �úng và ng�#c l�i là 0 (false).

Ví d� 2: Vi�t ch��ng trình tính t�ng các s� nguyên ��#c nh�p t� bàn phím, ch��ng trình ��#c k�t thúc khi nh�p s� âm.

#include <iostream.h> #include <conio.h>



void main() { int num,sum=0; while(1) { cout <<"Input a number (negative for exit): "; cin >> num; if (num < 0) break; sum += num; } cout<<"\nSum of all inputs is " << sum; getche(); }

Ch��ng trình trên n�u không dùng break có th �u#c vi�t l�i nh� sau: do { cout <<"Input a number (negative for exit): ”; cin >> num; if (num>=0)

sum += num; }while (num>=0);

5.2. L%nh continue L�nh continue ch, ��#c dùng trong thân các c�u trúc l�p nh� for, while, do...while. Trong m�i l(n l�p c�a các c�u trúc trên, các l�nh trong thân vòng l�p ��#c th�c hi�n r*i �i�u khin s� quay v� �(u vòng l�p chu�n b� cho l(n l�p k� ti�p. Tuy nhiên, n�u mu�n �i�u khin quay v� �(u vòng l�p ngay l�p t�c mà không th�c hi�n các l�nh còn l�i c�a l(n l�p hi�n hành thì ta dùng câu l�nh continue. Câu l�nh continue th�%ng �i kèm v i 1 câu l�nh if.

Ví d�: m�t vòng l�p th�c hi�n ��c m�t s�, x� lý nó nh�ng b� qua nh�ng s� âm, và d�ng khi s� là 0, có th di-n gii nh� sau: do

{ cin >> num; if (num < 0) continue;

// process num here } while(num != 0);



�i�u này t��ng ��ng v�i: do {

cin >> num; if(num >= 0) {

// process num here }

} while(num != 0);

− M�t bi�n th c�a vòng l�p này là � ��c chính xác m�t s� n l(n có th ��#c di-n gii nh� sau:

for(i=0; i<n; i++) {

cin >> num; if(num<0) continue; // jump to i++

// process num here }

Khi l�nh continue xu�t hi�n bên trong các c�u trúc l�p l*ng nhau thì nó ch, liên � i ��n c�u trúc l�p tr�c ti�p ch�a nó.

Ví d�: trong m�t t�p các c�u trúc l�p ��#c l*ng nhau sau �ây, l�nh continue liên � i v i c�u trúc l�p for và không liên � i v i c�u trúc l�p while: while(more)

{ for (i = 0; i<n; i++) {

cin >> num; if (num < 0)

continue; // jump to i++ // process num here...

} //etc...

}



BÀI T�P CH��NG 3

1. Nh�p 1 s� n>=0. Tính và xu�t c$n b�c hai c�a n.

HD: dùng hàm sqrt(a)= a

2. Nh�p vào s� giây b�t k/ t>=0. Tính và xu�t ra d�ng Gi3:Phút:Giây

Ví d�: Nh�p 3750 thì xu�t ra 1:2:30 AM Nh�p 51100 thì xu�t ra 2:11:40 PM

HD: hour=(t/3600)%24

minute=(t%3600)/60

second=(t%3600)%60

3. Nh�p 3 s� th�c a, b, c. Tìm s� l n nh�t.

4. Nh�p n. Kim tra n là s� ch.n hay s� l&.

5. Nh�p 2 s� a, b. Kim tra xem chúng có cùng d�u hay không.

6. Nh�p vào hai s� nguyên d��ng a, b. So sánh giá tr� c�a chúng (l n h�n, nh� h�n, b�ng).

7. Gii và bi�n lu�n ph��ng trình b�c 1: ax+b=0.

8. Gii và bi�n lu�n ph��ng trình b�c 2: ax2+bx+c=0.

9. Nh�p vào tháng t (v i 1<=t<=12). Cho bi�t t thu�c qúy m�y trong n$m.

10. Nh�p vào tháng t (v i 1<=t<=12). Cho bi�t tháng t có bao nhiêu ngày. Riêng tháng 2 thì phi kim tra n$m nhu�n (N$m nhu�n là n$m chia h�t cho 4 mà không chia h�t cho 100, ho�c chia h�t cho 400).

11. Nh�p vào m�t ngày (ngày, tháng, n�m). Tìm ngày k� sau ngày v�a nh�p (ngày/tháng/n�m).

12. Nh�p vào m�t ngày (ngày, tháng, n�m). Tìm ngày k� tr� c ngày v�a nh�p (ngày/tháng/n�m).



13. Nh�p vào m�t ngày (ngày, tháng, n�m). Cho bi�t ngày �ó là ngày th� bao nhiêu trong n$m.

14. Nh�p vào m�t n$m d��ng l�ch. Hãy cho bi�t n$m âm l�ch. (vd: n=2007 => inh H#i)

15. Nh�p m�t s� n có t�i �a 2 ch� s�. Hãy cho bi�t cách ��c ra d�ng ch�.

(vd: n=35 => Ba m��i l$m, n=5 => n$m).

16. Nh�p m�t s� n có t�i �a 3 ch� s�. Hãy cho bi�t cách ��c ra d�ng ch�.

(vd: n=235 => Hai tr$m ba m��i l$m, n=305 => Ba tr$m l& n$m)

17. Nh�p m�t s� n b�t k/. Hãy cho bi�t cách ��c ra d�ng ch�.

18. Nh�p vào �im Toán, Lý, Hoá. Hãy tính TB và Cho bi�t sinh viên �ó x�p lo�i gì (Xu�t s�c, Gi�i, Khá, Trung bình, Y�u)..

19. Kim tra s� nguyên d��ng n có phi là s� chính ph��ng hay không?

20. Vi�t ch��ng trình nh�p vào m�t s� nguyên d��ng n v i 1<=n<=7. Tùy theo n=1,2,...,7 hãy in t��ng �ng các t� (Sunday, Monday, Tuesday,.... , Saturday) ra màn hình.

21. Nh�p vào s� Kwh tiêu th� �i�n. Tính ti�n �i�n phi tr bi�t r�ng cách th�c tính ti�n theo qui ��nh nh� sau:

a. 100 kwh ��nh m�c �(u tiên có ��n giá trung bình là 600�/kwh

b. Các kwh t� 101 ��n 150 có ��n giá là 700�/kwh c. Các kwh t� 151 ��n 200 có ��n giá là 900�/kwh d. Các kwh t� 201 tr" �i có ��n giá là 1100�/kwh

22. Nh�p c�nh a>=0, b>=0, c>=0. N�u a, b, c t�o thành tam giác thì hãy tính và xu�t chu vi, di�n tích hình tam giác. Ng�#c l�i, thông báo “ Không t�o thành tam giác”

HD: cv=a+b+c, p=cv/2 và dt= )(*)(*)(* cpbpapp −−−

23. Vi�t ch��ng trình nh�p t� bàn phím 2 s� a, b và m�t ký t� ch.

N�u:



o ch là “ +“ thì th�c hi�n phép tính a+b và in k�t qu lên màn hình o ch là “ –“ thì th�c hi�n phép tính a-b và in k�t qu lên màn hình. o ch là “ *” thì th�c hi�n phép tính a*b và in k�t qu lên màn hình. o ch là “ /” thì th�c hi�n phép tính a/b và in k�t qu lên màn hình.

24. M�t s� nguyên d��ng chia h�t cho 3 n�u t�ng các ch� s� c�a nó chia h�t cho 3. Vi�t ch��ng trình nh�p vào m�t s� có 3 ch� s�, kim tra s� �ó có chia h�t cho 3 dùng tính ch�t trên.( if )

25. Vi�t ch��ng trình nh�n vào gi%, phút, giây d�ng (hh:mm:ss ), t� bàn phím. C�ng thêm m�t s� giây vào và in ra k�t qu d� i d�ng ( hh:mm:ss ).

26. Kim tra m�t ký t� nh�p vào thu�c t�p h#p nào trong các t�p ký t� sau:

− Các ký t� ch� hoa: 'A' ...'Z' − Các ký t� ch� th�%ng: 'a' ... 'z' − Các ký t� ch� s� : '0' ... '9' − Các ký t� khác.

27. H� th�p l�c phân dùng 16 ký s� bao g*m các ký t�

0 .. 9 và A, B, C, D, E ,F. Các ký s� A, B, C, D, E, F có giá tr� t��ng �ng trong h� th�p phân nh� sau:

A 10 B 11 C 12 D 13 E 14 F 15

Hãy vi�t ch��ng trình cho nh�p vào ký t� biu di-n m�t ký s� c�a h� th�p l�c phân và cho bi�t giá tr� th�p phân t��ng �ng. Tr�%ng h#p ký t� nh�p vào không thu�c các ký s� trên, ��a ra thông báo l�i: "H� th�p l�c phân không dùng ký s� này"

28. Nh�p n>=0. Tính S(n)=1+2+3+ … + n.

29. Nh�p n>=0. Tính S(n)=2+4+ … + n.

30. Nh�p n>=0. Tính S(n)=1+3+ … + n.

31. Nh�p n>=0. Tính S(n)=12+22+32+ … + n2.



32. Nh�p n>=0. Tính S(n)=12+22+32+ … + n2.

33. Nh�p n>=0. Tính n

nS1

...31

21

1)( ++++=

34. Nh�p n>=0. Tính n

nS21

...41

21

)( +++=

35. Nh�p n>=0. Tính 12

1...

51

31

1)(+

++++=n

nS

36. Nh�p n>=0. Tính )1(

1...

321

211

)(+×

++×

+×

=nn

nS

37. Nh�p n>=0. Tính 1

...32

21

)(+

+++=n

nnS

38. Nh�p n>=0. Tính 2212

...43

21

)(+++++=

nn

nS

39. Nh�p n>=0. Tính T(n)=1×2×3× … ×n

40. Nh�p n>=0. Tính S(n)=1+1×2+1×2×3+ … +1×2×3×… ×n

41. Nh�p x,n. Tính T(x,n)=xn

42. Nh�p x,n. Tính n xnS =)(

43. Nh�p x,n. Tính S(x,n)=x+x2+x3+ … +xn

44. Nh�p x,n. Tính S(x,n)=x2+x4+x6+ … +x2n

45. Nh�p x,n. Tính S(x,n)=x+x3+x5+ … +x2n+1

46. Nh�p n. Tính

nnS

+++++

+++

++=

...211

...321

121

11)(

47. Nh�p x,n. Tính

nxxx

xnxSn

+++++

+++

++=

...21...

32121),(

32

48. Nh�p x,n. Tính !

...!3!2

),(32

nxxx

xnxSn

++++=

49. Nh�p x,n. Tính !2

...!4!2

),(242

nxxx

xnxSn

++++=



50. Nh�p x,n. Tính )!12(

...!5!3

),(1253

+++++=

+

nxxx

xnxSn

51. Nh�p n. Tính 2...222)( ++++=nS , có n d�u c$n l*ng nhau.

52. Nh�p n. Tính 12...)2()1()( +++−+−+= nnnnS , có n

d�u c$n l*ng nhau.

53. Nh�p n. Tính nnnS +−++++= )1(...321)( , có n

d�u c$n l*ng nhau.

54. Li�t kê t�t c các ��c s� c�a s� nguyên d��ng n.

55. Li�t kê t�t c các ��c s� l� c�a s� nguyên d��ng n.

56. Li�t kê t�t c các ��c s� ch�n c�a s� nguyên d��ng n.

57. Tính t�ng t�t c các ��c s� c�a s� nguyên d��ng n.

58. Tính tích t�t c các ��c s� c�a s� nguyên d��ng n.

59. �m s� l�#ng các ��c s� c�a s� nguyên d��ng n.

60. Tìm ��c s� l�n nh�t c�a s� nguyên d��ng n.

61. Kim tra n có phi là s� nguyên t� hay không?

62. Li�t kê các s� nguyên t� nh� h�n hay b�ng s� nguyên d��ng n.

63. Li�t kê các ch� s� là s� nguyên t� c�a s� nguyên d��ng n.

64. Tính t*ng các ch� s� là s� nguyên t� c�a s� nguyên d��ng n.

65. Tính tích các ch� s� là s� nguyên t� c�a s� nguyên d��ng n.

66. �m s� l�#ng các ch� s� ch�n c�a s� nguyên d��ng n.

67. Tính t�ng các ch� s� ch�n c�a s� nguyên d��ng n.

68. Tính tích các ch� s� ch�n c�a s� nguyên d��ng n.

69. �m s� l�#ng các ch� s� l� c�a s� nguyên d��ng n.

70. Tính t�ng các ch� s� l� c�a s� nguyên d��ng n.

71. Tính tích các ch� s� l� c�a s� nguyên d��ng n.

72. Tìm ��c s� chung l�n nh�t c�a 2 s� nguyên d��ng a, b.



73. Tìm B�i s� chung l�n nh�t c�a 2 s� nguyên d��ng a, b.

74. Kim tra s� nguyên d��ng n có phi là s� �i x�ng hay không?

75. Kim tra s� nguyên d��ng n có phi là s� hoàn thi�n (Perfect number) hay không? (S� hoàn thi�n là s� có t�ng các � c s� c�a nó (không k nó) thì b�ng chính nó. Vd: 6 có các � c s� là 1,2,3 và 6=1+2+3 � 6 là s� hoàn thi�n)

76. Kim tra s� nguyên d��ng n có phi là s� th�nh v��ng (Abundant number) hay không? (S� th�nh v�#ng là s� có t�ng các � c s� c�a nó (không k nó) thì l n h�n nó. Vd: 12 có các � c s� là 1,2,3,4,6 và 12<1+2+3+4+6 � 12 là s� th�nh v�#ng)

77. Kim tra s� nguyên d��ng n có phi là s� không tr�n v n (Deficient number) hay không? (S� không tr�n v2n là s� có t�ng các � c s� c�a nó (không k nó) thì nh� h�n nó. Vd: 9 có các � c s� là 1,3 và 9>1+3 � 9 là s� không tr�n v2n)

78. Kim tra s� nguyên d��ng n có các ch� s� toàn là ch� s� ch�n hay không?

79. Kim tra s� nguyên d��ng n có các ch� s� toàn là ch� s� l� hay không?

80. Kim tra s� nguyên d��ng n có các ch� s� t�ng d�n t! trái qua ph�i hay không?

81. Kim tra s� nguyên d��ng n có các ch� s� gi�m d�n t! trái qua ph�i hay không?

82. Nh�p n>0. Tìm s� nguyên d��ng m l n nh�t sao cho 1+2+3+… +m<n.

83. Nh�p n>0. Tìm s� nguyên d��ng m nh� nh�t sao cho 1+2+3+… +m>n.

84. Xu�t s� �o c�a s� nguyên d��ng n.

85. Xu�t ra các ký t� t� A->Z, Z->A, a->z, z->a.

86. Xu�t ra các s� l& nh� h�n 50 tr� các s� 11, 25, 37.

87. Nh�p n>0. Xu�t ra bng c�u ch��ng n.

88. Hãy tìm s� gà và s� chó? bi�t:

V�a gà v�a chó



bó l�i cho tròn

ba m��i sáu con

m�t tr$m chân ch.n.

89. Hãy tìm s� trâu m�i lo�i? bi�t:

Tr$m trâu t$m c� Trâu ��ng $n n$m Trâu n�m $n ba Trâu già ba con m�t bó

90. Xu�t ra màn hình các hình có chi�u cao h>0. ví d� h=4 ta có các hình nh� sau:

91. Vi�t ch��ng trình th�c hi�n trò ch�i �oán s� nh� sau:

Máy l�y ra m�t s� ng!u nhiên n∈[1,100] là s� c�a máy: S(máy (s� d�ng hàm random).



Ng�%i nh�p vào m�t s� (S(nh�p) + N�u S(nh�p l n h�n S(máy thì thông báo “ S� b�n l n h�n s� máy” . + N�u S(nh�p nh� h�n S(máy thì thông báo “ S� b�n nh� h�n s� máy” .

Trò ch�i k�t thúc khi: + Ho�c B�n �ã �oán trúng: thông báo “ Ha ha b�n tài th�t” . + Ho�c B�n �ã �oán sai 7 l(n: thông báo “ B�n �ã thua r*i” và hin th� S(máy.

92. Trò ch�i l�y bì:

“ Có M viên bi, hai ng�i ch�i l�n l��t l�y i các viên bi sao cho s� viên bi l�y ít nh�t là 1 và nhi"u nh�t là 3, ng�i nào mà l�y ��c viên bi cu�i cùng thì ng�i ó b� thua” - Gi s� b�n ch�i v i máy. Hãy vi�t ch��ng trình mô ph�ng trò

ch�i này sao cho máy có c� h�i th�ng nhi�u nh�t. - Ng�%i ch�i c(n nh�p vào s� viên bi M và ch�n l�#t l�y bi

tr� c (máy l�y tr��c hay b�n l�y tr��c) sau �ó c� thay phiên nhau l�y. Cu�i cùng thì thông báo k�t qu c�a ván ch�i.



Ch��ng 4

M�NG (Array)

1. Gi i thi%u M�ng Mng là m�t t�p h#p các bi�n có cùng kiu d� li�u n�m liên ti�p nhau trong b� nh và ��#c tham chi�u b"i m�t tên chung (tên mng). M�i ph(n t� c�a mng ��#c tham chi�u thông qua ch, m�c (index). N�u mng có n ph(n t� thì ph(n t� �(u tiên có ch, m�c là 0 và ph(n t� cu�i có ch, m�c là n-1. tham chi�u ��n m�t ph(n t� ta dùng tên mng và ch, m�c c�a ph(n t� ��#c ��t trong c�p d�u [].

S� l�#ng ph(n t� trong mng ��#c g�i là kích th c c�a mng. Kích th� c c�a mng là c� ��nh và phi ��#c xác ��nh tr� c; nó không th thay ��i trong su�t quá trình th�c hi�n ch��ng trình.

Ví d�: Khai báo mng a có 10 ph(n t�. M�i ph(n t� có kiu int int a[10];

a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9]

Có 2 lo�i mng thông d�ng là mng 1 chi�u và mng nhi�u chi�u.

2. M�ng 1 chi+u 2.1. Khai báo m�t m�ng m�t chi+u D�ng t�ng quát � khai báo m�t mng m�t chi�u là:

type arrayName[elements];

type: kiu d� li�u c�a m�i ph(n t� mng.

elements: s� ph(n t� có trong mng

int int int



arrayName: tên mng

Gi�ng nh� nh�ng bi�n khác, mng phi ��#c khai báo t�%ng minh � cho trình biên d�ch có th c�p phát b� nh cho nó.

Kích th� c (tính b�ng byte) c�a mng ��#c tính theo công th�c:

TotalSize = sizeof(type) * elements Ví d�, � khai báo m�t mng có 100 ph(n t� tên num có kiu int, ta dùng l�nh: int num[100];

V�y mng trên có kích th� c là 2bytes * 100 = 200bytes (gi s� int chi�m 2 bytes)

M�i ph(n t� mng là m�t bi�n thông th�%ng. o�n l�nh d� i �ây minh h�a vi�c s� d�ng các ph(n t� mng. num[0] = 2; //gán ph�n t� có ch� m�c 0 giá tr� 2

num[1] = num[0] + 3 //num[1] có giá tr� 5

num[2] = num[0] + num[1]; //num[2] có giá tr� 7

cout << num[1]; //In ra giá tr� 5

2.2. Khai báo và kh7i t!o m�ng m�t chi+u Ngoài ra, ta còn có th v�a khai báo v�a kh"i t�o các ph(n t� c�a mng m�t chi�u. D�ng t�ng quát nh� sau:

type arrayName[] = {value1, value2, ..., valueN};

L�u ý: kích th� c mng không khai báo. S� l�#ng ph(n t� trong mng là s� s� giá tr� ��#c cung c�p trong c�p d�u ngo�c {}. M�i giá tr� phân cách nhau dùng d�u ph�y.

Ví d�: Xem xét khai báo sau: int soChan[] = {2,4,6,8,10};

Mng soChan có 5 ph(n t� l(n l�#t là: soChan[0] có giá tr� là 2 soChan[1] có giá tr� là 4 ... soChan[4] có giá tr� là 10



2.3. M�t s( ví d& Ví d� 1: T�o m�t mng nguyên a có N ph(n t�. M�i ph(n t� có giá tr� là ch, m�c c�a nó. In mng ra màn hình. #include <iostream.h> #include <conio.h> #define N 10 void main() {

int a[N]; for(int i=0 ; i < N ; i++) a[i] = i ; cout<< "In mang:\n"; for(int i=0 ; i < N ; i++) cout << “a[“ << i <<”] = ” << a[i] << endl;

}

Ví d� 2: �i m�t s� nguyên d��ng thành s� nh� phân. Vi�c chuyn ��i này ��#c th�c hi�n b�ng cách l�y s� �ó chia liên ti�p cho 2 cho t i khi b�ng 0 và l�y các s� d� theo chi�u ng�#c l�i � t�o thành s� nh� phân. Ta s� dùng mng m�t chi�u � l�u l�i các s� d� �ó. Ch��ng trình c� th nh� sau: #include <iostream.h> #include <conio.h> void main() {

int n; int remainder; int binary[20],k=0,i; cout << "Input an integer n= "; cin >> n; do {

remainder = n % 2; binary[k]= remainder; k++; n = n/2;

} while(n>0); cout << "Binary form: "; for(i=k-1 ; i>=0 ; i--)

cout << binary[i]; getche();

}



3. M�ng nhi+u chi+u C/C++ h� tr# mng nhi�u chi�u. D�ng ��n gin nh�t c�a mng nhi�u chi�u là mng hai chi�u. Mng hai chi�u th�c ch�t là mng c�a nh�ng mng m�t chi�u. Ta có th xem mng hai chi�u là m�t ma tr�n g*m các hàng và các c�t.

3.1. Khai báo m�ng hai chi+u

type arrayName[rows][columns];

rows: s� hàng columns: s� c�t Gi s� ta khai báo m�t mng num có 3 hàng và 4 c�t, kiu int và gán giá tr� cho các ph(n t� nh� hình minh h�a.

int num[3][4]; num[0][0] = 1; num[0][1] = 2; num[0][2] = 3; num[0][3] = 4; num[1][0] = 5; ... num[2][3] = 12;

3.2. Khai báo và kh7i t!o m�ng hai chi+u D�ng t�ng quát khai báo và kh"i t�o mng hai chi�u: type arrayName[][columns] = { {value1,value2,...,valueN},

{value1,value2,...,valueN},

{...},

{value1,value2,...,valueN}};

L�u ý:



- S� ph(n t� c�a m�i hàng phi b�ng s� c�t (columns)

- S� hàng (rows) c�a khai báo mng hai chi�u � tr�ng.

- S� hàng c�a mng ��#c xác ��nh d�a vào s� hàng trong ph(n kh"i t�o. Giá tr� các ph(n t� trong m�i hàng ��#c ��t trong c�p {}, các hàng phân cách nhau b�ng m�t d�u ph�y.

Ví d�, � khai báo và kh"i t�o mng hai chi�u c�a hình minh h�a trên, ta khai báo nh� sau: int num[][4] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};

3.3. M�t s( ví d&

Ví d� 1: T�o 1 mng hai chi�u có ROWS hàng, COLUMNS c�t. Giá tr� c�a ph(n t� trong mng ��#c xác ��nh b�ng tích c�a ch, m�c hàng và ch, m�c c�t c�a chúng. #include <iostream.h> #include <conio.h> #define ROWS 4 #define COLUMNS 3 void main() { int a[ROWS][COLUMNS]; //Initialization for(int i=0 ; i<ROWS ; i++) for(int j=0 ; j<COLUMNS ; j++) a[i][j] = i*j; //Display array contents cout << “Contents in array:\n”; for(int i=0 ; i<ROWS ; i++) { for(int j=0 ; j<COLUMNS ; j++) cout << a[i][j] << “\t”; cout << endl; } }

Ví d� 2: T�o m�t ma tr�n vuông 4x4. Tính t�ng các ph(n t� trên ��%ng chéo chính

0 0 0

0 1 2

0 2 4

0 3 6



#include <iostream.h> #include <conio.h> void main() { int a[][4] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}, {13,14,15,16}}; int sum=0; //Tinh tong duong cheo chinh for(int i=0 ; i<4 ; i++) for(int j=0 ; j<4 ; j++) if(i==j) sum += a[i][j]; cout << “Tong duong cheo chinh la: ” << sum; }




1. Vi�t ch��ng trình nh�p vào m�t dãy n s� th�c a[0], a[1],..., a[n-1], s�p x�p dãy s� theo th� t� gim d(n. Xu�t ra dãy s� sau khi s�p x�p.

2. Vi�t ch��ng trình s�p x�p m�t mng theo th� t� t$ng d(n sau khi �ã lo�i b� các ph(n t� trùng nhau.

3. Vi�t ch��ng trình nh�p vào m�t mng, hãy xu�t ra màn hình: - Ph(n t� l n nh�t c�a mng. - Ph(n t� nh� nh�t c�a mng. - Tính t�ng c�a các ph(n t� trong mng .

4. Vi�t ch��ng trình nh�p vào m�t dãy các s� theo th� t� t$ng, n�u nh�p sai quy cách thì yêu c(u nh�p l�i. In dãy s� sau khi �ã nh�p xong.

5. Vi�t ch��ng trình nh�p vào m�t ma tr�n (mng hai chi�u) các s� nguyên, g*m m hàng, n c�t. In ma tr�n �ó lên màn hình.

6. Vi�t ch��ng trình � chuyn ��i v� trí t� dòng thành c�t c�a m�t ma tr�n (ma tr�n chuyn v�) vuông 4 hàng 4 c�t. Sau �ó vi�t cho ma tr�n t�ng quát c�p m*n.

Ví d�:

1 2 3 4 1 2 9 1 2 5 5 8 2 5 4 5 9 4 2 0 3 5 2 8 1 5 8 6 4 8 0 6

7. Vi�t ch��ng trình nh�p vào m�t mng s� t� nhiên. Hãy xu�t ra màn hình: - Dòng 1 : g*m các s� l&, t�ng c�ng có bao nhiêu s� l&. - Dòng 2 : g*m các s� ch.n, t�ng c�ng có bao nhiêu s� ch.n. - Dòng 3 : g*m các s� nguyên t�. - Dòng 4 : g*m các s� không phi là s� nguyên t�.

8. Vi�t ch��ng trình tính t�ng bình ph��ng c�a các s� âm trong m�t mng các s� nguyên.

9. Vi�t ch��ng trình th�c hi�n vi�c �o m�t mng m�t chi�u.

Ví d� : 1 2 3 4 5 7 9 10 �o thành 10 9 7 5 4 3 2 1 .



10. Vi�t ch��ng trình nh�p vào hai ma tr�n A và B có c�p m, n. In hai ma tr�n lên màn hình. T�ng hai ma tr�n A và B là ma tr�n C ��#c tính b"i công th�c:

cij= a

ij +b

ij ( i=0,1,2,...m-1; j=0,1,2...n-1)

Tính ma tr�n t�ng C và in k�t qu lên màn hình.

11. Vi�t ch��ng trình nh�p vào hai ma tr�n A có c�p m, k và B có c�p k, n. In hai ma tr�n lên màn hình. Tích hai ma tr�n A và B là ma tr�n C ��#c tính b"i công th�c: c

ij= a

i1*b

1j + a

i2 *b

2j + a

i3 *b

3j + ... + a

ik *b

kj

(i=0,1,2,...m-1;j=0,1,2...n-1)

Tính ma tr�n tích C và in k�t qu lên màn hình.

12. Nh�p s� ph(n t� và các ph(n t� nguyên d��ng c�a mng a. a) In các s� nguyên t� có trong mng a. b) S�p x�p các s� ch.n trong mng theo th� t� t$ng d(n.

13. Vi�t ch��ng trình nh�p vào mng a a) Vi�t hàm kim tra mng ��i x�ng không? N�u có tr v� 1

ng�#c l�i tr v� 0. b) Nh�p mng b, kim tra mng b có phi là mng con c�a

mng a không? N�u có tr v� s� l(n mng b xu�t hi�n trong mng a.

14. Vi�t ch��ng trình theo d�ng hàm: nh�p vào mng nguyên a có n ph(n t� v i : a) Các s� nguyên t� (n�u có) trong mng phi < 100. b) Không có ph(n t� trùng nhau trong mng. c) Tính t�ng các s� nguyên t� trong mng.

15. Vi�t ch��ng trình th�c hi�n các b� c sau: a) Nh�p mng th�c. b) S�p x�p mng th�c theo th� t� t$ng d(n. c) In ph(n t� có s� l(n xu�t hi�n nhi�u nh�t trong mng.

16. Nh�p vào mng a, b theo kiu c�p phát ��ng. V i: a) Các ph(n t� c�a a và b không trùng nhau. b) X�p theo th� t� t$ng d(n hai mng a, b. c) N�i hai mng này l�i thành m�t mng duy nh�t sao cho

mng v!n t$ng. 17. Nh�p vào m�t mng a. Th�c hi�n s�p x�p sau:



a) T�t c các s� l& n�m phía tr� c dãy s�, các s� ch.n n�m phía sau dãy s�, các s� 0 n�m gi�a.

b) Nh�p vào m�t s� x, hãy tìm s� nguyên t� trong a bé h�n và g(n v i x nh�t.

18. Vi�t ch��ng trình nh�p vào mng m�t chi�u có n s� nguyên d��ng. Hãy cho bi�t s� nào trong mng có giá tr� g(n v i trung bình c�ng c�a toàn mng.

19. Nh�p vào m�t mng có n s� nguyên d��ng khác nhau. Hãy in ra t�t c các ph(n t� trong mng có giá tr� nh� h�n giá tr� l n nh�t và l n h�n giá tr� nh� nh�t c�a mng.

20. Vi�t ch��ng trình nh�p ng!u nhiên m�t mng có n s� nguyên d��ng. Nh�p vào m�t s� nguyên d��ng k. Hãy tính trung bình c�ng c�a các ph(n t� trong mng có giá tr� l n h�n hay b�ng k.

21. Nh�p vào m�t dãy s� nguyên d��ng ng!u nhiên (random) có n ph(n t�. Vi�t ch��ng trình in ra s� l n h�n s� nh� nh�t c�a dãy và nh� h�n hay b�ng v i m�i s� còn l�i (ngh+a là tìm s� nh� th� hai trong dãy). N�u n ph(n t� ��u b�ng nhau thì thông báo: không t*n t�i s� c(n tìm.

22. Vi�t ch��ng trình nh�p vào mng s� nguyên có n ph(n t�. Hãy tìm s� ch.n l n nh�t và s� l& nh� nh�t.

23. Hãy nh�p dãy n s� nguyên d��ng có giá tr� trong khong t� 1->100. S�p x�p l�i dãy s� trên theo chi�u t$ng d(n và lo�i b� các ph(n t� trùng nhau (ch, gi� l�i m�t giá tr� trong s� �ó)

24. Hãy nh�p dãy n s� nguyên d��ng có giá tr� trong khong t� 1->100. S�p x�p l�i dãy s� trên theo chi�u t$ng d(n. Nh�p vào m�t s� x nguyên d��ng. Chèn x vào dãy sao cho th� t� c�a dãy không thay ��i.

25. Hãy nh�p dãy n s� nguyên d��ng có giá tr� trong khong t� 1 -> 100. In ra màn hình các s� ch.n xu�t hi�n trong dãy theo th� t� t$ng d(n.

26. Hãy nh�p dãy n s� nguyên d��ng có giá tr� trong khong t� 1->100. In ra giá tr� trung bình c�ng c�a các s� ch.n xu�t hi�n trong dãy.

27. Vi�t ch��ng trình th�c hi�n các công vi�c sau: a) Nh�p vào m�t ma tr�n các giá tr� th�c kích th� c mxn, v i n

và m ��#c nh�p t� bàn phím. b) Tính t�ng các s� d��ng có trong mng.

28. Vi�t ch��ng trình th�c hi�n các công vi�c sau:



a) Nh�p vào m�t ma tr�n các giá tr� th�c kích th� c nxn, v i n ��#c nh�p t� bàn phím.

b) Tìm t�t c các v� trí trong ma tr�n th�a yêu c(u sau: giá tr� c�a ma tr�n t�i v� trí �ó là giá tr� l n nh�t c�a ma tr�n.

29. Vi�t ch��ng trình th�c hi�n công vi�c sau: a) Nh�p vào s� nguyên d��ng N. C�p phát ��ng m�t mng

nguyên A có N ph(n t�. Th�c hi�n vi�c nh�p giá tr� cho mng này.

b) Tìm s� nguyên t� l n nh�t có trong mng. N�u không có phi có thông báo.

30. Vi�t ch��ng trình nh�p vào ma tr�n vuông A(NxN), v i N nh�p vào t� bàn phím. a) In ra t�ng các giá tr� trong tam giác vuông trên c�a ma tr�n

A (k c các ph(n t� trên ��%ng chéo c�a ma tr�n A) In ma tr�n tích AxA ra màn hình.



Ch��ng 5

CON TR� (Pointers)

1. Gi i thi%u Con tr8

M�t con tr� là 1 bi�n ch�a m�t ��a ch, b� nhó. �a ch, này là v� trí c�a m�t ��i t�#ng khác (th�%ng là m�t bi�n) trong b� nh . N�u m�t bi�n ch�a ��a ch, c�a m�t bi�n khác, bi�n th� nh�t ��#c g�i là tr� ��n bi�n th� hai.

Ví d�:

�a ch, b� nh

Bi�n trong b� nh

B� nh

M�t bi n ��c c�p phát ô nh� t�i �a ch# 1000 có giá tr� là �a ch# (1003) c�a 1 bi n khác. Bi n th� nh�t ��c g�i là con tr$.



2. Bi�n con tr8 (pointer variables)

N�u m�t bi�n s� ch�a ��a ch, c�a m�t bi�n khác thì nó phi ��#c khai báo là m�t con tr�. Khai báo 1 bi�n là con tr� g*m kiu d� li�u c� s", m�t d�u *, và tên bi�n. D�ng t�ng quát � khai báo m�t bi�n con tr� là

type *pointerVariable;

type: xác ��nh kiu d� li�u c�a bi�n mà con tr� có th tr� ��n. Ví d� con tr� có kiu int s� tr� ��n bi�n có kiu int. Do các phép toán s� h�c trên con tr� (t$ng, gim) liên quan ��n type c�a nó nên c(n phi khai báo type c�a con tr� �úng ��n.

2.1. Các toán t� con tr8 (pointer operators)

Có 2 toán t� con tr� là * và &.

Toán t� & là toán t� 1 ngôi mà tr v� ��a ch, b� nh c�a toán h�ng c�a nó. (toán t� 1 ngôi ch, yêu c(u 1 toán h�ng).

Ví d�:

int count;

int *m;

m = &count;

L�nh m=&count; ��t ��a ch, b� nh c�a bi�n count vào con tr� m. L�nh trên có th phát biu: "con tr� m nh�n ��a ch, c�a bi�n count.".

Gi s� bi�n count ��#c c�p phát t�i ��a ch, b� nh 2000 � l�u tr� giá tr� c�a nó. Gi s� r�ng count có giá tr� 100. Nh� v�y, t�i ��a ch, b� nh 2000 có ch�a giá tr� 100. Sau khi l�nh m = &count; ��#c th�c hi�n thì m s� có giá tr� là 2000.

Toán t� con tr� * là toán t� m�t ngôi tr v� giá tr� t�i ��a ch, con tr� tr� ��n.

Ví d�: q = *m;

L�y giá tr� t�i ��a ch, mà m tr� ��n và ��t vào bi�n q. Nh� v�y q s� có giá tr� là 100 (là giá tr� c�a bi�n count).



2.2. Các thao tác trên con tr8

2.2.1. L%nh gán con tr8

Ta có th dùng m�t con tr� " bên phi c�a câu l�nh gán (=) � gán giá tr� c�a 1 con tr� cho m�t con tr� khác. Ví d�:

int x;

int *p1, *p2;

p1 = &x;

p2 = p1;

Sau khi ��an l�nh trên ��#c th�c hi�n, c hai p1 và p2 cùng tr� ��n bi�n x.

2.2.2. Phép toán s( h0c trên con tr8

Ch, có 2 phép toán s� h�c ta có th dùng trên con tr� �ó là c�ng và tr�. Gi s� p1 là m�t con tr� nguyên v i giá tr� hi�n t�i là 2000. C)ng gi s� r�ng s� nguyên chi�m 2 bytes b� nh . Nh� v�y, sau khi th�c hi�n l�nh p1++; thì p1 có giá tr� là 2002 ch� không phi 2001. T��ng t�, Gi s� p1 là m�t con tr� nguyên v i giá tr� hi�n t�i là 2000. C)ng gi s� r�ng s� nguyên chi�m 2 bytes b� nh . Nh� v�y, sau khi th�c hi�n l�nh p1--; thì p1 có giá tr� là 1998 ch� không phi 1999.

T�ng quát t� 2 ví d� trên: T�t c con tr� s� t$ng hay gim v i ��n v� là kích th� c c�a kiu d� li�u c�a nó.



Ngoài toán t� t$ng (++) và gim (--), ta có th c�ng hay tr� s� nguyên v i con tr�. Ví d�: theo hình minh h�a trên.

Con tr� char ch ch�a ��a ch, 3000, v�y l�nh

ch = ch + 3;

ch s� ch�a ��a ch, 3003

Con tr� nguyên i ch�a ��a ch, 3000, v�y l�nh

i = i + 2;

i s� ch�a ��a ch, 3004

L�u ý: ��n v� t$ng c�a con tr� char là 1 byte, con tr� int là 2 bytes.

T��ng t�, gi s� con tr� char ch ch�a ��a ch, 3003, v�y l�nh

ch = ch – 3;

ch s� ch�a ��a ch, 3000

Gi� s% ki�u nguyên (int) có kích th�c 2 bytes.

Gi� s% ki�u ký t� (char) có kích th�c 1 byte.



Gi s� con tr� nguyên i ch�a ��a ch, 3004, v�y l�nh

i = i – 2;

i s� ch�a ��a ch, 3000

3. M�t s( ví d& v+ con tr8

Ví d� 1: Vi�t ch��ng trình hoán ��i giá tr� c�a 2 bi�n dùng con tr�

#include <iostream.h> #include<conio.h> void main () {

int a = 20, b = 15; int *pa, *pb, temp; pa = &a; // con tr pa ch�a �a ch� c�a a pb = &b; // con tr pb ch�a �a ch� c�a b temp = *pa; *pa = *pb; *pb = temp; cout << "a = " << a << endl; cout << “b = ” << b; getche();

}

// k�t qu xu�t ra màn hình

a = 15

b = 20

4. C$p phát b� nh ��ng

Con tr� cung c�p s� h� tr# cho c�p phát b� nh ��ng trong C/C++. C�p phát ��ng là ph��ng ti�n nh% �ó m�t ch��ng trình có th dành ��#c thêm b� nh trong khi �ang th�c thi.

Bi�n toàn c�c (global variables) ��#c c�p phát b� nh vào lúc biên d�ch. Bi�n c�c b� (local variables) dùng stack. Tuy nhiên, bi�n toàn c�c hay c�c b� không th ��#c t�o thêm trong khi th�c thi



ch��ng trình. M�t s� ch��ng trình c(n thêm b� nh khi th�c thi, gii pháp cho v�n �� này là c�p phát ��ng.

C/C++ h� tr# hai h� th�ng c�p phát ��ng: m�t cái ��#c ��nh ngh+a b"i C và m�t cái b"i C++.

4.1. C$p phát ��ng �9c ��nh ngh.a b7i C

B� nh c�p phát ��ng b"i nh�ng hàm c�p phát ��ng c�a C là t� heap (heap là vùng nh" r�i n�m gi�a ch��ng trình c�a b�n và vùng l�u tr� th�%ng tr�c và stack). M�c d(u kích th� c vùng nh heap là không bi�t tr� c, nh�ng nói chung là khá l n.

Hai hàm c�p phát ��ng quan tr�ng nh�t c�a C là malloc() và free(). Nh�ng hàm này làm vi�c cùng nhau � dùng vùng nh r�i � c�p phát và thu h*i b� nh . Hàm malloc() dùng � c�p phát b� nh ��ng và hàm free() dùng � thu h*i. B�t k/ ch��ng trình nào dùng nh�ng hàm này phi include t�p tin header stdlib.h.

Hàm malloc() có nguyên m!u (prototype) sau:

void *malloc(length)

length: là s� byte mu�n c�p phát b� nh . Hàm malloc() tr v� m�t con tr� có kiu void, do �ó có th gán nó cho con tr� có kiu b�t k/. Sau khi c�p phát thành công, hàm malloc() tr v� ��a ch, c�a byte �(u tiên c�a vùng nh ��#c c�p phát t� heap. N�u không thành công (không có �� vùng nh r�i yêu c(u), hàm malloc() tr v� null.

�an mã d� i �ây c�p phát 1000 bytes vùng nh liên t�c:

char *p;

p = (char *) malloc(1000); //cp phát 1000 bytes

Vì hàm malloc() tr v� con tr� kiu void, trong tr�%ng h#p này ta phi ép kiu (casting) nó thành con tr� char cho phù h#p v i bi�n con tr� p.

o�n mã d� i �ây c�p phát vùng nh cho 50 s� nguyên.

int *p;



p = (int *) malloc(50*sizeof(int));

L�u ý: trong ví d� trên ta dùng toán t� sizeof � xác ��nh kích th� c kiu d� li�u int.

T� �ó, do kích th� c c�a heap thì không xác ��nh nên khi c�p phát b� nh ta phi kim tra giá tr� tr v� c�a hàm malloc() � bi�t là b� nh có ��#c c�p phát thành công hay không. o�n mã d� i �ây dùng � kim tra:

p = (int *)malloc(100);

if(p == NULL)

{ cout << "Khong du bo nho";

exit(1);

}

Hàm free() thì ng�#c l�i v i hàm malloc(). free() tr v� vùng nh ��#c c�p tr� c �ó cho h� th�ng. Hàm free() có khuôn m!u sau:

void free(void *p);

1 �ây, p là con tr� ��n vùng nh �ã ��#c c�p phát tr� c �ó b"i hàm malloc().

4.2. C$p phát ��ng �9c ��nh ngh.a b7i C++

C++ cung c�p hai toán t� c�p phát b� nh ��ng: new và delete. Nh�ng toán t� này dùng � c�p phát và thu h*i b� nh trong khi ch��ng trình th�c thi.

Toán t� new c�p phát b� nh và tr v� m�t con tr� ��n byte �(u tiên c�a vùng nh ��#c c�p phát. Toán t� delete thu h*i vùng nh ��#c c�p phát tr� c �ó b"i toán t� new. D�ng t�ng quát c�a new và delete là:

p = new type;

delete p;



1 �ây, p là m�t bi�n con tr� mà nh�n ��a ch, c�a vùng nh ��#c c�p phát �� l n � ch�a 1 ��i t�#ng có kiu là type.

Ví d�:

#include <iostream.h> #include <new> int main() {

int *p; p = new int; // allocate space for an int *p = 100; cout << "At " << p << " "; cout << "is the value " << *p << "\n"; delete p; return 0;

}

5. Con tr8 void (void pointers)

Kiu d� li�u khi khai báo bi�n con tr� chính là kiu d� li�u mà con tr� có th tr� ��n. �a ch, ��t vào bi�n con tr� phi cùng kiu v i kiu c�a con tr�. Xem xét ��an mã sau:

int a;

float f;

int *pa;

float *pf;

Nh�ng l�nh sau là h#p l�:

pa = &a;

pf = &f;

Nh�ng l�nh sau là không h#p l�:

pa = &f; //pa là con tr int do ó ch� ch�a �a ch�

//c�a bi�n ki�u int

pf = &a; //pf là con tr float do ó ch� ch�a

// �a ch� c�a bi�n ki�u float



Con tr� void là m�t l�ai con tr� ��c bi�t mà có th tr� ��n b�t k/ kiu d� li�u nào. Cú pháp khai báo con tr� void nh� sau:

void *pointerVariable;

N�u ta khai báo con tr� void sau:

void *p;

thì các l�nh sau �ây là h#p l�

p = &a; //sau l�nh này p tr �n bi�n nguyên a

p = &f; //sau l�nh này p tr �n bi�n th�c f

Tuy nhiên, tùy thu�c con tr� void �ang tr� ��n kiu d� li�u nào, ta phi ép v� �úng kiu t��ng �ng khi dùng trong các biu th�c.

Ví d� p �ang tr� ��n bi�n nguyên a, � t$ng giá tr� c�a bi�n a lên 10 ta phi dùng l�nh sau: (int*)*p + 10;

N�u p �ang tr� ��n bi�n th�c f, � t$ng giá tr� c�a bi�n f lên 10 ta phi d�ng l�nh sau: (float*)*p + 10;

6. Con tr8 null (Null pointers) M�t con tr� hi�n hành không tr� ��n m�t ��a ch, b� nh h#p l� thì ��#c gán giá tr� NULL (mà là zero). B"i qui � c, con tr� NULL là con tr� không tr� ��n �âu c và không nên dùng. NULL ��#c ��nh ngh+a trong <cstdlib>

N�u ch��ng trình vô tình dùng con tr� null nh� d� i �ây thì s� nh�n l�i khi th�c thi ch��ng trình (run-time error). #include <iostream.h> void main() { int *p; cout << “Gia tri con tro p tro den la: “ << *p;

}



K�t qu c�a ch��ng trình trên là:

NULL POINTER ASSIGNMENT

Ch��ng trình trên s� gây ra l�i vào lúc th�c thi vì bi�n con tr� p không ��#c gán ��a ch, b� nh h#p l�. Nó là con tr� null, vì v�y, truy c�p ��n ��a ch, 0 gây ra thông báo l�i trên.

7. Con tr8 và m�ng

Gi�a con tr� và mng có m�t s� quan h� g(n. Xem xét ��an mã d� i �ây:

char ch[10], *p;

p = ch;

ch[0] ch[1] ch[2] ch[3] ch[4] ch[5] ch[6] ch[7] ch[8] ch[9]

1 �ây, p ��#c gán ��a ch, c�a ph(n t� �(u tiên c�a mng ch. tham chi�u ph(n t� th� 3 trong mng ch, ta dùng m�t trong 2 cách sau: ch[2] ho�c *(p+2). C hai cách ��u tham chi�u ��n ph(n t� th� ba trong mng ch (l�u ý ch, m�c c�a mng b�t �(u là 0).

T�ng quát: C/C++ cung c�p hai ph��ng th�c � truy c�p các ph(n t� mng: dùng ch, m�c thông qua tên mng và dùng s� h�c con tr�.

Tên mng ��#c xem là “ con tr� h�ng” ngh+a là nó ch�a ��a ch, c�a ph(n t� �(u tiên trong mng và giá tr� này không bao gi% thay ��i. Do �ó ta không th áp d�ng các phép toán s� h�c (c�ng, tr�) cho tên mng. Nh� v�y, trong ví d� trên ch là tên mng �*ng th%i c)ng là con tr� h�ng và l�nh p = ch; sao chép ��a ch, c�a ch vào bi�n con tr� p.

p p+1 p+2 p+9 ch



Ví d�: In ra giá tr� các ph(n t� c�a mng sau khi �ã nhân cho 10 dùng con tr�

#include <iostream> void main() {

int a[] = {0,1,2,3,4,5,6,7,8,9}; int *p; p = a; for(int i=0 ; i<10 ; i++) { *(p+i) *= 10; //tuong duong a[i] = a[i]*10 cout << “a[“ << i << “] = “ << *(p+i) << ”\n”; }

}

8. M�ng con tr8

M�i bi�n con tr� là m�t bi�n ��n. Ta có th t�o mng c�a các con tr�. M�i ph(n t� c�a mng là m�t con tr� thông th�%ng. Cú pháp � khai báo mng con tr� là:

type *pointerArray[elements];

type: kiu d� li�u mà các con tr� ph(n t� tr� ��n.

pointerArray: tên mng con tr�.

elements: s� ph(n t� c�a mng con tr�.

Ví d�: int *p[5]; l�nh này khai báo mng con tr� p có 5 ph(n t�. Các l�nh d� i �ây minh h�a cách s� d�ng mng này:

p[0] = &a; //gán ��a ch, c�a bi�n nguyên a cho con tr� p[0]

p[2] = p[0]; //sao chép ��a ch, có trong p[0] vào p[2]

b = *p[0]; //gán giá tr� t�i ��a ch, p[0] tr� ��n vào bi�n b. Trong tr�%ng h#p này, l�nh t��ng ��ng v i b=a; vì hi�n t�i p[0] ch�a ��a ch, c�a bi�n a.




1. Vi�t ch��ng trình nh�p vào m�t mng a g*m n ph(n t� nguyên. S�p x�p mng theo chi�u gim d(n (l�u ý s� d�ng tên mng nh� con tr� và s� d�ng con tr�).

2. Hãy dùng m�t vòng for � nh�p vào m�t ma tr�n vuông c�p n v i các ph(n t� th�c và tìm ph(n t� Max c�a ma tr�n này.

3. Vi�t hàm hoán v� hai bi�n th�c a, b b�ng cách s� d�ng con tr� (��i vào là hai con tr�). Vi�t ch��ng trình chính nh�p hai s� th�c a, b. S� d�ng hàm trên � ��i ch� a và b.

4. Vi�t hàm gii h� ph��ng trình b�c nh�t v i sáu ��i vào là a, b, c, d, e, f và 2 ��i ra là x và y.

5. Vi�t hàm tính giá tr� �a th�c:

f(x) = a0xn + … + an-1x + an. v i ��i vào là bi�n nguyên n và

mng th�c a.

6. Vi�t hàm c�ng hai ma tr�n vuông a và b c�p n (s� d�ng con tr�).

7. Vi�t ch��ng trình tính tích phân c�a f(x) trên �o�n [a, b] b�ng công th�c hình thang. Theo �ó, tích phân c�a f(x) trên [a, b] b�ng: h * s. Trong �ó:

h là �� dài khong phân ho�ch �o�n [a, b] thành n khong.

s là t�ng t�t c các f(a+i*h) v i i t� 1 t i n.

S� d�ng hàm trên � tính tích phân trong �o�n [-1, 4] c�a:

f(x) = (ex-2sin(x2))/ (1+x4). (nghiên c�u cách ��a con tr� vào gii quy�t bài toán).



Ch��ng 6

HÀM (Functions)

1. Khái ni%m hàm M�t hàm là m�t kh�i l�nh ��#c ��t tên và có m�t tính ch�t là nó có th ��#c th�c thi t� nhi�u �im khác nhau trong ch��ng trình khi ��#c g�i.

Hàm nhóm m�t s� l�nh thành m�t kh�i và ��#c ��t m�t tên. Kh�i này còn g�i là unit hay module. Hàm có th ��#c g�i t� nhi�u ch� khác nhau trong ch��ng trình. Khi hàm ��#c g�i, kh�i l�nh t��ng �ng c�a hàm ��#c th�c thi. Sau khi th�c hi�n xong, quy�n �i�u khin ��#c tr v� cho ch��ng trình g�i. Xem hình minh h�a dòng th�c thi c�a ch��ng trình có g�i ��n nhi�u hàm.

void main() { . . . f1(); . . . f2(); . . . f3(); . . . }

f1() { ...; ...; }

f2() { ...; ...; }

f3() { ...; ...; }



Hàm còn ��#c g�i là ch��ng trình con (subroutine). Hàm có th tr v� giá tr� cho ch��ng trình g�i ho�c không. N�u hàm không tr v� giá tr� cho ch��ng trình g�i thì nó ��#c g�i là th� t�c (procedure). Hàm có th ��#c g�i t� ch��ng trình chính (hàm main) ho�c t� 1 hàm khác. Hàm có th ��#c g�i nhi�u l(n.

Có hai l�ai hàm: hàm th� vi�n và hàm do ng�%i dùng ��nh ngh+a. Hàm th� vi�n là nh�ng hàm �ã ��#c xây d�ng s.n. Mu�n s� d�ng các hàm th� vi�n trong ch��ng trình ta phi khai báo th� vi�n ch�a nó trong ph(n khai báo #include.

Ví d�: Tìm min c�a 4 giá tr� a,b,c,d


int min(int a, int b); //prototype

void main()

{

int a=40, b=30, c=10, d=20, min4;

min4 = min(a,b);

min4 = min(min4,c);

min4 = min(min4,d);

cout << “Min = “ << min4;

}

int min(int a, int b) { if(a<b) return a; else return b; }

2. D!ng t/ng quát c�a hàm Hàm có d�ng t�ng quát nh� sau:

returnType functionName(parameterList) {

body of the function }



returnType: Kiu d� li�u c�a giá tr� tr v� b"i hàm. N�u hàm không tr v� giá tr� thì returnType là void functionName: Tên hàm. parameterList: Danh sách các tham s� hình th�c ��#c ��t trong c�p d�u (). Là danh sách các tên bi�n và kiu d� li�u t��ng �ng c�a chúng phân cách nhau b"i d�u ph�y. N�u hàm không có tham s� thì danh sách này là r�ng.

Ví d�: xem khai báo hàm sau: int max(int a, int b) { if(a<b) return b; else return a; }

Trong ví d� trên, max là tên hàm, hàm c(n 2 tham s� � h�at ��ng là 2 bi�n nguyên, d� li�u tr v� c�a hàm có kiu int. Ph(n mã n�m gi�a {} là thân hàm.

3. Các qui t2c v+ ph!m vi c�a hàm Hàm gi�ng nh� m�t h�p �en, bên trong hàm (thân hàm) là không bi�t ��i v i nh�ng l�nh n�m ngoài hàm. Ph(n thân c�a hàm ch, ��#c th�c thi khi hàm ��#c g�i. Do �ó, không có l�nh nào bên ngoài hàm có th nhy tr�c ti�p vào thân hàm. Tóm l�i, mã và d� li�u bên trong m�t hàm không th t��ng tác v i mã và d� li�u n�m trong m�t hàm khác. Nh�ng bi�n ��#c khai báo bên trong hàm (k c các tham s� hình th�c) là nh�ng bi�n c�c b�. Nh�ng bi�n này ��#c t�o ra khi hàm ��#c g�i và bi�n m�t sau khi hàm th�c thi xong.

4. Tham s( hình th*c và tham s( th#c Khi hàm c(n nh�n ��i s� (arguments) � th�c thi thì khi khai báo hàm c(n khai báo danh sách các tham s� � nh�n giá tr� t� ch��ng trình g�i. Các tham s� này ��#c g�i là tham s� hình th�c. Khi g�i hàm, ta cung c�p các giá tr� th�t, các giá tr� này s� ��#c sao chép vào các tham s� hình th�c và khi �ó ta g�i chúng là tham s� th�c.



Ví d�: Xem xét ��nh ngh+a hàm sau int min(int a, int b) { if(a<b) return a; else return b; }

Trong ��nh ngh+a hàm min " trên thì a và b là 2 tham s� hình th�c. Khi g�i hàm nh� câu l�nh sau: minAB = min(15,7); thì 15 ��#c sao chép vào bi�n a, 7 ��#c sao chép vào bi�n b. 15 và 7 ��#c g�i là ��i s�. Khi a và b nh�n giá tr� do l%i g�i hàm thì chúng ��#c g�i là tham s� th�c.

Có hai cách truy�n ��i s� vào tham s� hình th�c: Truy�n tham tr� và truy�n tham bi�n.

4.1. Truy+n tham tr� (call by value) Cách này sao chép giá tr� c�a ��i s� vào tham s� hình th�c c�a hàm. Trong tr�%ng h#p này, nh�ng thay ��i c�a tham s� không nh h�"ng ��n ��i s�. Nh� v�y, n�u không mu�n hàm làm thay ��i giá tr� c�a ��i s� truy�n vào thì ta khai báo tham s� c�a hàm là bi�n thông th�%ng (ngh+a là không phi bi�n con tr�).

int min(int a, int b) {

if(a<b) return a; else return b;

}

minAB = min(15,7);

sao chép

��i s� (arguments)

Tham s� hình th�c



Ví d�: Kho sát ch��ng trình sau #include <iostream> void doubleNum(int a); //prototype void main() {

int a=40; doubleNum(a); cout << “\nInside main function: ”; cout << “a = “ << a << endl;

} void doubleNum(int a) { a = a*2; cout << “Inside doubleNum function. a = “ << a; }

Khi ��i s� a c�a hàm main ��#c truy�n vào tham s� a c�a hàm doubleNum thì cách truy�n này là truy�n tham tr�, ngh+a là giá tr� c�a a là 40 ��#c truy�n vào tham s� a. Trong thân hàm doubleNum, tham s� a ��#c nhân �ôi và có giá tr� là 80. Khi hàm doubleNum k�t thúc, bi�n a trong hàm main v!n không thay ��i. 4.2. Truy+n tham chi�u (call by reference) Trong cách này, ��a ch, c�a ��i s� ��#c sao chép vào tham s� hình th�c. Do �ó, nh�ng thay ��i làm ��i v i tham s� s� có tác d�ng trên ��i s�. Ví d� 1: Xem xét ví d� trên ��#c vi�t l�i nh� sau: #include <iostream.h> void doubleNum(int *b); //prototype void main() { int a=40; doubleNum(&a); cout << “\nInside main function:”; cout << “a = “ << a << endl; } void doubleNum(int *b) { *b = *b + *b; cout << “Inside doubleNum function. a = “ << *b; }



Trong ch��ng trình trên, khi g�i hàm doubleNum ta truy�n ��a ch, c�a ��i s� a vào bi�n con tr� b c�a hàm. Nh� v�y, con tr� b s� ch�a ��a ch, c�a bi�n a c�a hàm main. Trong thân hàm doubleNum, l�nh làm g�p �ôi giá tr� c�a vùng nh do con tr� b tr� ��n th�c ch�t �ã làm t$ng g�p �ôi giá tr� c�a bi�n a trong hàm main. Ví d� 2: Hoán ��i giá tr� 2 bi�n dùng con tr� (truy�n tham chi�u) #include <iostream.h>

void swap(int *a, int *b); //prototype

void main()

{

int a = 20, b = 40;

int *pa, *pb;

pa = &a;

pb = &b;

swap(pa,pb);

cout << “After call swap, Values:” << endl;

cout << “a = “ << a << endl;

cout << “b = “ << b << endl;

}

void swap(int *a, int *b) { int temp;

temp = *a; *a = *b; *b = temp;

}

5. Truy+n m�ng vào hàm Khi m�t mng ��#c dùng nh� m�t ��i s� � truy�n cho hàm, ��a ch, c�a mng ��#c truy�n ��n hàm vào tham s� hình th�c. Nh� v�y, truy�n mng vào hàm m�c ��nh là truy�n tham chi�u. Do �ó, nh�ng thay ��i ��n giá tr� c�a các ph(n t� mng trong thân hàm s� nh h�"ng ��n mng g�c.



Ví d�: Vi�t ch��ng trình thay ��i giá tr� các ph(n t� mng theo yêu c(u: n�u giá tr� >=0 thì thay b�ng 1, ng�#c l�i thay b�ng 0.


void change(int a[], int elements); //prototype

void main()

{

int arr[] = {5, -5, -3, 3, 7, -7};

change(arr,6);

cout << “After call change, value of array:\n”;

for(int i=0 ; i<6 ; i++)

cout << “arr[“ <<i<< “] = “ << arr[i] << endl;

}

void change(int a[], int elements) {

for(int i=0 ; i<elements ; i++) if(a[i] < 0) a[i]=0; else a[i] = 1;

}

Nh� v�y, sau khi g�i hàm change, giá tr� các ph(n t� trong mng b� thay ��i thành 0 hay 1. 6. �(i s( c�a hàm main Hàm main là �im b�t �(u c�a m�i ch��ng trình C/C++. Th,nh thong, ta c(n truy�n thông tin vào hàm main khi nó th�c thi. Nh�ng thông tin này ta g�i là ��i s� dòng l�nh (command line arguments). Hàm main có 2 tham s� là argv và argc dùng � nh�n các ��i s� dòng l�nh. Tham s� argc là m�t bi�n nguyên gi� s� ��i s� có trong dòng l�nh. Tham s� argv là m�t mng con tr� char. M�i ph(n t� c�a mng này tr� ��n m�t ��i s� dòng l�nh. T�t c ��i s� dòng l�nh là chu�i (string).



Khi hàm main có nh�n ��i s� dòng l�nh, nó ��#c khai báo nh� sau:

int main(int argc, char *argv[]) Xem xét ch��ng trình sau: #include <iostream.h>

int main(int argc, char *argv[]) {

if(argc!=2) {

count << “Hello, “ << argv[1]; exit(1);

} return 0;

}

Gi s� sau khi biên d�ch ch��ng trình trên, ta ��#c t�p tin th�c thi là greeting.exe T�i d�u nh�c h� �i�u hành DOS, ta nh�p l�nh sau: greeting Mr.IT Thì trên màn hình xu�t hi�n: Hello, Mr.IT L�nh geeting Mr.IT g*m 2 ��i s� dòng l�nh là getting và Mr.IT, các ��i s� này ��#c tr� ��n b"i 2 con tr� là argv[0] và argv[1]. Do �ó, khi th�c thi ch��ng trình trên, chu�i Mr.IT s� ��#c in ra. Khi m�t ch��ng trình không yêu c(u cung c�p ��i s� dòng l�nh, thông th�%ng nó ��#c khai báo là main() mà không có tham s�. ây là m!u ��#c dùng cho h(u h�t các ví d� trong tài li�u này. 7. L%nh return L�nh return có 2 cách dùng quan tr�ng. Th� nh�t, nó k�t thúc ngay l�p t�c hàm ch�a nó khi�n s� th�c thi ch��ng trình ��#c tr v� cho ch��ng trình g�i hàm. Th� hai, nó dùng � tr v� m�t giá tr� cho ch��ng trình g�i.



7.1. Cách dùng th* nh$t (k�t thúc hàm) Có hai cách th�c � hàm k�t thúc s� th�c thi c�a nó và tr �i�u khin v� ch��ng trình g�i nó. M�t là (thông th�%ng) là khi l�nh cu�i cùng có trong hàm ��#c th�c thi. Ví d�: Xem xét ch��ng trình sau: #include <iostream.h>

void printMessage();

void main() { cout << “Calling printMessage: “ <<endl; printMessage(); cout << “Calling printMessage again: “ << endl; printMessage(); } void printMessage() { cout << “This message comes from the printMessage function.” << endl; }

Trong ví d� trên, vì hàm main khai báo kiu tr v� là void nên sau khi th�c thi t�t c các l�nh có trong hàm main, ch��ng trình k�t thúc và tr quy�n �i�u khin v� cho h� �i�u hành. Trong thân hàm main, khi g�i hàm printMessage, �i�u khin ��#c trao cho hàm printMessage, các l�nh trong thân hàm printMessage th�c thi và r*i �i�u khin ��#c tr v� cho ch��ng trình g�i (trong tr�%ng h#p này là hàm main). L�u ý là c hai hàm trên ��u không dùng l�nh return. Hai là khi hàm th�c hi�n câu l�nh return. Ví d�: In các ph(n t� c�a mng ��n khi g�p ph(n t� có giá tr� âm #include <iostream.h>

int main() { int a[] = {3,2,1,0,-1,-2,-3}; for(int i=0 ; i<7 ; i++) { if(a[i] < 0) return 0; cout << a[i] << “\t”; } }



Th�c hi�n ch��ng trình trên, khi duy�t ��n ph(n t� a[4] có giá tr� là -1 nên biu th�c �i�u ki�n c�a câu l�nh if là true nên l�nh return ��#c th�c thi và ch��ng trình k�t thúc. 7.2. Cách dùng th* hai (tr� v+ m�t giá tr�) Xem xét ví d� sau: Tính t�ng các ph(n t� có trong mng


int total(int a[], int size);

void main() { int a1[] = {1,2,3}; int a2[] = {1,2,3,4,5,6}; int total1, total2; total1 = total(a1,3); total2 = total(a2,6); cout << “Tong mang 1 la = “ << total1 << endl; cout << “Tong mang 2 la = “ << total2 << endl; } int total(int a[], int size) { int sum=0;

for(int i=0 ; i<size ; i++) sum += a[i]; return sum; }

Nh� v�y, m�i khi hàm total ��#c g�i, mng t��ng �ng ��#c tính t�ng và l�nh return tr v� giá tr� này cho ch��ng trình g�i. 8. �% qui M�t hàm có th g�i ��n chính nó. M�t hàm ��#c g�i là �� qui n�u m�t l�nh trong thân hàm g�i ��n chính hàm �ó. Ví d�, xem xét ch��ng trình tính giai th�a c�a n. n! = 1*2*..*n




int giaiThua(int n);

void main() { int gt4, gt7; gt4 = giaiThua(4); gt7 = giaiThua(7); cout << “4! =“ << gt4 << endl; cout << “7! =“ << gt7 << endl; } int giaiThua(int n) {

int gt; if(n==1) return(1); gt = giaiThua(n-1)*n; // goi de qui return gt;

}

9. Nguyên m:u hàm (function prototypes) Trong C/C++, t�t c các hàm phi ��#c khai báo tr� c khi chúng ��#c s� d�ng. Vi�c này th�c hi�n b�ng cách khai báo nguyên m!u c�a hàm. Nguyên m!u hàm cho phép C/C++ cung c�p ch�c n$ng kim tra s� h#p l� c�a tham s� khi ��nh ngh+a c)ng nh� khi g�i hàm. Khi biên d�ch, trình biên d�ch s� d�a vào nguyên m!u hàm � kim tra xem có s� không h#p l� nào c�a các ��i s� khi g�i hàm và kiu c�a các tham s� hình th�c trong ��nh ngh+a hàm. Nó c)ng kim tra xem s� ��i s� cung c�p khi g�i hàm có phù h#p v i s� tham s� hình th�c c�a hàm. D�ng t�ng quát c�a m�t nguyên m!u hàm: type functionName(type parameter1, type parameter2, ...);

type: kiu d� li�u tr v� b"i hàm functionName: tên hàm parameter1, parameter2,... : danh sách các tham s� hình th�c và kiu c�a chúng. L�u ý: Khai báo nguyên m!u hàm phi có d�u ch�m ph�y " cu�i. Nh�ng khi ��nh ngh+a hàm thì không có.



10. C$u trúc c�a m�t ch�ng trình vi�t d i d!ng hàm - Ph(n khai báo các th� vi�n - Ph(n khai báo các h�ng toàn c�c (n u có) - Ph(n khai báo các bi�n toàn c�c (n u có) - Ph;n khai báo các nguyên m:u hàm (prototype) - Ph(n hàm main (s� g�i các hàm th�c hi�n) - Ph;n ��nh ngh.a các hàm �ã �9c khai báo prototype

Ví d� : Vi�t ch��ng trình nh�p vào 2 s� nguyên a,b và xu�t ra màn hình s� l n nh�t trong 2 s� (s� d�ng hàm)

#include <iostream.h>// Khai báo th� vi�n iostream.h #include <conio.h>// Khai báo th� vi�n conio.h

int max(int x, int y);// khai báo nguyên m�u hàm max void main()//hàm main (s� g�i các hàm th�c hi�n) {

int a, b;// khai báo bi�n cout<<” Nhap vao 2 so a, b "; cin>>a>>b; cout<<”so lon nhat la:”<< max(a,b); getche();

} int max(int x, int y)// nh ngh�a hàm max(a,b) {

return (x>y) ? x:y; }



BÀI T�P CH��NG 6 Vi�t l�i t�t c bài t�p ch��ng 3 và 4 d� i d�ng hàm.



Ch��ng 7 CHU�I KÝ T�

(Strings) 1. Gi i thi%u Chu,i Trong C/C++, m�t chu�i là m�t mng ký t� v i ký t� null " cu�i chu�i. Ký t� null (‘\0’ ) là ký t� dùng � k�t thúc chu�i. Nh� v�y, m�t chu�i bao g*m các ký t� t�o nên chu�i và theo sau là ký t� null. Khi khai báo m�t mng ký t� dùng � ch�a chu�i, ta c(n khai báo nó dài h�n 1 byte � ch�a ký t� null. Ví d�: � khai báo m�t mng str � ch�a chu�i có �� dài 10 ký t�, ta phi khai báo nh� sau: char str[11]; H�ng chu�i là chu�i ��#c bao quanh b"i c�p d�u nháy �ôi. Ví d�: "Hello" là m�t h�ng chu�i. Ta không c(n thêm ký t� null vào sau chu�i vì trình biên d�ch s� làm �i�u này t� ��ng.

2. Khai báo và kh7i t!o chu,i Có 2 cách khai báo và kh"i t�o chu�i. Gi s� khai báo và kh"i t�o chu�i “ Hello” . Cách 1: Dùng mng m�t chi�u char str[] = {‘H’ ,’ e’ ,’ l’ ,’ l’ ,’ o’ ,’ \0’ }; L�u ý: trong tr�%ng h#p này, ta phái thêm ký t� null vào cu�i. ho�c char str[] = “ Hello” ; L�u ý không cung c�p ký t� null. Chu�i trên ��#c l�u tr� trong b� nh nh� sau:

‘H’ ‘e’ ‘l’ ‘l’ ‘o’ ‘\0’

str[0] str[1] str[2] str[3] str[4] str[5]

ký t� null



Cách 2: Dùng con tr� char *str = “ Hello” ;

3. Nh�p chu,i nh�p d� li�u cho bi�n chu�i, ta dùng hàm gets() c�a th� vi�n stdio.h. Hàm này có cú pháp sau:

char *gets(char *s);

Hàm gets() ��c các ký t� t� bàn phím (stdin) vào trong mng tr� ��n b"i s cho ��n khi nh�n Enter. Ký t� null s� ��#c ��t sau sau ký t� cu�i cùng c�a chu�i nh�p vào trong mng. Ho�c ta có th dùng cin (Console INput). Cú pháp nh� sau:

cin >> s;

4. Xu$t chu,i xu�t chu�i ra màn hình, ta dùng hàm puts() c�a th� vi�n stdio.h. Hàm này có cú pháp sau:

int puts(const char *s);

Ho�c ta có th dùng cout (Console OUTput). Cú pháp nh� sau:

cout << s;

5. M�t s( hàm th vi%n thao tác trên chu,i s� d�ng các hàm này, ta phi khai báo dòng l�nh sau: #include <string.h>

strcpy(s1, s2) Sao chép chu�i s2 vào s1

strcat(s1, s2) N�i chu�i s2 vào cu�i chu�i s1

strlen(s1) Tr v� �� dài c�a chu�i



strcmp(s1, s2) Tr v� 0 n�u s1 và s2 gi�ng nhau, giá tr� nh� h�n 0 n�u s1<s2 và giá tr� l n h�n 0 n�u s1>s2

strchr(s1, ch) Tr v� con tr� ��n v� trí xu�t hi�n �(u tiên c�a ký t� ch trong chu�i s1

strstr(s1, s2) Tr v� con tr� ��n v� trí xu�t hi�n �(u tiên c�a chu�i s2 trong s1

6. M�t s( ví d& v+ chu,i Ví d& 1: #include <stdio.h> #include <iostream.h> #include <string.h> void main() { char s1[80], s2[80]; cout << “Input the first string: “; gets(s1); cout << “Input the second string: “; gets(s2);

cout << "Length of s1= “ << strlen(s1) << endl; cout << "Length of s2= “ << strlen(s2) << endl;

if(!strcmp(s1, s2))

cout << "These strings are equal\n";

strcat(s1, s2); cout << “s1 + s2: “ << s1 << endl;;

strcpy(s1, "This is a test.\n"); cout << s1 << endl;

if(strchr("hello", 'e')) cout << "e is in hello\n";

if(strstr("hi there", "hi")) cout << "found hi";

}



Ví d& 2: Nh�p m�t chu�i str, nh�p m�t ký t� ch. Cho bi�t ch xu�t hi�n bao nhiêu l(n trong chu�i str. #include <stdio.h> #include <iostream.h> #include <string.h> void main() { char str[80], ch; int num=0; cout << “Input str: “; gets(str); cout << “Input ch: “; cin >> ch; for(int i=0 ; i<strlen(str) ; i++) if(str[i] == ch) num++; cout << ch << “ is appeared “ << num << “ times.”;

}

7. M�ng các chu,i t�o m�t mng các chu�i, dùng m�t mng ký t� hai chi�u. Kích th� c c�a ch, m�c th� nh�t là s� chu�i và kích th� c c�a ch, m�c th� hai xác ��nh chi�u dài l n nh�t c�a m�i chu�i. �an mã d� i �ây khai báo m�t mng c�a 5 chu�i, m�i chu�i có chi�u dài t�i �a là 79 ký t�. char str[5][80]; nh�p d� li�u cho chu�i th� nh�t t� bàn phím, ta dùng l�nh: gets(str[0]); cin >> str[0] //Tuong duong voi lenh tren xu�t chu�i th� hai ra màn hình, ta dùng l�nh: puts(str[1]); cout << str[1]; //Tuong duong voi lenh tren



Khai báo và kh"i t�o mng các chu�i char arrayList[][length] = { constantString1, constantString2, ... constantStringN};

arrayList: Tên c�a mng chu�i constantString1, ..., constantStringN : Các h�ng chu�i Ví d�: khai báo m�t mng danh sách các ngôn ng� l�p trình thông d�ng, ta khai báo nh� sau: char listOfPL[][10] = {“ Pascal” , “ C/C++” , “ CSharp” , “ Java” , “ VB” }; Câu l�nh trên s� khai báo mng listOfPL g*m 5 chu�i. Mng chu�i trên ��#c l�u tr� trong b� nh nh� sau:

P a s c a l ‘\0’

C / C + + ‘\0’

C S h a r p ‘\0’

J a v a ‘\0’

V B ‘\0’

L�u ý v� trí c�a các ký t� null Ví d�: Nh�p tên c�a 5 ng�%i dùng mng char hai chi�u, in chúng ra màn hình. #include <stdio.h> #include <iostream.h> #include <string.h> void main()



{ char name[5][20]; for(int i=0 ; i<5 ; i++) {

cout << “Input name “ << i+1 <<”: “; cin >> name[i];

}

cout << “List of names: “; for(int i=0 ; i<5 ; i++)

cout << name[i] << “, “; }

8. M�ng con tr8 ��n các chu,i Ngoài cách dùng mng ký t� hai chi�u � l�u tr� mng các chu�i, ta có th dùng mng c�a các con tr�. M�i con tr� s� ch�a ��a ch, c�a chu�i. C)ng ví d� nh� ph(n trên, ta dùng mng con tr� char *listOfPL[] = {“Pascal”, “C/C++”, “CSharp”, “Java”, “VB”}; Mng con tr� trên có th ��#c l�u tr� trong b� nh nh� sau:

Giá tr� 120 145 189 210 272

�a ch, b� nh 65514 65516 65518 65520 65522

listOfPL[0] listOfPL[1] listOfPL[2] listOfPL[3] listOfPL[4]

P a s c a l ‘\0’

120 C / C + + ‘\0’

145

J a v v ‘\0’

210

C S h a r p ‘\0’

189

V B ‘\0’

172



Ví d�: Nh�p tên c�a 5 ng�%i dùng mng con tr�, in chúng ra màn hình.

#include <stdio.h>


#include <string.h>

#include <stdlib.h>

void main()

{

char *name[5];

for(int i=0 ; i<5 ; i++)

name[i] = (char *)malloc(20);

for(int i=0 ; i<5 ; i++)

{

cout << "Input name " << i+1 <<": ";

gets(name[i]);

}

cout << "List of names: ";

for(int i=0 ; i<5 ; i++)

cout << name[i] << ", ";

}




1. Vi�t ch��ng trình nh�p m�t chu�i ký t� t� bàn phím, xu�t ra màn hình mã ASCII c�a t�ng ký t� v�a nh�p vào (m�i ký t� trên m�t dòng). 2. Vi�t ch��ng trình nh�p m�t chu�i ký t� t� bàn phím, xu�t ra màn hình �o ng�#c c�a chu�i �ó. Ví d� �o c�a “ abcd egh” là “ hge dcba” . 3. Vi�t ch��ng trình nh�p m�t chu�i ký t� và kim tra xem chu�i �ó có ��i x�ng không.

Ví d� : ABCDEDCBA là ��i x�ng. 4. Nh�p vào m�t chu�i ký t� b�t k/, hãy ��m s� l(n xu�t hi�n c�a m�i lo�i ký t�. 5. Vi�t ch��ng trình nh�p vào m�t chu�i ký t�. a) In ra màn hình t� bên trái nh�t và ph(n còn l�i c�a chu�i. Ví d�:

“ Nguy-n V$n Minh” in ra thành: Nguy-n V$n Minh

b) In ra màn hình t� bên phi nh�t và ph(n còn l�i c�a chu�i. Ví d�: “ Nguy-n V$n Minh” in ra thành:

Minh Nguy-n V$n

6. Vi�t ch��ng trình nh�p vào m�t chu�i r*i xu�t chu�i �ó ra màn hình d� i d�ng m�i t� m�t dòng.

Ví d�: “ Nguy-n V$n Minh” In ra :

Nguy-n V$n Minh

7. Vi�t ch��ng trình nh�p vào m�t chu�i, in ra �o ng�#c c�a chu�i �ó theo t�ng t�. Ví d� : “ Nguy-n V$n Minh” �o thành “ Minh V$n Nguy-n” 8. Vi�t ch��ng trình ��i s� ti�n t� s� thành ch�.



9. Vi�t ch��ng trình nh�p vào h� và tên c�a m�t ng�%i, c�t b� các khong tr�ng không c(n thi�t (n�u có), tách tên ra kh�i h� và tên, in tên lên màn hình. Chú ý ��n tr�%ng h#p c h� và tên ch, có m�t t�. 10. Vi�t ch��ng trình nh�p vào h� và tên c�a m�t ng�%i, c�t b� các khong tr�ng bên phi, trái và các khong tr�ng không có ngh+a trong . In ra màn hình toàn b� h� tên ng�%i �ó d� i d�ng ch� hoa, ch� th�%ng. 11. Vi�t ch��ng trình nh�p vào m�t danh sách h� và tên c�a n ng�%i theo kiu ch� th�%ng, ��i các ch� cái �(u c�a h�, tên và ch� lót c�a m�i ng�%i thành ch� hoa. In k�t qu lên màn hình. 12. Vi�t ch��ng trình nh�p vào m�t danh sách h� và tên c�a n ng�%i, tách tên t�ng ng�%i ra kh�i h� và tên r*i s�p x�p danh sách tên theo th� t� t� �in. In danh sách h� và tên sau khi �ã s�p x�p.



Ch��ng 8

STRUCTURES – ENUM - typedef

Ngôn ng� C/C++ ��a ra 5 cách � t�o nên m�t kiu d� li�u tùy bi�n (custom data types). 1. Kiu c�u trúc (structure): Là m�t nhóm c�a các bi�n ��#c ��nh ngh+a d� i m�t tên. Kiu này còn g�i là kiu d� li�u ph�c h#p (compound data types). 2. bit-field: là m�t bi�n th c�a kiu structure và cho phép d- dàng truy c�p ��n t�ng bit riêng r�. 3. Union: cho phép cùng m�t m!u b� nh ��#c ��nh ngh+a nh� hai hay nhi�u kiu bi�n khác nhau. 4. Enumeration: là danh sách c�a c�a các tên h�ng nguyên. 5. T� khóa typedef: ��nh ngh+a m�t tên khác cho m�t kiu d� li�u �ã có. Trong ph(n này ch, tho lu�n structures, enumerations, và typedef.

1. Structures M�t c�u trúc là m�t t�p các bi�n ��#c tham chi�u thông qua m�t tên chung. M�t khai báo c�u trúc hình thành m�t khuôn m!u (template) mà có th dùng � t�o nên các bi�n c�u trúc có cùng kiu. Nh�ng bi�n mà t�o nên c�u trúc ��#c g�i là các thành viên (members).

Nói chung, t�t c các thành viên c�a m�t c�u trúc v� m�t logic là có liên quan v i nhau. Ví d� sau �ây khai báo m�t c�u trúc address g*m các thông tin v� m�t ��a ch,. T� khóa struct dùng � khai báo m�t c�u trúc. Xem xét khai báo sau: struct addr { char name[30];

char street[40]; char city[20]; char state[3]; unsigned long int zip;

};



T�i th%i �im này, ta m i ch, có khai báo m�t c�u trúc. khai báo m�t ho�c nhi�u bi�n có kiu address, ta dùng tên c�u trúc nh� b�t k/ kiu d� li�u nào. Ví d�, � khai báo 2 bi�n kiu address, ta khai báo nh� sau: address addr1, addr2;

Khi m�t bi�n c�u trúc ��#c khai báo, trình biên d�ch t� ��ng c�p phát �� b� nh cho t�t c thành viên c�a c�u trúc. 1.1. D!ng t/ng quát c�a m�t khai báo c$u trúc

struct structureName {

type member1; type member2; ... type memberN; .. .

} varNames;

structureName: Tên c�a c�u trúc type: Kiu d� li�u c�a thành viên t��ng �ng member1, member2, ..., memberN: Tên các bi�n thành viên c�a c�u trúc varNames: Tên các bi�n c�u trúc phân cách nhau b�ng d�u ph�y.

1.2. Truy c�p các thành viên c�a bi�n c$u trúc Toán t� d�u ch�m (dot operator) dùng � truy c�p (access) các thành viên c�a m�t bi�n c�u trúc. D�ng t�ng quát � truy c�p m�t thành viên c�a m�t bi�n c�u trúc là:

structureName.memberName

Ví d�: Xem xét khai báo c�u trúc sau



struct coordXY

{ int x;

int y;

} diemA, diemB;

gán giá tr� t�a �� cho diemA, ta dùng các l�nh sau: diemA.x = 100;

diemA.y = 200;

in t�a �� im A, ta dùng l�nh sau: cout < “A(“ << diemA.x << “,” << diemA.y << “)”;

1.3. L%nh gán c$u trúc N�i dung trong 1 bi�n c�u trúc có th gán cho m�t bi�n c�u trúc khác có cùng kiu dùng m�t câu l�nh gán. Ví d�, � gán n�i dung bi�n c�u trúc pointA cho bi�n pointB, ta th�c hi�n l�nh sau: pointB = pointA;

Sau câu l�nh này, bi�n pointB có cùng n�i dung nh� bi�n pointA. Tuy nhiên, ta c)ng có th sao chép t�ng thành viên nh� sau: pointB.x = pointA.x;

pointB.y = pointA.y;

Ví d�: Khai báo, nh�p và xu�t c�u trúc book g*m các thông tin title, author, pages, price.


#include <stdio.h>

void main()

{ struct book { char title[30];

char author[20];

int pages;

float price;

};

book b;



cout << “Input book information:” << endl;

cout << “Title: “; gets(b.title);

cout << “Author: “; gets(b.author);

cout << “Number of pages: “; cin >> b.pages;

cout << “Price: “; cin >> b.price;

cout << “Information of this book is:” << endl;

cout << “Title: “ << b.title << endl;

cout << “Author: “ << b.author << endl;

cout << “Pages: “ << b.pages << endl;

cout << “Price: “ << b.price << endl;

}

1.4. M�ng các c$u trúc khai báo m�t mng các c�u trúc, �(u tiên ta khai báo c�u trúc, sau �ó khai báo m�t mng c�a c�u trúc �ó. Ví d�, � khai báo mng points có 100 ph(n t�, ta khai báo nh� sau:

coordXY points[100];

truy c�p (access) ��n t�ng thành viên c�a t�ng ph(n t� c�a mng, ta dùng ch, m�c c�a ph(n t� và toán t� thành viên (.). Ví d�, � gán t�a �� x,y cho ph(n t� th� 10, ta dùng các l�nh: points[9].x = 100;

points[9].y = 200;

1.5. Truy+n các c$u trúc vào hàm a. Truy+n các thành viên c�a bi�n c$u trúc vào hàm Khi ta truy�n m�t thành viên c�a m�t c�u trúc vào m�t hàm, ta th�t s� truy�n giá tr� c�a thành viên �ó cho tham s� hình th�c c�a hàm (truy�n tham tr�). N�u mu�n truy�n ��a ch, c�a thành viên cho hàm (truy�n tham chi�u) ta ��t phía tr� c d�u &.



Ví d�: Gi s� ta có hàm int distanceAB(int x1, int y1, int x2, int y2) � tính khong cách gi�a 2 �im. tính khong cách gi�a 2 �im nào �ó, ta truy�n t�a �� x,y c�a 2 �im t��ng �ng. Ta dùng l�nh sau: length1 = distance(pointA.x, pointA.y, pointB.x, pointB.y);

L�nh trên g�i hàm distance và truy�n t�a �� x,y c�a hai �im A,B. K�t qu th�c hi�n hàm tr v� gán cho bi�n length1. truy�n ��a ch, c�a thành viên c�a c�u trúc vào hàm dùng toán t� & ��t phía tr� c tên bi�n c�u trúc ch� không ��t tr� c tên c�a thành viên c�a bi�n c�u trúc. Ví d�: Ta có hàm void move(int *x, int *y, int delta_x, int delta_y); dùng � thay ��i t�a �� x,y c�a m�t �im; delta_x l�#ng di chuyn theo chi�u ngang; delta_y l�#ng di chuyn theo chi�u d�c. V�y, � thay ��i t�a �� bi�n c�u trúc pointA, ta dùng l�nh sau: move(&pointA.x, &pointA.y, 10, 20);

b. Truy+n toàn b� bi�n c$u trúc ��n hàm Khi m�t c�u trúc ��#c dùng nh� m�t ��i s� c�a m�t hàm, toàn b� c�u trúc ��#c truy�n dùng cách truy�n tham tr�. V i cách này, hàm không th làm thay ��i n�i dung c�a ��i s�. Tuy nhiên, n�u mu�n hàm có th làm thay ��i n�i dung c�a ��i s�, ta truy�n tham chi�u (thêm d�u & vào tr� c ��i s�). Ví d� ta có hàm distance2 có khai báo nguyên m!u nh� sau: int distance2(point p1, point p2); g�i hàm trên tính kh�ang cách c�a 2 �im pointA và pointB, ta dùng l�nh sau: length2 = distance2(pointA, pointB); Trong tr�%ng h#p này, ta sao chép n�i dung c�a 2 bi�n c�u trúc pointA, pointB vào 2 tham s� hình th�c p1 và p2 c�a hàm distance2.



1.6. Con tr8 ��n c$u trúc C/C++ cho phép các con tr� ��n các c�u trúc nh� ��n b�t k/ kiu d� li�u nào c�a bi�n. Khai báo m�t con tr� c�u trúc Cú pháp khai báo con tr� c�u trúc gi�ng nh� các l�ai con tr� khác. D�ng t�ng quát � khai báo con tr� c�u trúc:

structureName *structurePointers;

1.7. S� d&ng con tr8 c$u trúc tham chi�u ��n thành viên c�a m�t c�u trúc ��#c tr� ��n b"i m�t con tr�, ta dùng toán t� -> (toán t� tham chi�u g*m m�t d�u tr� và m�t d�u l n h�n).

Xem xét ví d� sau: points *p; //khai báo con tr p có ki�u cu trúc points

p = &pointA; //gán �a ch� c�a bi�n cu trúc pointA cho con tr p

p->x = 100; //gán giá tr� 100 cho thành viên x c�a bi�n cu trúc pointA

L�u ý: truy c�p ��n thành viên c�a m�t c�u trúc, n�u dùng bi�n c�u trúc thì dùng toán t� ch�m (dot operator), n�u dùng bi�n con tr� thì dùng toán t� -> (arrow operator). Khi con tr� c�u trúc ��#c truy�n vào m�t hàm thì hàm có th thay ��i n�i dung c�a bi�n c�u trúc �ó vì cách truy�n này là truy�n tham chi�u.



2. Ki�u li%t kê (Enumerations, enum) M�t enum là m�t t�p c�a các tên h�ng nguyên mà xác ��nh t�t c các giá tr� h#p l� mà m�t bi�n c�a kiu �ó có th có. Ví d�, ta có m�t enum là danh sách giá tr� ti�n t� sau: one$, two$, five$, ten$, twenty$, fifty$, hundred$ D�ng t�ng quát � khai báo m�t enum là

enum enumName {enumList} enumVars;

enum: t� khóa � khai báo enum enumName: Tên c�a enum enumList: Danh sách các tên h�ng nguyên phân cách nhau b"i d�u ph�y enumVars: Tên các bi�n kiu enum.

Ví d�, khai báo enum trên enum money {one$,two$,five$,ten$,twenty$,fifty$,hundred$} m1, m2;

Khai báo hai bi�n m1, m2 có kiu money Kho sát các l�nh sau: m1 = one$;

m2 = ten$;

if(m1 == m2) cout << "They are same.";

if(m1 == one$) cout << "m1 is one dollar.";

if(m2 != five$) cout << "m2 is not five-dollar.";

im quan tr�ng � hiu v� enum là m�i m�t tên trong danh sách enum t�#ng tr�ng cho m�t giá tr� nguyên. Giá tr� c�a tên th� nh�t trong enum là 0, k� ti�p là 1, ... Trong khai báo trên giá tr� c�a các tên l(n l�#t là:

one$ 0 two$ 1 five$ 2



ten$ 3 twenty$ 4 fifty$ 5 hundred$ 6

Ta có th gán giá tr� khác cho m�i tên h�ng nguyên nh� trong câu l�nh sau: enum money {one$=1, two$=2, five$=5, ten$=10, twenty$=20, fifty$=50, hundred$=100}; L�nh này s� gán m�i tên h�ng nguyên m�t giá tr� ��ng sau d�u b�ng.

one$ 1 two$ 2 five$ 5 ten$ 10 twenty$ 20 fifty$ 50 hundred$ 100

3. typedef T� khóa typedef dùng � ��nh ngh+a m�t tên m i cho m�t kiu d� li�u �ã có. D�ng t�ng quát c�a dùng typedef là

typedef existingType newType;

existingType: là b�t k/ kiu d� li�u nào �ã t*n t�i newType: tên m i c�a kiu d� li�u Ví d�: � t�o m�t tên m i cho kiu d� li�u nguyên typedef int int2bytes; //Ki�u int có thêm m�t tên m�i là int2bytes

typedef long int4bytes; //Ki�u long có thêm m�t tên m�i là int4bytes

Sau khi các l�nh trên th�c hi�n thì l�nh long n1, n2; //Khai báo 2 bi�n long

t��ng ��ng int4bytes n1, n2;




1. Cho c�u trúc NHANVIEN nh� sau: - MaNV: kiu s� nguyên có giá tr� trong khong 0… 65535 - H�tên: kiu chu�i. - �ach,: kiu chu�i. - CBQL: có giá tr� 1 n�u nhân viên này là cán b� qun lý. Yêu c(u ch��ng trình th�c hi�n: (a) Vi�t hàm nh�p vào thông tin c�a m�t nhân viên. (b) Vi�t hàm xu�t thông tin c�a m�t nhân viên. (c) Vi�t hàm main có yêu c(u nhâp vào n nhân viên v i n ��#c nh�p t� bàn phím. In ra h� tên c�a các nhân viên là cán b� qun lý. 2. Cho c�u trúc NHANVIEN nh� bài 1: Nh�p vi�t hàm Main có yêu c(u nhâp vào n nhân viên v i n ��#c nh�p t� bàn phím. Xóa các nhân viên không là cán b� qun lý ra kh�i danh sách. 3. Cho c�u trúc NHANVIEN nh� bài 1 Vi�t hàm main có yêu c(u nhâp vào n nhân viên v i n ��#c nh�p t� bàn. Nh�p thêm thông tin c�a m�t nhân viên và nh�p m�t s� nguyên k. Th�c hi�n vi�c chèn nhân viên m i vào danh sách t�i v� trí k.



Ch��ng 9

T�P TIN (Files)

C/C++ h� tr# 2 h� th�ng nh�p xu�t. M�t h� th�ng th�a k� t� ngôn ng� C và m�t h� th�ng nh�p xu�t h� ng ��i t�#ng c�a C++. Trong ch��ng này, ta ch, kho sát h� th�ng th� nh�t. 1. Streams và Files H� th�ng nh�p xu�t c�a C cung c�p m�t giao di�n (interface) nh�t quán cho l�p trình viên mà ��c l�p v i thi�t b� th�t s� mà ch��ng trình t��ng tác. Ngh+a r�ng h� th�ng nh�p xu�t c�a C cung c�p m�t m�c �� tr�u t�#ng gi�a l�p trình viên và thi�t b� nh�p xu�t. S� tr�u t�#ng này ��#c g�i là stream và thi�t b� th�t s� ��#c g�i là file. 2. Streams (dòng nh�p xu$t) H� th�ng file c�a C ��#c thi�t k� � làm vi�c v i nhi�u lo�i thi�t b� khác nhau nh� terminals (thi t b� �u cu�i), các lo�i � �+a, b$ng t�, ... M�c d(u m�i thi�t b� là r�t khác nhau, h� th�ng file chuyn ��i m�i lo�i thành m�t thi�t b� logic g�i là stream. T�t c stream có cùng hành vi. B"i vì stream thì ��c l�p v i thi�t b� nên cùng m�t ho�t ��ng trên stream nh� vi�t vào m�t t�p tin trên �+a c)ng có th dùng � vi�t ��n lo�i thi�t b� khác nh� console (màn hình). Có hai lo�i stream: v$n bn (text) và nh� phân (binary). 2.1. Text Streams M�t text stream là m�t chu�i các ký t�. Trong m�t text stream, m�t s� ký t� có th b� chuyn ��i (��#c hiu nh� là m�t ký t� khác) tùy thu�c môi tr�%ng. Ví d�, ký t� newline ('\n') có th b� ��i thành c�p ký t� carriage return/linefeed (ký t� xu�ng dòng và v" �u dòng). Vì v�y, không có s� quan h� m�t-m�t gi�a các ký t� ��#c vi�t (hay ��c) và nh�ng ký t� trên các thi�t b� ngoài. Do �ó, b"i vì có kh n$ng xy ra s� chuyn ��i, nên s� s� ký t� ��#c vi�t (hay ��c) có th khác s� s� ký t� trên thi�t b� ngoài. 2.2. Binary Streams



M�t binary stream là m�t chu�i bytes mà có s� t��ng �ng m�t-m�t v i chu�i bytes trên thi�t b� ngoài. Ngh+a là không có s� chuyn ��i xy ra. Do �ó, s� bytes ��#c vi�t (hay ��c) thì b�ng v i s� bytes trên thi�t b� ngoài. 3. Files M�t file có th là m�t t�p tin trên �+a, m�t terminal, hay máy in. t�o k�t n�i (associate) gi�a m�t stream v i m�t file ta dùng ho�t ��ng m" (open). M�t khi m�t file ��#c m", thông tin có th ��#c trao ��i gi�a nó và ch��ng trình. Không phi t�t c file ��u có cùng kh n$ng nh� nhau. Ví d�, m�t t�p tin trên �+a (file) có th h� tr# truy xu�t ng!u nhiên trong khi �ó máy in (c)ng là file) thì không th. Vi�c này ��a ��n m�t k�t lu�n là: "T�t c stream là nh� nhau nh�ng file thì không". ng�t k�t n�i gi�a m�t stream v i m�t file ta dùng ho�t ��ng �óng (close). N�u �óng m�t file �ang m" cho xu�t (output) thì n�i dung (n�u có) c�a stream t��ng �ng ��#c vi�t ra thi�t b� ngoài. Qúa trình này ��#c g�i là flushing và �m bo là không có thông tin b� � l�i trong vùng ��m (buffer). T�t c file ��#c t� ��ng �óng khi ch��ng trình m" chúng k�t thúc bình th�%ng. Files không ��#c �óng khi ch��ng trình m" chúng b� k�t thúc b�t th�%ng nh� b� treo (halt) hay khi ch��ng trình th�c hi�n hàm abort(). M�i stream liên � i v i m�t file có m�t c�u trúc kiu FILE. 3.1. C� b�n v+ h% th(ng file C/C++ có nhi�u hàm liên quan nhau ho�t ��ng trên file. Nh�ng hàm này yêu c(u t�p tin header stdio.h. Sau �ây là danh sách các hàm: Tên hàm Ch*c n<ng fopen( ) M" m�t file fclose( ) óng m�t file. putc( ) Vi�t m�t ký t� ��n m�t file. fputc( ) Gi�ng nh� putc() . getc( ) �c m�t ký t� t� m�t file.



fgetc( ) Gi�ng nh� getc() . fgets( ) �c m�t chu�i t� m�t file. fputs( ) Vi�t m�t chu�i ��n m�t file. fseek( ) Tìm m�t byte trong m�t file. ftell( ) Tr v� v� trí hi�n hành c�a c�a file indicator. feof( ) Tr v� true n�u duy�t ��n cu�i file (end-of-file). ferror( ) Tr v� true n�u m�t l�i xy ra. rewind( ) �a indicator v� �(u. remove( ) Xóa m�t file. fflush( ) X h�t vùng ��m c�a file. T�p tin header stdio.h cung c�p các nguyên m!u cho các hàm nh�p xu�t file. Ngoài ra còn có các macro nh� NULL, EOF, FOPEN_MAX, SEEK_SET, SEEK_CUR và SEEK_END. Macro NULL ��nh ngh+a m�t con tr� null. Macro EOF ��#c ��nh ngh+a là -1, là giá tr� tr v� khi hàm ��c file ��n v� trí cu�i c�a file. FOPEN_MAX ��nh ngh+a m�t giá tr� nguyên ch, ra s� file có th m" �*ng th%i. Các macro còn l�i ho�t ��ng v i hàm fseek() � thi hành ho�t ��ng truy c�p file ng!u nhiên. 3.2. Con tr8 file (File pointer) M�t con tr� file là m�t c�u trúc kiu FILE. Nó tr� ��n thông tin mà ��nh ngh+a nhi�u th� v� file nh� tên file, tr�ng thái, và v� trí hi�n hành c�a file. Con tr� file ��#c dùng b"i stream t��ng �ng � th�c hi�n các ho�t ��ng nh�p xu�t trên file. ��c hay vi�t file, ch��ng trình phi dùng con tr� file. khai báo m�t bi�n con tr� file, dùng l�nh:

FILE *fp; 3.3. M7 file Hàm fopen() m" m�t stream � dùng và liên k�t m�t file v i stream �ó. Hàm tr v� m�t con tr� file liên � i v i t�p tin ��#c m". Hàm fopen() có nguyên m!u sau: FILE *fopen(const char *filename, const char *mode);

filename: Là m�t h�ng chu�i ch�a tên (và ��%ng d!n) c�a file mode: Là m�t h�ng chu�i cho bi�t m" file theo mode nào.



Các mode �� m� t�p tin D� i �ây là danh sách các mode � m" m�t t�p tin. "r" N�u t�p tin ��#c m" thành công, hàm fopen() n�p nó vào trong b� nh và tr v� m�t con tr� tr� ��n ký t� �(u tiên c�a t�p tin. N�u không th m" t�p tin, hàm fopen() tr v� NULL Các ho�t ��ng có th làm trên t�p tin: ��c (read) "w" N�u t�p tin t*n t�i, n�i dung c�a nó s� b� vi�t �è. N�u t�p tin không t*n t�i, m�t t�p tin m i ��#c t�o. Tr v� NULL n�u không th m" t�p tin. Các ho�t ��ng có th làm trên t�p tin: vi�t (write) "a" N�u t�p tin ��#c m" thành công, hàm fopen() n�p nó vào trong b� nh và tr v� m�t con tr� tr� ��n ký t� cu�i cùng c�a t�p tin. N�u t�p tin không t*n t�i, m�t t�p tin m i ��#c t�o. Tr v� NULL n�u không th m" t�p tin. Các ho�t ��ng có th làm trên t�p tin: thêm (append) n�i dung m i vào cu�i t�p tin. "r+" N�u t�p tin ��#c m" thành công, hàm fopen() n�p nó vào trong b� nh . Tr v� NULL n�u không th m" t�p tin. Các ho�t ��ng có th làm trên t�p tin: vi�t n�i dung m i vào t�p tin, ��c n�i dung t�p tin, và s�a ��i n�i dung c�a t�p tin. "a+" N�u t�p tin ��#c m" thành công, hàm fopen() n�p nó vào trong b� nh và tr v� m�t con tr� tr� ��n ký t� �(u tiên c�a t�p tin. N�u t�p tin không t*n t�i, m�t t�p tin m i ��#c t�o. Tr v� NULL n�u không th m" t�p tin. Các ho�t ��ng có th làm trên t�p tin: ��c n�i dung t�p tin, vi�t thêm n�i dung m i vào cu�i t�p tin. Không th s�a ��i n�i dung �ang có trong t�p tin. Ví d� sau minh h�a m" m�t file test.txt � vi�t FILE *fp; fp = fopen("test.txt", "w"); o�n mã trên là �úng nh�ng th�c t� �o�n mã trên ��#c vi�t nh� sau:



FILE *fp; if((fp = fopen("test.txt","w")) == NULL) { cout << "Cannot open file"; exit(1); } Ph��ng pháp này s� dò tìm b�t k/ l�i nào khi m" file � vi�t nh� file ��#c bo v� ch�ng ghi hay �+a b� �(y không th t�o thêm file. Nói chung, ta phi luôn kim tra xem vi�c m" file có thành công hay không tr� c khi làm b�t k/ hành ��ng nào trên file. M�t file có th m" " mode text hay binary. M�c ��nh là m" file " text mode. N�u mu�n m" file " binary mode thì thêm ký t� b vào chu�i mode " trên nh� "wb", "rb", ... S� file ��#c phép m" �*ng th%i ��#c xác ��nh b"i macro FOPEN_MAX. Giá tr� này th�%ng nh� nh�t là 8. 3.4. �óng file Hàm fclose() �óng stream ��#c m" b"i hàm fopen(). Khi hàm ��#c g�i, nó s� vi�t b�t k/ d� li�u nào v!n còn trong buffer ��n file r*i �óng file. Hàm fclose() có nguyên m!u sau:

int fclose(FILE *fp); fp: là con tr� file tr v� b"i hàm fopen(). N�u �óng file thành công, hàm tr v� giá tr� zero. N�u m�t l�i xy ra khi �óng file, hàm tr v� EOF. 3.5. Vi�t m�t ký t# ��n m�t file Có hai hàm xu�t ký t� ��n file là putc() và fputc(). Hai hàm này là t��ng ��ng nhau. Hàm putc() vi�t m�t ký t� ��n m�t file �ã ��#c m" b"i hàm fopen(). Nguyên m!u c�a hàm nh� sau:

int putc(int ch, FILE *fp); fp là con tr� file tr v� b"i hàm fopen() và ch là ký t� ��#c vi�t ��n file. N�u ho�t ��ng putc() thành công, nó tr v� ký t� ��#c vi�t vào file. Ng�#c l�i, nó tr v� EOF.



3.6. �0c m�t ký t# t) m�t file Có hai hàm t��ng ��ng � ��c m�t ký t� t� file là getc() và fgetc(). Hàm getc() ��c m�i l(n m�t ký t� t� file ��#c m" b"i hàm fopen() " ch� �� c (read). Nguyên m!u c�a fopen là:

int getc(FILE *fp); fp là con tr� file kiu FILE tr v� b"i hàm fopen(). Hàm getc() tr v� m�t s� nguyên là giá tr� c�a ký t� ��#c ��c. Hàm getc() tr v� EOF n�u m�t l�i xy ra. 3.7. Ví d& minh h0a fopen(), getc(), putc(), và fclose() Ví d� 1: Minh h�a vi�c ��c t� bàn phím và ghi chúng vào m�t t�p tin cho ��n khi ng�%i dùng nh�n nh�p ký t� $. #include <iostream.h> #include <stdio.h> #include <stdlib.h> void main() {

FILE *fp; char ch; if((fp=fopen(“test.txt”, "w"))==NULL) { cout << "Cannot open file.\n";

exit(1); } do {

ch = getchar(); putc(ch, fp);

}while (ch != '$'); fclose(fp);

}

Ví d� 2: Minh h�a vi�c ��c t� m�t file v$n bn và xu�t chúng ra màn hình. #include <iostream.h> #include <stdio.h> #include <stdlib.h> void main() {

FILE *fp;



char ch; if((fp=fopen(”test.txt”, "r"))==NULL) {

cout << "Cannot open file.\n"; exit(1);

} ch = getc(fp); // read one character while (ch!=EOF) {

putchar(ch); // print on screen ch = getc(fp);

} fclose(fp);

}

3.8. �0c và vi�t chu,i trên file C/C++ h� tr# hai hàm fgets() và fputs() � ��c và vi�t chu�i ký t� trên file. Nh�ng hàm này t��ng t� nh� getc() và putc() nh�ng thay vì ��c hay vi�t t�ng ký t�, chúng ��c hay vi�t m�t chu�i. Nguyên m!u c�a các hàm trên nh� sau: int fputs(const char *str, FILE *fp); char *fgets(char *str, int length, FILE *fp);

Hàm fputs() vi�t m�t chu�i tr� ��n b"i str ��n stream tr� ��n b"i con tr� file fp. Hàm tr v� EOF n�u m�t l�i xy ra. Hàm fgets() ��c m�t chu�i t� stream t��ng �ng cho ��n khi g�p ký t� newline hay �ã ��c ��#c length-1 ký t�. Hàm tr v� str n�u ��c thành công và m�t con tr� null n�u không. Ch��ng trình sau minh h�a hàm fputs(). Nó ��c các chu�i t� bàn phím và vi�t chúng ��n file tên teststr.txt. k�t thúc ch��ng trình, nh�p m�t dòng tr�ng #include <iostream.h> #include <stdio.h> #include <stdlib.h> #include <string.h> void main(void) {

char str[80]; FILE *fp;



if((fp = fopen("teststr.txt", "w"))==NULL) {


} do {

cout << "Enter a string (CR to quit):\n"; gets(str); strcat(str, "\n"); /* add a newline */ fputs(str, fp);

} while(*str!='\n'); }

3.9. Hàm fread() và fwrite() ��c và vi�t các kiu d� li�u có kích th� c l n h�n 1 byte, C/C++ cung c�p hai hàm fread() và fwrite(). Nh�ng hàm này cho phép ��c và vi�t m�t kh�i c�a b�t k/ d� li�u nào. Nguyên m!u c�a các hàm này nh� sau: size_t fread(void *buffer, size_t numbytes, size_t count, FILE *fp); size_t fwrite(const void *buffer, size_t numbytes, size_t count, FILE *fp);

�i v i fread(), buffer là m�t con tr� ��n m�t vùng b� nh mà s� nh�n d� li�u ��c t� file. �i v i fwrite(), buffer là m�t con tr� ��n thông tin mà s� vi�t ��n file. Giá tr� c�a count cho bi�t bao nhiêu ph(n t� ��#c ��c hay vi�t v i m�i ph(n t� có �� dài num_bytes. fp là con tr� ��n file �ã ��#c m" b"i fopen(). /* Write some non-character data to a disk file and read it back. */ #include <iostream.h> #include <stdio.h> #include <stdlib.h> void main(void) {

FILE *fp; double d = 12.23; int i = 101; long l = 123023L; if((fp=fopen("testNchar.txt", "wb+"))==NULL) {




} fwrite(&d, sizeof(double), 1, fp); fwrite(&i, sizeof(int), 1, fp); fwrite(&l, sizeof(long), 1, fp); rewind(fp); fread(&d, sizeof(double), 1, fp); fread(&i, sizeof(int), 1, fp); fread(&l, sizeof(long), 1, fp); cout << “double= ” << d << endl; cout << “integer= ” << i << endl; cout << “long= ” << l; fclose(fp);

}

M�t trong nh�ng �ng d�ng h�u d�ng c�a fread() và fwrite() là ��c và vi�t kiu d� li�u ng�%i dùng ��nh ngh+a nh� các c�u trúc. Ví d� 1: Nh�p các m!u tin nhân viên vào t�p tin employee.dat #include <iostream.h> #include <stdio.h> #include <conio.h> void main() {

FILE *fp; struct employee { char name[30]; int age; }; struct employee e; char more = 'Y'; fp = fopen("employee.dat", "wb"); if(fp == NULL) { cout << "Cannot open file"; exit(1); } while(more == 'Y'|| more == ‘y’) { cout << "\nEnter name and age: "; cin >> e.name >> e.age; fwrite(&e, sizeof(e), 1, fp); cout << "Input more (y/n)?: "; fflush(stdin);



more = getche(); } fclose(fp);

}

Ví d� 2: Xu�t các m!u tin nhân viên có trong t�p tin employee.dat #include <iostream.h> #include <stdio.h> #include <conio.h> void main() {

FILE *fp; struct employee { char name[30]; int age; }; struct employee e; fp = fopen("employee.dat", "rb"); if(fp == NULL) { cout << "Cannot open file"; exit(1); } while(fread(&e, sizeof(e), 1, fp) == 1) { cout << "\nName= " << e.name; cout << "\tAge= " << e.age; } fclose(fp);

}

3.10. Hàm rewind() Hàm rewind() di chuyn indicator ��n �im b�t �(u c�a file. Hàm có prototype nh� sau:

void rewind(FILE *fp); 3.11. Hàm ferror() Hàm ferror() cho bi�t m�t ho�t ��ng trên file �ã gây ra l�i. Nguyên m!u c�a hàm nh� sau:

int ferror(FILE *fp);



Hàm tr v� true n�u m�t l�i �ã xy ra v i ho�t ��ng trên file tr� c khi g�i hàm ferror(), ng�#c l�i tr v� false. 3.12. Xóa file Hàm remove() dùng � xóa t�p tin. Nguyên m!u nh� sau:

int remove(const char *filename); Hàm tr v� zero n�u xóa thành công, ng�#c l�i tr v� nonzero 3.13. Flushing a stream Hàm fflush() dùng � xu�t t�t c n�i dung còn l�i trong buffer c�a stream. Hàm có nguyên m!u sau:

int fflush(FILE *fp); Hàm vi�t n�i dung còn trong buffer ��n file liên � i v i fp. N�u ta g�i hàm fflush() không có ��i s� thì t�t c flush t�t c file �ang m". Hàm tr v� 0 n�u thành công, ng�#c l�i tr v� EOF 4. Truy xu$t file ng:u nhiên ��c hay vi�t t� hay ��n m�t v� trí b�t k/ trong file ta c(n s� giúp �3 c�a hàm fseek(). Hàm này dùng � di chuyn ch, báo file. Hàm có nguyên m!u sau: int fseek(FILE *fp, long numbytes, int origin);

fp: là con tr� tr v� b"i hàm fopen() origin: là m�t trong các giá tr� sau: SEEK_SET (t� �(u file), SEEK_CUR (t� v� trí hi�n hành), và SEEK_END (t� cu�i file). numbytes: s� byte mà indicator di chuyn tùy thu�c origin cung c�p. 5. Các stream chu1n Khi m�t ch��ng trình th�c thi, ba stream ��#c m" t� ��ng. ó là stdin (standard input), stdout (standard output), và stderr (standard error). stdin dùng � ��c t� bàn phím, stdout và stderr dùng � vi�t ��n màn hình. B"i vì standard streams là các con tr� file nên có th dùng các hàm nh�p xu�t trên chúng.




Vi�t hàm t�o m�t t�p ch�a 10000 s� nguyên ng!u nhiên khác nhau �ôi m�t trong ph�m vi t� 1 ��n 32767 ��t tên là “ SONGUYEN.INP” 1) Vi�t hàm ��c t�p “ SONGUYEN.INP” , sau �ó s�p x�p theo th�

t� t$ng d(n và l�u k�t qu vào t�p “ SONGUYEN.OUT” 2) Vi�t hàm t�o t�p v$n bn có tên là “ INPUT.TXT” có c�u trúc

nh� sau o Dòng �(u tiên ghi N (N là s� nguyên d��ng nh�p t� bàn phím) o Trong các dòng ti�p theo ghi N s� nguyên ng!u nhiên trong

ph�m vi t� 0 ��n 100, m&i dòng 10 s� (các s� cách nhau ít nh�t m�t d�u cách)

o Hãy ��c d� li�u c�a file “ INPUT.TXT” và l�u vào mng m�t chi�u A Hãy th�c hi�n các công vi�c sau :

a) Tìm giá tr� l n l n nh�t c�a mng A b) �m s� l�#ng s� ch0n, s� l�#ng s� l� c�a mng A c) Hãy s�p x�p các ph(n t� theo th� t� t$ng d(n

Hãy ghi các k�t qu trên vào filetext có tên là “ OUTPUT.TXT” theo m!u sau:

4) Vi�t hàm t�o t�p v$n bn có tên là “ INPUT.TXT” có c�u trúc

nh� sau - Dòng �(u tiên ghi hai s� M và N (M,N là các s� nguyên d��ng

nh�p t� bàn phím)

OUTPUT.TXT Cau a: 99 cau b: 9 9 cau c: 1 4 4 19 20 29 34 38 39 40

43 58 65 78 87 89 98 99

INPUT.TXT 18 87 39 78 19 89 4 40 98 29 65 20 43 1 99 38 34 58 4



- Trong M dòng ti�p theo m�i dòng ghi N s� nguyên ng!u nhiên trong ph�m vi t� 0 ��n 50 (các s� cách nhau ít nh�t m�t d�u cách)

Hãy ��c d� li�u c�a t�p “ INPUT.TXT” và l�u vào mng hai chi�u A. Hãy th�c hi�n các công vi�c sau:

a) Tìm giá tr� l n l n nh�t c�a mng A b) �m s� l�#ng s� ch0n, s� l�#ng s� l� c�a mng A c) Hãy tính t�ng các ph(n t� trên m�i dòng c�a mng A

Hãy ghi các k�t qu trên vào t�p tin v$n bn có tên là “ OUTPUT.TXT” theo nh� m!u trong ví d� sau

INPUT.TXT OUTPUT.TXT

5) Vi�t hàm ��c m�t file “ SONGUYEN.INP” ��#c t�o " bài t�p

1. Sau �ó ghi các s� ch.n vào file SOCHAN.OUT và các s� l& vào file SOLE.OUT.

6) Vi�t m�t hàm g�p n�i dung c�a hai t�p tin có s.n vào m�t t�p

tin th� ba. Tên các t�p tin ��#c nh�p vào t� bàn phím.

7) Vi�t m�t hàm tìm ki�m trên t�p nh� phân có c�u trúc employee g*m tên và tu�i. Hin th� k�t qu là t�t c các thông tin v� các nhân viên ��#c tìm th�y khi cho bi�t :

a) Tên nhân viên b) Có tu�i cao h�n m�t giá tr� X nào �ó.

6 6 41 17 33 23 12 1 44 24 23 49 5 24 33 20 17 25 33 19 0 48 45 48 41 32 10 24 36 19 19 24 30 4 23 26 27 36

Cau a: 49 Cau b: 17 19 Cau c: 127 169 147 214 132 146



Tài li%u tham kh�o 1. Herbert Schildt, The Complete Reference C/C++, Fourth

Edition, McGraw-Hill 2. Yashavant P. Kanetkar, Let Us C, Fifth Edition, BPB Pub.

Giáo Trình PH NG PHÁP L P TRÌNHGiáo trình PP lp trình TT.Công Ngh Thông Tin 4/127 Ch ng 1 T...

Documents

Transcript of Giáo Trình PH NG PHÁP L P TRÌNHGiáo trình PP lp trình TT.Công Ngh Thông Tin 4/127 Ch ng 1 T...