CC

<span class='text_page_counter'>(1)</span><div class='page_container' data-page=1>

Object-Oriented Programming <b>1</b>

Ngôn ngữ lập trình

Với C & C++

Với C & C++

(Lập trình 1)

(Lập trình 1)

Giảng viên

Giảng viên : Phạm DoÃn Tĩnh: Phạm DoÃn Tĩnh
Bộ môn

Bộ môn : §iƯn tư tin häc: §iƯn tư tin häc
Khoa

Khoa : §iƯn tư ViƠn Th«ng: §iƯn tư Viễn Thông<i></i>
Tr ờng

</div>
<span class='text_page_counter'>(2)</span><div class='page_container' data-page=2>

Tài liệu tham khảo

_{Ngôn ngữ lập trình C++ và cấu trúc dữ liệu PGS.TS Nguyễn Việt}<i></i>

H ơng.

_{Kỹ thuật lập trình C GS. Phạm Văn}_ấ_{t NXB Thống kê}

_{The C Programming Language - Ritchie kernighan- Prentice Hall}

Software series.

 _{Practical C Programming, 3rd Edition}_{- Steve Oualline - O'Reilly}
 _{The C++ Programming Language Special 3rd Edition- Bjarne}

Stroustrup – C++ Creator –<b>Addison Wesley</b>

 <b>C++ by Dissection</b> - <b>Ira Pohl (University of California </b>

</div>
<span class='text_page_counter'>(3)</span><div class='page_container' data-page=3>

Object-Oriented Programming <b>3</b>

Ch ơng 1

</div>
<span class='text_page_counter'>(4)</span><div class='page_container' data-page=4>

1.1 Phân tích bài toán

_{Với phần cứng và phần mềm trong tay rồi, ng ời lập trình cần làm}<b></b> <b></b>

gì?

_{Học một ngôn ngữ lập trình.}

_{Vn cn gii quyết cần đ ợc xem xét kỹ l ỡng.}

 _{Ph©n tích bài toán là quá trình làm hoàn tất các møc chi tiÕt cÇn}

thiết khi giải quyết một vấn đề. Nó bao gồm các b ớc chính nh sau:

 _{Vấn đề cần giải quyết phải đ ợc hiểu một cách thấu đáo. Bởi nếu ng ời}

giải quyết ch a hiểu vấn đề thì tất nhiên máy tính cng khụng th gii
quyt tt c

_{Cần phải chọn đ ợc một ph ơng án giải quyết và phát triển ph ơng án.}
_{Tiến trình giải cần đ ợc mô tả d ới dạng từng b ớc từng b ớc một. Đôi khi}

chúng ta gọi là ThuËt gi¶i (Solution algorithm).<b>“</b> <b>”</b>

</div>
<span class='text_page_counter'>(5)</span><div class='page_container' data-page=5>

<i><b>5</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

1.2 Giải thuật và các vấn đề liên quan

 _{Gi¶i thuật là gì?}

<b>_{Giải thuật là một danh sách các chỉ dẫn mô tả một cách chính xác các}</b>

b ớc của một quá trình mà đảm bảo là quá trình này sẽ phải kết thúc sau
một số b ớc nhất định với câu trả lời đúng cho từng tr ờng hợp cụ thể của
một vấn đề cần giải quyết .<b>”</b>

 _{Mỗi thuật giải phải đảm bảo 4 đặc tính sau:}

 _{Sù chÝnh x¸c.}

 _{Tính hiệu quả- Đ a ra câu trả lời đúng.}
 _{Đảm bảo sự kết thỳc.}

_{Tổng quát hoá.}

_{Ví dụ: Giải thuật cho giải ph ơng trình bậc nhất a.x+b=0}

_{B c 1: Xột a =0, nếu đúng tiếp tục b ớc 2, nếu sai tiếp tục b ớc 5.}
 _{B ớc 2: Xét b=0, nếu đúng tiếp tục b ớc 3, nếu sai tiếp tục b ớc 4.}
 _{B ớc 3: Hiển thị vơ số nghiệm và kết thúc.}

 _{B íc 4: HiĨn thị vô nghiệm và kết thúc.}

</div>
<span class='text_page_counter'>(6)</span><div class='page_container' data-page=6>

1.3 Quá trình thiết kế.

_{1.3.1 Đặc tả ch ơng trình.}

_{Xuất phát điểm cho quá trình thiết kế bất kỳ một ch ơng trình máy tính nào cũng}

u phi cú một đặc tả phù hợp về hoạt động của ch ơng trình dự định thực hiện.

 _{Thơng th ờng đặc t ca ch ng trỡnh bo gm:}

_{Mô tả chức năng của ch ơng trình.}
_{Các yêu cầu đầu vào và đầu ra.}
_{Các biện pháp l u trữ dữ liệu.}
_{Các thủ tục quản lý tệp.}

</div>
<span class='text_page_counter'>(7)</span><div class='page_container' data-page=7>

<i><b>7</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

1.3 Quá trình thiết kế.

_{1.3.2 Các kiểu tệp (File types)}

_{Tệp chứa các bản ghi một cách lặp đi lặp lại.}

_{Tuỳ theo việc tổ chức các bản ghi trong tƯp, ng êi ta chia tƯp}
thµnh 4 loại khác nhau:

_{Tệp nối tiếp (Serial file)}

_{Các bản ghi đ ợc ghi nối tiếp nhau theo trình tự thời gian}
đ a bản ghi vào. Ví dụ các bản ghi ghi lại các phiên giao
dịch.

_{Tệp tuần tự (sequential file)}

_{ở đây các bản ghi đ ợc sắp xếp theo trình tự của một}
hoặc nhiều tr ờng khoá.

</div>
<span class='text_page_counter'>(8)</span><div class='page_container' data-page=8>

1.3 Quá trình thiết kế.

_{1.3.2 Các kiểu tệp (File types)}

_{Tệp tuần tự đ ợc chỉ mục (Indexed sequential file)}

_{Thay vì sắp xếp lại toàn bộ tệp, ng ời ta tạo ra các tệp chØ môc}

và trong các tệp này chứa các tr ờng khoá đã sắp xếp đi kèm với
địa chỉ các bản ghi trong tệp chính.

 _{TƯp truy cËp trùc tiÕp (Direct Access file)}

 _{Để có thể truy cập nhanh, mỗi bản ghi sẽ đ ợc ghi vào địa chỉ}

</div>
<span class='text_page_counter'>(9)</span><div class='page_container' data-page=9>

<i><b>9</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

1.3 Quá trình thiết kế.

_{1.3.3 Bảng quyết định (Decision Table)}

 _{Bảng quyết định?}

 _{Bảng quyết định là một bảng chỉ ra các hành động khác nhau đ ợc thực hiện}

dùa theo c¸c sù kết hợp khác nhau của các điều kiện.

Tên điều kiện
(Condition Stub)

Giá trị điều kiện

(Condition Entries)

Tờn hnh ng
(Action Stub)

</div>
<span class='text_page_counter'>(10)</span><div class='page_container' data-page=10>

1.3 Quá trình thiết kế.

_{1.3.3 Bng quyt nh (Decision Table)}

_{Ví dụ: Giả sử một cửa hàng điện tử thực hiện việc giảm giá cho}
khách hàng dựa vào tiêu chí: Khách quen tiêu trên $200 giảm giá
20%, nếu không thì giảm giá 10%. Khách không quen thì tiêu

trên $200 giảm giá 10%, nếu không thì không giảm giá.

1. Khách quen Y Y N N

2. Tiêu trên $200 Y N Y N

Giảm giá 20 % X

Giảm giá 10% X X

Không giảm giá X

</div>
<span class='text_page_counter'>(11)</span><div class='page_container' data-page=11>

<i><b>11</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

1.3.4 KiÓm tra thiÕt kÕ (Design checking)

 _{Sau khi thiết kế xong, chúng ta phải kiểm tra tính đúng đắn của thiết kế. Có rất nhiều}

ph ơng pháp khác nhau để kiểm tra thiết kế.

 _{1. Dry-run.}

 _{Ph ơng pháp này, ng ời kiểm tra dùng giấy bút để tính tốn và ghi lại các b ớc thực}

hiện của ch ơng trình dựa theo một số dữ liƯu thư.

 _{2. Walk through:}

 _{Đây là ph ơng pháp mà ng ời thiết kế mô tả thiết kế của mình cho các đồng nghiệp}

và ghi nhận lại tất cả các đóng góp ý kiến.

 _{Với PP này, cho phép bộc lộ sớm các vấn đề, t ơng tác các thành viên trong nhóm,}

đào tạo lẫn nhau, tiến trình ổn định, tính nhất qn trong thiết kế.

 _{Catalytic Checking.}

 _{Ng ời thiết kế mô tả thiết kế, đồng nghiệp luôn hỏi Tại sao? Làm thế nào? và}<b>_“</b> <b>_{” “}</b> <b>_”</b>

sÏ tù béc lé ra ®iĨm sai trong thiÕt kÕ.

 _{Independent Inspection}

 _{Đây là ph ơng pháp dùng nhiều ng ời độc lập kiểm tra thiết kế d ới sự chỉ đạo của}

</div>
<span class='text_page_counter'>(12)</span><div class='page_container' data-page=12>

<b>1.3.5 Thiết kế h ớng đối t ợng (Object-Oriented Design OOD)</b>

 _{Ph ơng pháp thiết kế h ớng đối t ợng OOD là ph ơng pháp thiết k gm}

có 4 b ớc chính sau đây:

_{1. Xác định các loại đối t ợng (Các lớp – classes) xuất hiện trong}
giải pháp.

 _{2. Xác định và mô tả các biến thể hiện trong mỗi loại đối t ợng.}
 _{3. Xác định các hành động của mỗi một loại đối t ợng.}

 _{4. Đối với mỗi hành động, mơ tả chức năng của nó, các tham số,}
các điều kiện tiên quyết và các hậu điều kiện.

 _{Ví dụ: Giả sử chúng ta cần xây dựng một CTrình tính điểm trung bình}

và lấy ra điểm trung bình cho các sinh viên. Mỗi sinh viên trong lớp đ
ợc có các thông tin sau: tên SV, 3 ®iĨm thi, ®iĨm trung b×nh.

 _{B ớc 1: Xác định các loại đối t ợng, ở đây có 2 loại đối t ợng là}
Sinhvien và Lophoc.

</div>
<span class='text_page_counter'>(13)</span><div class='page_container' data-page=13>

<i><b>13</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

<b>1.3.5 Thiết kế h ớng đối t ợng (Object-Oriented Design OOD)</b>

 _{B ớc 2: Xác định các biến thể hiện của mỗi loại đối t ợng:}

 _{Sinhvien: TenSV, Diem1, Diem2, Diem3, DiemTB}

 _{Lophoc: TenLop,SoSV, DSSV}

 _{B íc 3:}

 _Sinhvien:

_Constructor
_Destructor

_{GetName: Trả lại tên SV}

_{SetName: Đổi tên SV}

_{GetData: Nhập số liệu SV từ bàn phím}
_{ComputeAverage: Tính điểm TB.}

_{DisplayAverage: Hiển thị điểm TB.}

_Lophoc:

_Constructor
 _Destructor

</div>
<span class='text_page_counter'>(14)</span><div class='page_container' data-page=14></div>
<span class='text_page_counter'>(15)</span><div class='page_container' data-page=15>

<i><b>15</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

2 Mô hình lập trình

<b>Structural (Procedural) </b>

<b> Object-Oriented</b>

<b> PROGRAM</b>

<b> PROGRAM</b>

<b>FUNCTION</b>

<b>FUNCTION</b>

<b>FUNCTION</b>

<b>OBJECT</b>

<b>Operations</b>

<b> Data</b>

<b>OBJECT</b>

<b>Operations</b>
<b> Data</b>

<b>OBJECT</b>

</div>
<span class='text_page_counter'>(16)</span><div class='page_container' data-page=16>

Các đặc tính của ngơn ngữ lập trình h ớng đối t ợng

<b>1. Data abstraction (Trừu t ợng hoá dữ liệu)</b>

<b>2. Inheritance of properties (Sù kÕ thõa c¸c thuéc tÝnh)</b>

<b>3. Dynamic binding of operations to objects (Sự ràng buộc </b>
<b>các thao tác với các đối t ợng)</b>

</div>
<span class='text_page_counter'>(17)</span><div class='page_container' data-page=17>

<i><b>17</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

1.5 Thử nghiệm ch ơng trình (testing)

_{Chy th l quỏ trình xác thực một ch ơng trình tuân theo đúng nhng c t}

mà nó cần thực hiện.

_{Testing gồm nh÷ng b íc sau:}

 _{Chän bé d÷ liƯu thư phï hỵp.}

 _{Xác định kết quả đầu ra mong muốn.}
 _{Chạy ch ng trỡnh}

_{Phân tích kết quả đầu ra của ch ơng trình.}

_{Các ph ơng pháp:}

_{Unit testing: Thực hiƯn ë møc module}

 _{Integration testing (test tÝch hỵp): diƠn ra ë møc cao h¬n}

 _{Bottom-up testing: Trong ph ¬ng pháp này thì các module mức thấp đ ợc}

tớch hợp và chạy thử tr ớc, nh vậy ta cần một driver để thực hiện.

 _{Top-down testing: C¸c module mức cao đ ợc tích hợp và chạy thử tr íc,}

lúc đó ta cần các dummy module (module giả) ở mức thấp.

 _{System testing: Đảm bảo rằng toàn bộ ch ơng trình chạy đúng.}

 _{Acceptance testing: Kiểm tra nghiệm thu liên quan nhiều đến ng ời sử}

</div>
<span class='text_page_counter'>(18)</span><div class='page_container' data-page=18>

1.5 Thử nghiệm ch ơng trình (testing)

_{Test data (D÷ liƯu thư)}

 _{Dữ liệu thử là thành phần cốt lõi nhằm đảm bảo tính hiệu quả của}
việc chạy thử ch ơng trình. Nó bao gồm 2 nhiệm vụ:

 _{Chọn bộ dữ liệu thử đầu vào}

_{Xỏc nh kt quả mong đợi ở đầu ra.}
 _{Các loại dữ liệu th:}

_{Dữ liệu tự tạo: Tự tạo theo cách thủ công hoặc dùng bộ ngẫu}
nhiên

_{Dữ liệu sửa từ d÷ liƯu thËt}

</div>
<span class='text_page_counter'>(19)</span><div class='page_container' data-page=19>

<i><b>19</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

1.6 Gì rèi ch ơng trình (Debugging)

_{Gỡ lỗi và chạy thử luôn song hành cùng nhau, gỡ lỗi là quá trình phát}

hiện ra nguồn gốc việc gây lỗi trong chạy thử ch ơng trình.

_{Các ph ơng pháp gỡ lỗi:}

_{G lỗi riêng lẻ: Ng ời lập trình làm việc một mình để tìm ra lỗi.}
 _{Gỡ lỗi theo nhóm: Một nhóm ng ời lập trình cùng tập trung trong}

rà sốt mã nguồn để tìm ra ngun nhân gây lỗi.

 _{Gỡ lỗi tổng hợp: Ch ơng trình giao cho nhiều ng ời, kết quả sẽ đ ợc}
tập hợp lại.

_{Các công cụ gỡ lỗi:}

_{In mà nguồn}

_{Da vo đặc tả chi tiết của ch ơng trình}
 _{Dựa vào flowchart}

_{In kết quả đầu ra.}

</div>
<span class='text_page_counter'>(20)</span><div class='page_container' data-page=20>

1.7 Các giai đoạn trong chu trình sống của một hệ thống

_{D nh ban u}

_{Nghiên cứu tính khả thi}

_{Phân tích yêu cầu của ng ời sử dụng}
_{Phân tích hệ thống}

_{Đặc tả hệ thống}
_{Thiết kế hệ thống}
_{Phát triển hệ thống}
_{Chạy thử}

_{Triển khai}
_{Bảo trì}

</div>
<span class='text_page_counter'>(21)</span><div class='page_container' data-page=21>

<i><b>21</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

1.8 Lập trình h ớng đối t ợng (OOP) và C++

 _{TÝnh trõu t ỵng (Abstraction)}

Lọc ra các đặc tính chính trong khi loại bỏ những cỏi khụng cn thit

_{S úng gúi (Encapsulation)}

ẩn và bảo vệ các các dữ liệu quan trọng thông qua một giao diện có
điều khiển

_{Tính modun hoá (Modularity)}

Chia i t ợng thành các modun nhỏ hơn cho dễ hiểu và dễ thao tác.

 _{Sù ph©n cÊp (hierachy)}

</div>
<span class='text_page_counter'>(22)</span><div class='page_container' data-page=22>

1.8 Lập trình h ớng đối t ợng (OOP) và C++

 _{Data abstraction:}

 _{Cho ta một định nghĩa về đối t ợng}
 _{Ví dụ:}

 _{Ng êi bu«n xe «t« nhìn xe với: Giá, thời hạn bảo hành, màu}
sắc,...

_{Ng ời thợ máy thì nhìn xe với: Kích th ớc lọc dầu,loại bugi,...}

</div>
<span class='text_page_counter'>(23)</span><div class='page_container' data-page=23>

<i><b>23</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

_{Encapsulation:}

_{Phân tích đối t ợng thành các phần}

 _{GiÊu ®i hoặc bảo vệ các thông tin quan trọng}

_{Cung cấp một giao diện cho phép truy cập vào các thuộc tính}
một cách an toàn.

_{Cỏc thụng tin ni bộ có thể bị thay đổi mà khơng làm ảnh h ởng đến}

c¸c bé phËn kh¸c.

 _{VÝ dơ - car radio}

_{Giao diện gồm các núm điều khiển, antena, nguồn}

</div>
<span class='text_page_counter'>(24)</span><div class='page_container' data-page=24>

Ch ơng 2

H ớng dẫn các b ớc lập trình với C++

Giảng viên

Giảng viên : Phạm DoÃn Tĩnh: Phạm DoÃn Tĩnh
Bộ môn

Bộ môn : Điện tử tin häc: §iƯn tư tin häc
Khoa

Khoa : §iƯn tư Viễn Thông: Điện tử Viễn Thông<i></i>
Tr ờng

</div>
<span class='text_page_counter'>(25)</span><div class='page_container' data-page=25>

<i><b>25</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

2.1 Tạo lập và thực hiện một ch ơng trình C++

_{Các công cụ có thể sử dụng trong khoá học này:}

_{Turbo C++ 3.0 trở lên}
_{Borland C++ 4.5 trë lªn}
 _{Microsoft Visual C++ 98 (*)}

Nªn sử dụng Microsoft Visual C++ 98 vì nó chạy trên m«i tr êng

windows dễ sử dụng cũng nh tính năng trong soạn thảo tốt và làm cơ
sở để xây dựng các ứng dụng phức tạp (nh lập trình mạng, kết nối
CSDL,...).

-Khi t¹o mét Project míi:

+Chän Win32 console application<b>“</b> <b>”</b>

+ Chän new -> C++ source file<b>“</b> <b>”</b>

</div>
<span class='text_page_counter'>(26)</span><div class='page_container' data-page=26></div>
<span class='text_page_counter'>(27)</span><div class='page_container' data-page=27>

<i><b>27</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

<i><b>// Program: Display greetings</b></i>

<i><b>// Author(s): Author name</b></i>

<i><b>// Date: 15-Aug-2004</b></i>

<b>#include <iostream></b>
<b>#include <string></b>

<b>using namespace std;</b>

<b>int main() {</b>

<b> cout << "Hello world!" << endl;</b>
<b> return 0;</b>

<b>}</b>

A First Program - Greeting.cpp

C¸c chØ dÉn
tiỊn xư lý

Insertion
statement

Kết thúc main() ng
thi kt thỳc ch ng trỡnh

Lời giải thích

Function

hàm
main()
ám chỉ ch

ơng trình
bắt đầu từ

đây

</div>
<span class='text_page_counter'>(28)</span><div class='page_container' data-page=28></div>
<span class='text_page_counter'>(29)</span><div class='page_container' data-page=29>

<i><b>29</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

<b>#include <iostream></b>
<b>using namespace std;</b>
<b>int main() {</b>

<b> // Extract length and width</b>

<b> cout << "Rectangle dimensions: ";</b>
<b> float Length;</b>

<b> float Width;</b>

<b> cin >> Length >> Width;</b>

<b> // Compute and insert the area</b>
<b> float Area = Length * Width;</b>
<b> </b>

<b>cout << "Area = " << Area << " = Length "</b>
<b> << Length << " * Width " << Width << endl;</b>
<b> return 0;</b>

<b>}</b>

Khai b¸o
NhËp sè liệu

Khai báo kèm
khởi tạo

</div>
<span class='text_page_counter'>(30)</span><div class='page_container' data-page=30></div>
<span class='text_page_counter'>(31)</span><div class='page_container' data-page=31>

Object-Oriented Programming <b>31</b>

Ch ơng 3

Cơ sở lập trình

với ngôn ngữ C

Giảng viên

Giảng viên : Phạm DoÃn Tĩnh: Phạm DoÃn Tĩnh
Bộ môn

Bộ môn : Điện tử tin học: Điện tử tin học
Khoa

Khoa : Điện tử Viễn Thông: Điện tư ViƠn Th«ng<i>––</i>
Tr êng

</div>
<span class='text_page_counter'>(32)</span><div class='page_container' data-page=32>

<b>Giíi thiƯu vài nét về ngôn ngữ lập trình C</b>

_{Vào đầu những năm 1970 Dennis Ritchie tại}

phũng thớ nghim Bell đã xây dựng ngơn ngữ lập

trình C khi cùng Ken Thompson xây dựng hệ điều

hành Unix, khởi đầu C đ ợc dùng trên UNIX.



_{Lý do khiÕn C trở nên phổ biến là do:}

_{C có l ợng tõ kho¸ Ýt.}



_{Là ngơn ngữ nền cho hệ điều hành (Unix).}



_{Nó đã đ ợc chuẩn hố (ANSI C).}



_{Là ngôn ngữ mạnh và hiệu quả.}

</div>
<span class='text_page_counter'>(33)</span><div class='page_container' data-page=33>

<i><b>33</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

 <b>_{Một ch ơng trình C tiêu biểu gồm có các phần sau:}</b>
 _{Các lệnh tiền xử lý (Preprocessor commands)}
_{Cỏc nh ngha kiu (Type definition)}

_{Các nguyên mẫu hàm (Function prototype)}
_{Các biến (variables)}

_{Các hàm}

<b>_{Đặc biệt chú ý là phải có một hàm tên là main()}</b>

_{VÝ dô:}

#include <stdio.h>
void main()

{

printf( Chuong trinh dau tien\n );<b>“</b> <b>”</b>

}

3.1 Cấu trúc của ch ơng trình C

Chỉ dẫn tiền xư lý: sư dơng th viƯn vµo ra chn

Hµm ch ơng trình chính, void ám chỉ không trả lại giá trị<b></b> <b></b>

</div>
<span class='text_page_counter'>(34)</span><div class='page_container' data-page=34>

3.2 Mô tả ngôn ngữ

<b>_{3.2.1 Định danh và từ khoá (identifier & keyword)}</b>

<b>_{Các ký tự cơ bản đ ợc sử dụng trong ch ơng trình C:}</b>

<b>_{Các chữ in th ờng (Lower case): a b c z}</b>

<b>_{Các chữ in hoa (Upper case)}</b> <b>_{: A B C … Z}</b>
<b>_{Các chữ số (Digits)}</b> <b>_{: 0 1 2 … 9}</b>
 <b>_{C¸c ký tù kh¸c:}</b>

<b>+ - * / ( ) { } [ ] < > ' " ! # $ % ^ ~ & | \ ; : , . / ?</b>

 <b>_{C¸c tõ kho¸}</b>

auto do goto signed unsigned

break double if sizeof void

case else int static volatile

char enum long struct while

</div>
<span class='text_page_counter'>(35)</span><div class='page_container' data-page=35>

<i><b>35</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

3.2.1 Định danh và từ khoá (identifier & keyword) (cont)

<b>_{Định danh tên (identifier):}</b><i><b></b></i>

<b>_{ctonờntchuicỏcchcỏi,chsvdugchdi_}</b>
<b>_{Tờnphõnbithoathng}</b>

<b>_{Btubngmtchcỏihocdugchdi_}</b>
<b>_{Tờnphiduynht}</b>

<b>_{Khôngưđượcưsửưdụngưtừưkhoá}</b>

<b>_{ditờnphthuchthng(chophộpnhn31kýt).}</b>
<b>_{Nguyờntcttờnsaochodhiu.}</b>

<b>_{Víưdụ:ưmy_name,ư_your_name,ưfield01}</b>
<b>_{Lờiưgiảiưthíchư(Comment)}</b>

<b>_{TrongC,ligiithớchnhmlmsỏngsahnýnghacacỏccõu}</b>
<b>lnhhaymtkhilnhcachngtrỡnh.</b>

</div>
<span class='text_page_counter'>(36)</span><div class='page_container' data-page=36>

3.2.3 Các kiểu dữ liệu

<b>_{Cách khai báo, viết}</b>
<b>biểu thức và phép gán.</b>
<b>_{Các ký tự và kiểu char}</b>
<b>_{Kiểu dữ liệu int}</b>

<b>_{Các kiểu nguyên}</b>
<b>short, long và </b>
<b>unsigned</b>

<b>_{Kiu du phy ng}</b>
<b>(float)</b>

<b>_{Cách khai báo typedef}</b>
<b>và sizeof</b>

<b>_{Các hàm toán học}</b>

<b>data type</b> <b>size</b> <b>capacity</b>
<b>char</b> <b>1 byte</b> <b>-128 to +127</b>
<b>unsigned </b>

<b>char</b>

<b>1 byte</b> <b>0 to 255</b>

<b>short</b> <b>2 bytes</b> <b>-32,768 to +32,767</b>
<b>unsigned </b>

<b>short</b>

<b>2 bytes</b> <b>0 to 65,535</b>
<b>int</b> <b>2 or 4 </b>

<b>bytes</b>

<b>long</b> <b>4 bytes</b> <b>-2,147,483,648 to </b>
<b>+2,147,483,647</b>
<b>unsigned </b>

<b>long</b>

</div>
<span class='text_page_counter'>(37)</span><div class='page_container' data-page=37>

<i><b>37</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

3.2.3.1 C¸ch khai b¸o, viÕt biểu thức và phép gán

_{Trong C, tt c cỏc bin u nờn khai bỏo u file,}

hàm, hoặc khèi lƯnh.

#include <stdio.h>
#include <conio.h>
void main()

{

int a,b,c;
char x,y;
...

}

<b>•</b>

_{Trong C, mét khèi lệnh đ ợc}

t trong cp du { }

<b>ã</b>

_{Các biến đ ợc khai báo trong}

mt khi thỡ ch cú hiu dng

trong khi ú.

<b>ã</b>

_{Một biểu thức là sự kết hợp:}

Các hằng, các biến, các toán

tử, và các lời gọi hàm. Hầu hết

các biểu thức có trả về giá trị.

<b>ã</b>

_{ví dụ: a+b; c=x*y +z;}

<b>ã</b>

_{Biểu thức có thể đ ợc gán}

</div>
<span class='text_page_counter'>(38)</span><div class='page_container' data-page=38>

3.2.3.2 Xâu kí tự vµ kiĨu char

 _{KiĨu char chiÕm 01 byte trong bé nhí}

máy tính, do đó chúng l u trữ đ ợc tối đa
256 giá trị phân biệt.

 _{Kiểu char đ ợc dùng để l u trữ các chữ}

cái, các chữ số, các dấu chấm câu cũng
nh các kí tự đặc biệt.

 _{Kiểu hằng kí tự đ ợc đặt trong dấu nháy}

đơn , ví dụ nh A , 1 , N ,...<b>‘</b> <b> </b>

_{Các kí tự điều khiển (bảng bên)}

Meaning uses ASCII

Alert \a 7

Backslash \\ 92

Backspace \b 8

Carriage return \r 13
Double quote \<b>“</b> 34

Form-feed \f 12

Horizontal tab \t 9

New-line \n 10

Null character \0 0
Single quote \<b>‘</b> 39
Vertical tab \v 11

KiĨu Ph¹m vi BDiƠn Sè ký tù KÝch th íc

</div>
<span class='text_page_counter'>(39)</span><div class='page_container' data-page=39>

<i><b>39</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

<b>Nhập số liệu kiểu char và hiển thị trên màn hình?</b>

_{Để nhập số liệu kiểu char, ta có thể sử dụng các hàm trong th viện}

<conio.h>:

_{char getch() trả về 1 ký tự từ bàn phím nh ng kô hiển thị trên màn}

hình.

_{char getche() trả vỊ 1 ký tù tõ bµn phÝm nh ng cã hiển thị trên màn}

hình.

_{in 1 ký t trên màn hình, ta dùng định dạng %c, để in d ới dạng}

hexa dùng %x, để in d ới dạng số dùng %d

</div>
<span class='text_page_counter'>(40)</span><div class='page_container' data-page=40>

3.2.3.2 X©u kÝ tù vµ kiĨu char

 _{Mét sè vÝ dơ:}

_{printf("%c", '\a');} _{/* cho ra tiÕng bÝp */}

_{printf("\"Book on C\" is published"); /* In ra x©u Book on C is published}<b>_“</b> <b>_”</b>

*/

_{printf("\'Book on C\' is published"); /* In ra x©u Book on C is published */}<b>_‘</b> <b>_’</b>

_{char c='a';}

_{printf("%c", c); /*In ra màn hình kÝ tù a */}

</div>
<span class='text_page_counter'>(41)</span><div class='page_container' data-page=41>

<i><b>41</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

3.2.3.3 KiÓu nguyên (integer)

_{Kiểu nguyên có thể là 2 bytes (short) hoặc 4 bytes (long)}

Kiểu Phạm vi biểu diễn Kích th íc

int -32768 ~ 32767 2 bytes

unsigned int 0 ~ 65535 2 bytes

long [int] -2147483648 ~ -2147483647 4 bytes
unsigned long [int] 0 ~ 4294967295 4 bytes

Hậu tố cho các số nguyên nh sau:

HËu tè
suffix

KiĨu vÝ dơ

u hc U unsigned 35u

l hc L long 35L

</div>
<span class='text_page_counter'>(42)</span><div class='page_container' data-page=42>

<b>NhËp sè liƯu kiĨu nguyên và hiển thị giá trị nguyên trên màn hình</b>
<b>_{Để nhập giá trị nguyên ta dùng hàm scanf() trong th viện}</b>

<b><stdio.h></b>
<b>_{cú pháp:}</b>

<b>scanf(Định dạng, &bien1, &bien2, );</b>

<b>_{Nếu muốn nhập số liệu vào từ 1 xâu, ta sử dụng}</b>
<b>sscanf(Xau,Định dạng, &bien1, &bien2,)</b>

<b>Ví dụ:</b>

<b>char *s=125;</b>
<b>int i;</b>

<b>sscanf(s,%d,&i);</b>

<b>printf(i=%d \n,i); /* KQ: i=125 */</b>

</div>
<span class='text_page_counter'>(43)</span><div class='page_container' data-page=43>

<i><b>43</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

3.2.3.4 Kiểu dấu phảy động (floating point)

Hậu tố cho các số dấu phảy động:

HËu tè
suffix

KiĨu vÝ dơ

f hc F float 3.5f

l hc L long double 3.5L

Mỗi số dấu phảy động đ c cu thnh t 4 phn:

<b>ã</b>

_{Phần nguyên}

<b>ã</b>

_{Dấu phảy}

<b>ã</b>

_{Phần thập phân}

<b>ã</b>

_{và phÇn mị}

</div>
<span class='text_page_counter'>(44)</span><div class='page_container' data-page=44>

<b>Nhập số dấu phảy động và hiển thị trên màn hình</b>

 _{Để nhập số dấu phảy động ta dùng hàm scanf() trong th viện}

<stdio.h>

 _{cú pháp:}

scanf( Định dạng , &bien1, &bien2, );<b></b> <b></b> <b></b>

_{Nếu muốn nhập số liệu vào từ 1 xâu, ta sử dụng}

sscanf(Xau, Định dạng , &bien1, &bien2, )<b></b> <b>”</b> <b>…</b>

VÝ dô:

char *s= 125.788 ;<b>“</b> <b>”</b>

double f;

sscanf(s, %f ,&f);<b>”</b> <b>”</b>

</div>
<span class='text_page_counter'>(45)</span><div class='page_container' data-page=45>

<i><b>45</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

3.2.3.5 C¸ch khai b¸o typedef và hàm sizeof()

_{Từ khoá typedef cho phép ng ời lập trình khai báo một}

<b></b>

<b></b>

cỏch rõ ràng cho các tên mới, nó làm ch ơng trình sáng

sủa và dễ đọc hơn.

typedef

char uppercase;

typedef

int

INCHES, FEET;

typedef unsigned long

size_t;

uppercase u; /* sử dụng khai báo trên */

</div>
<span class='text_page_counter'>(46)</span><div class='page_container' data-page=46>

_{Hàm sizeof() cho ta biết thông tin về một kiểu dữ liệu nào đó (kích th ớc)}
/* Compute the size of some fundamental types. */

#include <stdio.h>
int main(void) {

printf("The size of some fundamental types is computed.\n\n");
printf(" char:%3d byte \n",sizeof(char));

printf(" short:%3d bytes\n",sizeof(short));
printf("int:%3d bytes\n",sizeof(int));

printf(" long:%3d bytes\n",sizeof(long));

printf(" unsigned:%3d bytes\n",sizeof(unsigned));
printf(" float:%3d bytes\n",sizeof(float));

printf(" double:%3d bytes\n",sizeof(double));

</div>
<span class='text_page_counter'>(47)</span><div class='page_container' data-page=47>

<i><b>47</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

3.2.3.6 C¸c hàm toán học

_{Trong C, các hàm hàm toán học sẵn có trong th viện}

math.h , chẳng hạn nh :

<b></b>

<b></b>

_{double sqrt(double): hàm khai căn}

_{double pow(double,double): hµm l thõa}



_{double exp(double): Hµm mị}



_{double log(double): hµm logarit}

</div>
<span class='text_page_counter'>(48)</span><div class='page_container' data-page=48>

#include <math.h>
#include <stdio.h>
int main(void)

{

double x;

printf("\n%s\n%s\n%s\n\n",
"The square root of x and x
raised",

"to the x power will be
computed.",

"---");

while (1)
{

/* do it forever, endless loop */
printf("Input x: ");

if (x >= 0.0)

printf("\n%15s%22.15e\n%15s%22.15e\n%15s
%22 .15e\n\n",

"x = ", x,

"sqrt(x) = ",sqrt(x),

"pow(x, x) = ",pow(x, x));
else

printf("\nSorry, your number must be
nonnegative.\n\n");

}

return 0;

</div>
<span class='text_page_counter'>(49)</span><div class='page_container' data-page=49>

<i><b>49</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

Bµi tËp

 _{Cho hµm sè:}

 _{HÃy viết 1 ch ơng trình C nhập vào}

x, n (n nguyên) và tính f(x)?

n

3

n

5

7

x

x

6

x

x

5.

f(x)

</div>
<span class='text_page_counter'>(50)</span><div class='page_container' data-page=50>

<b>#include <stdio.h></b>

<b>#include <math.h></b>

<b>void main()</b>

<b>{</b>

<b>double tu,mau;</b>

<b>float x;</b>

<b>int n;</b>

<b>printf("Nhap vao x:"); scanf("%f",&x);</b>

<b>printf("Nhap vao n:"); scanf("%d",&n);</b>

<b>tu=5*powl(x,7)*powl(x,5/n);</b>

</div>
<span class='text_page_counter'>(51)</span><div class='page_container' data-page=51>

<i><b>51</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

3.2.4 C¸c kiĨu h»ng

 _{Hằng ký tự (char) đ ợc biểu diễn trong cặp dấu nháy đơn , ví dụ:}<b>_‘’</b>

a , G ,...

<b>‘ ’ ’ ’</b>

 _{Hằng nguyên đ ợc biểu diễn giống trong tốn học, ví dụ 125, -56, 90}
 _{Các hằng dấu phảy động đ ợc biểu diễn theo hai cỏch:}

_{Giống toán học thông th ờng: 12.56, 28.067}
_{Theo khoa học: 12.34e+2}

_{Các hằng xâu ký tự đ ợc biểu diễn trong cặp dấu nháy kép , khi}<b>_{“ “}</b>

hằng quá dài để viết trên nhiều dịng thì dùng dấu \ để nối dịng, ví
dụ:

 <b>_“</b>_{Day la mot hang xau ky tu}<b>_”</b>

 <b>_“</b>_{Day la hang xau voi\}

_{2 dong}<b></b>

_{Để khai báo hằng chóng ta sư dơng có ph¸p:}

</div>
<span class='text_page_counter'>(52)</span><div class='page_container' data-page=52>

3.3 C¸c to¸n tư

 _{C¸c to¸n tư to¸n häc nh :}

 _{+ phÐp céng}
 _{- phÐp trõ}
 _{* phÐp nh©n}
 _{/ phÐp chia}

 _{% phÐp lÊy phÇn d , vÝ dơ 8 % 3 sÏ cho ta 2.}

 _{C¸c thao tác theo bit}

_& _{phép và theo bit (AND), VD 0xFF & 0xF1 -> 0xF1}
 _| _{Hc theo bit (OR), VD 0x0F | 0xF1 -> 0xFF}

 _^ _{Hoặc loại trừ (XOR), VD 0xFF ^ 0xF1 -> 0x0E}
_~ _{LÊy phÇn bï theo bit, VD ~0 -> 1}

</div>
<span class='text_page_counter'>(53)</span><div class='page_container' data-page=53>

<i><b>53</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

3.3 C¸c to¸n tư

 _{Giá trị logic là đúng true (1) hoặc sai false (0)}<i>_–</i> <i>_–</i>

 _{C¸c phÐp to¸n so s¸nh (cã thứ tự u tiên thấp hơn các phép toán số học)}

Phép

toán ý nghĩa Ví dụ

> Lớn hơn 10 > 8 cho giá trị 1 (true)
>= lớn hơn hoặc bằng 8 >= 9 cho giá trị 0 (false)
< Nhỏ hơn 10 < 3 cho giá trị 0 (false)
<= Nhỏ hơn hoặc bằng 10 <=20 cho giá trị 1 (true)
== Bằng 10==10 cho giá trị 1 (true)
!= Khác 10 !=10 cho giá trị 0 (false)

_{Các phép toán logic}

_{Phộp ph nh một ngơi !, ví dụ 3> 7 cho giá trị 0, !(3 >7) cho giá trị 1}
_{Phép và (AND) &&, ví dụ (3>7) && (5 > 0) cho giá trị 0}

_{PhÐp hc (OR) ||, vÝ dơ (3>7) || (5 > 0) cho giá trị 1}

</div>
<span class='text_page_counter'>(54)</span><div class='page_container' data-page=54>

3.3 Các toán tử

_{Các toán tử tăng giảm (increment and decrement operators)}

_{Chúng đ ợc sử dụng để tăng hoặc giảm giá trị của một biến lên hoặc}

xuống 1 đơn vị.

 _{Chúng có thể đ ợc sử dụng d ới dạng postfix hoặc prefix.}

_{Cú pháp:}

_{ten_bien++, ++ten_bien}
_{ten_bien--, --ten_bien}

_{Dù ở tr ớc hay sau thì giá trị của biến đều tăng lên 1 đơn vị.}

 _{Chúng có mức độ u tiên cao trong một biểu thức.}

 _{Sù khác nhau cơ bản trong postfix và prefix thể hiện qua vÝ dô sau}

#include <stdio.h>
void main() {

int a,b,c=0;

Cho ta kÕt quả:

</div>
<span class='text_page_counter'>(55)</span><div class='page_container' data-page=55>

<i><b>55</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

3.3 Các toán tử

<b>_{Trong C, toán tử gán đ ợc sử dụng là = khác với PASCAL là :=}</b>

<b>_{Ten_bien=bieu_thuc;}</b>
<b>_{Ten_bien=gia_tri;}</b>

<b>_{Ngoài ra trong C còn cho phép ta gán cùng một giá trị cho nhiỊu biÕn}</b>

<b>cïng mét lóc</b>

 <b>_{VÝ dơ:}</b>

 <b>_{int a,b,c,d; a=b=c=d=100;}</b>

 <b>_{a=(b+2)+(c=3); /* tuong duong voi b=2; c=3; a=b+c; */}</b>

<b>_{Các ph ơng pháp gán khác:}</b>

<b>_{Cú pháp:}</b>

<b>_{Ten_bien Toan_tu= bieu_thuc; t ơng đ ơng với}</b>
<b>_{Ten_bien= Ten_bien Toan_tu Bieu_thuc;}</b>

 <b>₊₌</b> <b>_-=</b> <b>_*=</b> <b>_/=</b> <b>_%=</b>

 <b>_>>=</b> <b>_<<=</b> <b>_&=</b> <b>_^=</b> <b>_|=</b>

 <b>_{VÝ dô: j +=3; /* tuong duong j=j+3; */}</b>
<b>_{Biểu thức điều kiện (?):}</b>

<b>_{Cú pháp: s=ex1 ? gt1:gt2;}</b>

 <b>_{Nếu ex1 nhận giá trị đúng (1- true) thì s nhận gt1 nếu không s}</b>

</div>
<span class='text_page_counter'>(56)</span><div class='page_container' data-page=56>

3.3 C¸c to¸n tư

 _{Trong C dÊu , cịng đ ợc xem nh một toán tử, toán tử này có trình tự u}<b></b>

tiên thấp nhất.
Ví dụ int a,b=0,c;
a=100,b=200;

_{Trình tự u tiên của các toán tử nh sau (Từ trên xuống, từ trái qua phải)}

() [] ->> .

- + ++ -- ! ~ * & sizeof (type)

* / % + -

<< >>

< <= > >=

</div>
<span class='text_page_counter'>(57)</span><div class='page_container' data-page=57>

<i><b>57</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

3.3 C¸c to¸n tư

 _{Chuyển đổi kiểu (type casting)}

 _{Trong C, việc chuyển đổi kiểu}
khá linh hoạt.

 _{Cú pháp cho chuyển đổi kiểu}
nh sau:

 _{(type) (bieu_thuc);}
#include <stdio.h>

void main()
{

int a;

double b=10.1,c=20.55;
a=(int)(c-b);

printf( a=%d\n",a);<b>“</b>

}

</div>
<span class='text_page_counter'>(58)</span><div class='page_container' data-page=58>

3.4 Các lệnh điều khiển ch ơng trình

_{Lệnh if ... else}



_{LÖnh switch ... case}



_{LÖnh while(dieu_kien)...}



_{LÖnh do ... while(dieu_kien)}

_{Lệnh for ...}

_{Lệnh break thoát một vòng lỈp}



_{LƯnh continue}

</div>
<span class='text_page_counter'>(59)</span><div class='page_container' data-page=59>

<i><b>59</b></i>

<i><b>Object-Oriented Programming (OOP)</b></i>

3.4.1 LƯnh if



_{Cú pháp:}

if

( expression )

<i>stmt1</i>

;

hoặc

if

( expression )

<i>stmt1</i>

;

else

<i>stmt2</i>

;

_{Khi số câu lệnh trên}

mi nhỏnh r ln hn

1 thì đặt chúng trong

cặp dấu { }

if ( c == 'Y' )
{

printf( "Yes,\n" );

printf( "we have no bananas!\n" )'
bananas = 0;

}

if ( ( c >= 'a' ) && ( c <= 'z' ))
{

printf( "lower case\n" );
++lowers;

}

else if ( ( c >= 'A' ) && ( c <= 'Z' ))
{

</div>
<span class='text_page_counter'>(60)</span><div class='page_container' data-page=60>

3.4.2 Lệnh switch ... case

 _{Câu lệnh switch sử dụng để chọn}

một từ vài nhánh rẽ dựa trên giá trị
một biểu thức nào đó.

 _{Có ph¸p:}

switch( expression )
{
case constant-expr1:
stmt;
break;
case constant-expr2:

stmt;
break;
. . .
default:
stmt
}

 _{VÝ dô:}

switch( c )
{

case 'Y':

printf( "Yes" );
break;

case 'N':

printf( "No" );
break;

default:

</div>
<span class='text_page_counter'>(61)</span><div class='page_container' data-page=61>

<i><b>61</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

Bài tập

_{Viết 1 ch ơng trình C, nhập vào tháng và năm và hiển thị trên màn}

</div>
<span class='text_page_counter'>(62)</span><div class='page_container' data-page=62>

3.4.2 LƯnh switch ... case

 _{Cã thĨ dïng nhiỊu nh·n case}

cho cïng mét nh¸nh:
switch( c )

{

case 'Y':
case 'y':

printf( "Yes" );
break;

case 'N': case 'n':

/* 2 ĐK Cùng dòng */
printf( "No" );

break;
default:

printf( "What?\a" );

switch(month)
{

case 1:case 3: case 5: case 7:case 8:case
12:case 10:

printf("Thang 31 ngay!\n");
break;

case 4:case 6:case 9:case 11:
printf("Thang 30 ngay!\n");
break;

case 2:

if ((year % 4) ==0)

printf("Thang 29 ngay!\n");
else

</div>
<span class='text_page_counter'>(63)</span><div class='page_container' data-page=63>

<i><b>63</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

3.4.3 LÖnh while ...

 _{Câu lệnh while đ ợc sử dụng để lặp lại một lệnh hoặc khối}

lệnh khi biểu thức logic đúng.

 _{Có ph¸p:}

while ( expression )
<i>stmt ; </i>

 _{VÝ dô}

x = 1;

while ( (x * 5) >= (x * x) )
{

printf( "%d %d %d\n", x, x*5, x*x );
x++;

}

 _{Víi c©u lệnh này thì lệnh (khối lệnh) chỉ và chỉ đ îc thùc hiÖn}

</div>
<span class='text_page_counter'>(64)</span><div class='page_container' data-page=64>

3.4.4 LÖnh do ... while

 _{Câu lệnh while đ ợc sử dụng để lặp lại một lệnh hoặc khối lệnh}

khi biểu thức logic đúng.

 _{Có ph¸p}

do

stmt ;

while ( expression );

 _{VÝ dô:}

lng = 0;

do

{

c = getchar();
++lng;

}

</div>
<span class='text_page_counter'>(65)</span><div class='page_container' data-page=65>

<i><b>65</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

3.4.5 LÖnh for (...)

 _{Có ph¸p:}

for ( init-expr; cont-expr; loop-expr )
stmt;

 _{Thùc hiƯn:}

 _{TÝnh to¸n init_expr nÕu cã}
 _{TÝnh to¸n cont-expr nếu có}

_{Nếu cont-expr là true hoặc bỏ qua thì stmt đ ợc thực hiện ít nhất 1 lần,}

ri sau đó loop-expr sẽ đ ợc thực hiện.

 _{Lặp lại 2 b ớc trên đến khi cont-expr là false.}

9 times 0 is 0
9 times 1 is 9
9 times 2 is 18
9 times 3 is 27
9 times 4 is 36
9 times 5 is 45
9 times 6 is 54
9 times 7 is 63
9 times 8 is 72
9 times 9 is 81

/* B¶ng cưu ch ¬ng */
#define MAX 9

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

for ( j = 0; j <= MAX; j++ )
{

printf( "%d times %d is %d\n", i, j, i*j );
}

}

</div>
<span class='text_page_counter'>(66)</span><div class='page_container' data-page=66>

3.4.6 LƯnh break tho¸t một vòng lặp

_{Với các vòng lặp for,}

while, do ... while thì lệnh

break thốt khỏi vịng lặp

ở mức thấp nhất mà tại

đó lệnh break xuất hiện!

 _{VÝ dô:}

int c,max=10;

printf( "Enter up to %d chars", max );
for ( i = 0; i < max; i++ )

{

c = getchar();

if ( c == EOF || c == '\n' )
{

break;
}

putchar( 255 - c ); /* encrypt char
*/

</div>
<span class='text_page_counter'>(67)</span><div class='page_container' data-page=67>

<i><b>67</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

3.4.7 LƯnh goto chun ®iỊu khiĨn ch ơng trình

_{Lnh goto dựng}

chuyển điều khiển của ch

ơng trình tới một nhÃn

(label) no ú.

_{Cú pháp: goto label;}

_{ở đây label có cú pháp:}

_{Ten_label:}

{

Khoi_lenh_cua_label;

}

_{Nói chung là nên hạn chế}

dùng lệnh này, vì nó là

lệnh chuyển điều khiển

phi cấu trúc.

#include <stdio.h>
#include <conio.h>
void main()
{
int i,max=10,linelng;
char c;

printf( "Enter %d lines...\n", max );

for ( i = 1; i <= max; i++ )

{

linelng = 0;

while ( ( c = getchar() ) != '\n' )
{

if ( c == EOF )
{

goto SickOfIt;
}

++linelng;
}

printf( "Length of line %d is %d\n",
i, linelng );

}

SickOfIt:

</div>
<span class='text_page_counter'>(68)</span><div class='page_container' data-page=68>

Bµi tËp

 _{1. Viết 1 ch ơng trình C, nhập vào N số (N xác định bằng cách nhập}

tõ bµn phím).

_{Tính giá trị trung bình của các số d ơng?}

_{2. Viết 1 ch ơng trình nhập vào 1 dÃy các ký tự và đ a ra thống kª xem}

có bao nhiêu chữ cái, bao nhiêu chữ số, bao nhiêu ký tự đặc biệt?

 _{3. Cho:}

 _{A(n)= 1+2 + 3 + 5 + 8 + ... a}

n-2 +an-1 + an
 _{Víi a}

0 =1, a1 =2.
 _{vµ an = an-2 + an-1}

</div>
<span class='text_page_counter'>(69)</span><div class='page_container' data-page=69>

<i><b>69</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

3.5 Mảng (array)

_{Mảng là một kiểu cấu trúc dữ liệu dùng l u trữ nhiều phần}

tử dữ liệu cùng kiểu.

_{Khai báo giống nh biÕn th«ng th êng, trõ viƯc ta chØ ra sè}

chiều và số phần tử mảng.

_{Các phần tử có thể đ ợc khởi tạo giá trị ban đầu, khi ® ỵc}

khởi tạo giá trị đầu, chiều đầu tiên có thể bỏ qua và để ch

ơng trình dịch t tớnh.

_{Mỗi phần tử mảng đ ợc truy cập thông qua tên mảng và}

</div>
<span class='text_page_counter'>(70)</span><div class='page_container' data-page=70>

3.5.1 Khai báo và khởi tạo mảng

<b>_{Cú pháp:}</b>

<b>data_type array_name[so_phan_tu];</b>
<b>Ví dụ:</b>

<b>int a[10]; /* Khai báo mảng 10 số nguyên */</b>
<b>char my_name[35]; /* Khai mét x©u 35 ký tù */</b>

 <b>_{Khi muèn khởi tạo (initialize) các phần tử mảng ta đ a các giá trị khởi tạo}</b>

<b>vào dấu {gt1,gt2,...,gtN }</b>

<b>_{Với phần tử ch a khởi tạo thì giá trị của nó bằng 0.}</b>

<b>_{Khi đ ợc khởi tạo giá trị ®Çu, cã thĨ bá tham sè chiỊu (compiler sÏ}</b>

<b>tự động tính tốn)</b>

 <b>_{VÝ dơ:}</b>

<b>char whitesp[5] = {'\n','\t',' ','\r','\f'}; /* Mảng chứa các ký tự trắng */</b>

<b>int prodcod[] = { 16, 60, 75, 101, 17 }; /* Mảng chứa các m· s¶n phÈm */</b>

 <b>_{Ta có thể sử dụng sizeof() để xác định số phần tử mảng:}</b>

</div>
<span class='text_page_counter'>(71)</span><div class='page_container' data-page=71>

<i><b>71</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

3.5.2 Truy cập các phần tử mảng.

<b>_{Các phần tử mảng đ ợc truy}</b>

<b>cập dùng cú pháp:</b>

<b>ten_mang[chi_so_phan_tu];</b>

<b>_{Chỉ số của phần tử đầu tiên}</b>

<b>là 0.</b>

<b>Ví dụ</b>

<b>int Larry[5] = { 5, 10, 15, 20, 25 };</b>
<b>int i, Curly; tot = 0;</b>

<b>Curly = Larry[0]; /* Curly <-- 5 */</b>
<b>Curly = Larry[3]; /* Curly <-- 20 */ </b>
<b>Curly = Larry[4]; /* Curly <-- 25 */ </b>
<b>i = 1;</b>

<b>Curly = Larry[i]; /* Curly <-- 10 */ </b>

<b>Larry[0] = 30; /* Larry=30,10,15,20,25 </b>
<b>*/</b>

<b>/* sum and print all array elements */</b>
<b>for ( i = 0; i < 5; i++ )</b>

<b>{</b>

<b> printf( "%d", Larry[i] );</b>
<b> tot += Larry[i];</b>

<b>}</b>

<b>/* increment each array element */</b>
<b>for ( i = 0; i < 5; i++ )</b>

<b>{</b>

</div>
<span class='text_page_counter'>(72)</span><div class='page_container' data-page=72>

3.5.3 M¶ng nhiỊu chiỊu

 _{M¶ng nhiỊu chiỊu khai báo t ơng tự nh}

mảng 1 chiều, chỉ có điều ta thêm
chiều bằng các cặp dấu [].

_{Để truy cập ta dùng các chỉ số t ơng}

ứng.

_{Ví dụ:}

/* Khai báo mảng 4 hàng, 3 cột */
int hah[4][3];

Sự phân bố vị trí trong bộ nhớ nh hình vẽ
bên.

_{Để duyệt mảng nhiều chiều dùng vòng}

lặp lồng nhau.

_{Để khởi tạo mảng nhiều chiều}

int a[2][3]={{1,2,3},{4,5,6}};

#define NROWS 15 /* symbol for # rows
*/

#define NCOLS 24 /* symbol for # cols */
int i, j;

long mx[NROWS][NCOLS], totmx;
double pct[NROWS][NCOLS];
... /* Nhập mảng */

/* Tổng các PT m¶ng */
for ( i = 0; i < NROWS; i++ )
{

for ( j = 0; j < NCOLS; j++ )

{

totmx += mx[i][j];
}

}

/* compute pct of total for each */
if ( totmx != 0 )

{

</div>
<span class='text_page_counter'>(73)</span><div class='page_container' data-page=73>

<i><b>73</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

3.6 Con trá (pointer)

 _{Trong ch ơng trình, mỗi biến chiếm}

mt s bytes nht nh và l u ở một vị
trí cụ thể trong bộ nhớ máy tính.

 _{Con trỏ thực chất là một loại biến đặc}

biệt đ ợc sử dụng để l u địa chỉ một ơ
nhớ cụ thể nào đó hoặc l u địa chỉ của
một biến khác.

 _{Khai báo:}

Data_Type *pointer_var_name;
hoặc

Data_Type* pointer_var_name;

_{Để khởi tạo giá trị của con trá, ta cã}

thể cho nó trỏ vào một địa chỉ nhớ cụ
thể hoặc lấy địa chỉ của một biến
khác thơng qua tốn tử lấy địa chỉ

& .

<b>“ ”</b>

 _{Để truy cập vào ô nhớ tại a ch m}

con trỏ đang trỏ tới dùng toán tử tham
chiếu ng ợc *, với cú pháp:

*Ten_contro = gia_tri;
hoặc

ten_bien=*Ten_contro;

_{Ví dụ:}

int *int_ptr; /* Khai báo con trá int */
float *float_ptr; /* Con trá float */
int a;

char b;
int *ip=&i;
char *cp=&b;

int i=3, j=5, *p=&i, *q=&j, *r;
double x;

p==&i p==(&i) 1
**&p *(*&p) 3

r=&x r=(&x) illegal

</div>
<span class='text_page_counter'>(74)</span><div class='page_container' data-page=74>

3.6 Con trỏ (pointer) (tiếp)

 _{Bên cạnh con trỏ xác định kiểu,}

ta cßn cã thĨ dïng con trá

khơng xác định kiểu (void *) để l
u trữ địa chỉ của bất kỳ ô nhớ
nào. Nh ng l u ý với con trỏ này
khi truy cập ô nhớ mà nó trỏ tới
cần chuyển đổi kiểu t ơng ứng!

 _{Ngoài ra ta còn có thể dùng các}

phộp toỏn số học đối với con trỏ.
int *p1;

char *p2;

float *p3;

++p1; /* p1 tăng lên 4~4 bytes */
++p2; /* p2 tăng lªn 1~1 byte */

#include <stdio.h>
void main()

{

short i=10, *p1=&i;
char c='A',*p2=&c;
float f=100.8,*p3=&f;

printf("p1=%p p2=%p p3=
%p\n",p1,p2,p3);

printf("++p1=%p ++p2=\

%p
--p3=%p\n",++p1,++p2,--p3);

</div>
<span class='text_page_counter'>(75)</span><div class='page_container' data-page=75>

<i><b>75</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

3.7 Mèi liên hệ giữa con trỏ và mảng

<b>_{Bn thõn tờn mảng là địa chỉ}</b>
<b>của phần tử đầu tiên trong </b>
<b>mảng</b>

 <b>_{VÝ dơ:}</b>
<b>int a[100],*p;</b>

<b>Khi đó a[i] *(a+i)</b>

<b>p=a+1</b>
<b>p=&a[1];</b>

<b>#define N 100</b>

<b>int a[N], i, *p, sum=0;p=a;</b>
<b>p=&a[0];</b>

for (p=a;p<&a[N]; p++) for (i=0;i<N;i++)
sum+=*p; sum+=a[i];

for (i=0;i<N;i++) p=a;

</div>
<span class='text_page_counter'>(76)</span><div class='page_container' data-page=76>

3.8 CÊu trúc struct

_{Để khai báo cấu trúc ta dùng}

cú ph¸p:

 _{struct struct_name}

{

type1 field1;

type2 field2;
...

} [bien_co_kieu_struct_name];

 _{Để truy cập đến các thuộc tính}

cđa struct ta sư dơng to¸n tư
.

<b> </b>

_{Ta có thể khởi tạo giá trị cho}

một biến struct giống nh đối
với mảng , đặt các giá trị trong
cặp dấu { } phân cách giá trị

#include <stdio.h>
struct emp
{
int empno;
char ename[35];
};
void main()
{

struct emp e1={100, Nguyen <b>”</b>

X };<b>”</b>

printf( ENo:%d, Ename:\ <b>“</b>

</div>
<span class='text_page_counter'>(77)</span><div class='page_container' data-page=77>

<i><b>77</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

3.9 Hỵp Union

 _{Víi cÊu tróc}

struct, mỗi tr ờng
chiếm một vị trí
nhớ khác nhau,
đối với union
chúng chia sẻ
cùng một vùng
nhớ.

 _{Có ph¸p khai b¸o:}
 _union
union_name
{
Type1 field1;
Type2 field2;
...
}

* Define a variable to hold an integer or
* a real number (but not both)

union value {

long int i_value; /* The real number */

float f_value; /* The floating-point number */
} data;

int i; /* Random integer */

float f; /* Random floating-point number */
void main()

{

data.f_value = 5.0;

data.i_value = 3; /* data.f_value overwritten */
i = data.i_value; /* legal */

f = data.f_value; /* not legal, will generate unexpected
results */

data.f_value = 5.5; /* put something in f_value/clobber
i_value */

i = data.i_value; /* not legal, will generate unexpected
results */

</div>
<span class='text_page_counter'>(78)</span><div class='page_container' data-page=78>

3.10 lÖnh typedef



_{typedef cho phép ta định nghĩa một kiểu dữ liệu mới cho}

C.



_{Có ph¸p:}

typedef kieu_dang_co kieu_moi;



_{VÝ dơ}

main()

{

typedef int group[10]; /* T¹o kiĨu míi "group" */

group totals; /* Dïng kiĨu míi cho biÕn totals */

for (i = 0; i < 10; i++)

</div>
<span class='text_page_counter'>(79)</span><div class='page_container' data-page=79>

<i><b>79</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

3.11 kiÓu enum

 _{enum đ ợc dùng cho các biến mà sẽ chỉ nhận một số giá trị nhất định,}

các giá trị đ ợc liên hệ đến thông qua tên.
typedef int week_day;

/* define the type for week_days */
const int SUNDAY = 0;

const int MONDAY = 1;
const int TUESDAY = 2;
const int WEDNESDAY = 3;
const int THURSDAY = 4;
const int FRIDAY = 5;
const int SATURDAY = 6;
/* now to use it */

week_day today = TUESDAY;

enum week_day {SUNDAY, MONDAY,
TUESDAY, WEDNESDAY, THURSDAY,
FRIDAY, SATURDAY};

/* now use it */

</div>
<span class='text_page_counter'>(80)</span><div class='page_container' data-page=80>

3.12

<b>Bit Fields và mảng cÊu tróc </b>

struct item {

unsigned int list:1; /* true if item is in the list */

unsigned int seen:1; /* true if this item has been seen */
unsigned int number:14; /* item number */

};

_{Ta có thể tạo một mảng gồm 10 phần tử có kiểu là cấu trúc item:}

struct item mang_ct[10];

Trong C, viƯc kÕt hỵp cÊu tróc víi con trá sẽ cho phép ta tạo ra những
cấu trúc dữ liệu rất mạnh trong lập trình:

struct linked_list
{

</div>
<span class='text_page_counter'>(81)</span><div class='page_container' data-page=81>

<i><b>81</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

3.13 Hµm (function)

 _{Trong C, tất cả các ch ơng trình con đều đ ợc coi là hàm.}
 _{Có 2 loại hàm: trả lại giá trị và không trả lại giá trị (void).}
 _{Để khai báo 1 hàm trong C, dùng cú pháp sau:}

Kieu_Tra_lai ten_ham(tham_so)
{

/* Neu tra lai gia tri co them return (giatri); */
}

VÝ dô:

int cong_so(int a,int b)
{

return(a+b);
}

_{Trong C, các tham số khi truyền vào hàm th ờng là qua giá trị sao chép,}

do vy cho dù trong hàm có làm thay đổi giá trị của nó thì khi kết thúc
hàm, giá trị của nó vẫn khơng thay đổi.

 _{Trong tr ờng hợp muốn thay đổi giá trị của tham số khi thoát khi hm,}

</div>
<span class='text_page_counter'>(82)</span><div class='page_container' data-page=82>

3.13 Hàm (function)

_{Giả sử trong vÝ dô sau, ta muèn}

tăng giá trị tham số thứ nhất lên
1, tham số 2 lên 2 đơn vị khi kết
thúc hàm thì hàm cong_so_1 sẽ
cho ta điều mong muốn.

void main()
{

int a=10,b=20,c;
c=cong_so(a,b);

printf( a=%d,b=%d\n",a,b);<b>“</b>

c=cong_so_1(a,b);
printf("a=%d,b=%d\n",a,b);
c=cong_so_2(&a,&b);
printf("a=%d,b=%d\n",a,b);
}
#include <stdio.h>

int cong_so(int a,int b)
{

a++;b+=2;
return(a+b);
}

int cong_so_1(int &a,int &b)
{

a++;b+=2;
return(a+b);
}

int cong_so_2(int *a,int *b)

</div>
<span class='text_page_counter'>(83)</span><div class='page_container' data-page=83>

<i><b>83</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

Truyền tham số mảng

_{Để truyền tham số có kiểu mảng, ta dùng cú pháp}
_{Kieu_Tra_Ve Ten_Ham(Kieu_PT_Mang a[] ,...)}
_{Ví dụ:}

/* Hàm sắp xếp 1 mảng nguyên a gåm N phÇn tư */
void SX_NoiBot(int a[], int N)

{

int i,j,tmp;

for(i=0;i<N-1;i++)

for(j=0;j<N-i-1;j++)
if(a[j]>a[j+1])

{ tmp=a[j];a[j]=a[j+1];a[j+1]=tmp;}
}

void main()

{ int a[10]={9,2,7,4,3,6,1,12,8,5}, i;
SX_NoiBot(a,10);

for(i=0;i<10;i++) printf( %3d ,a[i]);<b>“</b> <b>”</b>

</div>
<span class='text_page_counter'>(84)</span><div class='page_container' data-page=84>

3.13 Hµm (function)

_{Ngoài cách dùng hàm thông th ờng}

ó bit, ta cịn có thể dùng hàm d
ới dạng con tr ti hm.

_{Cách này th ờng đ ợc dùng trong tr}

ờng hợp ta cần lập trình gọi hàm
một cách tổng quát.

_{Ví dụ:}

#include <stdio.h>
#include <math.h>

double dien_tich_hinh_tron(float bk)
{

return(3.14*bk*bk);
}

typedef double (*fptr)(float);

void main()

 _{Trong C, hàm cịn có thể có tính đệ}

quy (recursive): Một hàm có thể có
lời gọi đến chính nó.

 _{VÝ dơ: TÝnh giai thõa cña mét sè N}
#include <stdio.h>

#include <math.h>
long giai_thua(int N)
{

return(N<=1? 1:N *
giai_thua(N-1));

}

void main()
{

</div>
<span class='text_page_counter'>(85)</span><div class='page_container' data-page=85>

<i><b>85</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

3.13 Hàm (function)-Các tham sè cho hµm main()

 _{C cung cấp cho ta một cỏch}

truyền tham số cho ch ơng trình
khi ta chạy ch ơng trình thông
qua các tham số của hàm
main()

_{cú pháp nh sau:}

<i>main( int argc, char *argv[] )</i>

Trong đó:

<b>“</b>argc lµ sè tham sè<b>”</b>

<b>“</b>argv[] là mảng chứa giá trị <b></b>

các tham số.

Nh ng argv[0] là tên của ch ơng trình,
nh vậy giá trị tham số bắt đầu

từ argv[1].

_{Ví dụ:}

#include <stdio.h>

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

if( argc == 2 )

printf("The argument supplied is
%s\n", argv[1]);

else if( argc > 2 )

printf("Too many arguments
supplied.\n");

else

printf("One argument
expected.\n");

</div>
<span class='text_page_counter'>(86)</span><div class='page_container' data-page=86>

3.13 Hµm (function)- Gọi các ch ơng trình ngoài

_{Ta có thể thực hiện các}

lệnh của hệ điều hành

thông qua lời gäi hƯ

thèng.



_{§Ĩ thùc hiƯn, ta dïng th}

viƯn hµm <process.h> víi

lƯnh:

system( OS command );

<b>“</b>

<b>”</b>



_{VÝ dô:}

#include <process.h>

main() /* SYS.C */

{

char *command =

"dir";

system( "cls" );

</div>
<span class='text_page_counter'>(87)</span><div class='page_container' data-page=87>

<i><b>87</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

3.14 Vµo/ra víi C

 _{Trong C, stdio.h lµ th viƯn hµm}

cho vào ra. Trong đó ta sử dụng
một số hàm thông dụng nh :

 _{printf( format ,args) để kết}<b>_“</b> <b>_”</b>

xt d÷ liƯu.

 _{scanf( format ,args) để nhập}<b>_“</b> <b>_”</b>

sè liƯu tõ bµn phÝm.

 _{Ngoµi ra, ta cã thĨ dïng hµm}

gets(char *s) để nhập một xâu
ký tự t bn phớm.

_{Chú ý: Vào ra với C, cần l u ý}

đến bộ đệm bàn phím. Khi
cần xố bộ đệm ta dùng hàm:

 _{fflush(stdin);}

<b>®iỊu khiĨn ý nghÜa</b>

d Đọc vào số nguyên

o Đọc số hệ 8

x Đọc số hƯ 16

h §äc sè short

l §äc sè long

f Đọc số dấu phảy động

e đọc số double

c đọc một ký tự

S đọc một xâu kết thúc khi gặp dấu
trắng, tab, hoặc enter

[...] đọc xâu với các ký tự bắt _{buộc trong dấu [ ].}

</div>
<span class='text_page_counter'>(88)</span><div class='page_container' data-page=88>

3.14 Vµo/ra víi C

 _{để nhập một ký tự từ bàn phím, có}

thể dùng:

_{int getch() -> nhận KT không}

phản hồi màn hình.

_{int getche() -> nhận KT có}

phản hồi màn hình.

#include <stdio.h>
void main()

{

char name[35];
int a;

float f;

fflush(stdin);
printf("name=");
gets(name);
fflush(stdin);

</div>
<span class='text_page_counter'>(89)</span><div class='page_container' data-page=89>

<i><b>89</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

3.14 Xư lý tƯp (file) víi C

 _{Trong C, để làm việc với file, ta sử dụng th viện <stdio.h>.}
 _{Để khai báo một biến là con trỏ file, dùng cú pháp:}

 _{FILE *my_file;}

 _{Tr ớc khi làm việc với file, ta cần mở chóng:}

 _{my_file=fopen( my_file.txt , r );}<b>_“</b> <b>_{” ” ”}</b>

 _{Có mấy chế độ mở file: r chỉ đọc, w chỉ ghi, w+ cả đọc và}<b>_{“ ”}</b> <b>_{” ”}</b> <b>_“</b> <b>_”</b>
ghi, b mở chế độ binary.<b>“ ”</b>

 _NÕu_{my_file==NULL}_{th× cã nghÜa thao tác với FILE không thành}

công!

_{Để vào ra với file, dùng các hàm:}

_{In ra file:}_{int fprintf(FILE *,const char *,....)}
 _{đọc vào từ file:}_{fscanf(FILE *,const char *,....)}
 _{Ghi một ký tự ra file:}_{putc(int,FILE *)}

</div>
<span class='text_page_counter'>(90)</span><div class='page_container' data-page=90>

3.14 Xư lý tƯp (file) víi C

 _{Khi vào ra ở chế độ nhị phân (binary), dùng các hàm sau:}

 _{fwrite(void*,KT_PT,So_PT,FILE*);}
 _{fread(void*,KT_PT, So_PT ,FILE*);}
VÝ dô:

struct SV
{

int ma_sv;

char ten_sv[30];
}

...

struct SV s; FILE *f;
...

</div>
<span class='text_page_counter'>(91)</span><div class='page_container' data-page=91>

<i><b>91</b></i>

<i><b>Object-Oriented Programming (OOP)</b></i>

3.14 Xư lý tƯp (file) víi C

 _{Để xác định vị trí hiện thời của con trỏ dùng hàm:}

 _{long ftell( FILE *stream );}

 _{Để chuyển con trỏ FILE đến một vị trí xác định, dùng hàm:}

 _{int fseek( FILE *stream, long offset, int origin );}
_origin:

SEEK_CUR

Từ vị trí hiện tại
SEEK_END

Từ cuối file.
SEEK_SET

Từ đầu file.

VÝ dơ:

Xác định kích th ớc 1 File:

fseek(f,0L,SEEK_END);

</div>
<span class='text_page_counter'>(92)</span><div class='page_container' data-page=92>

3.14 Xư lý tƯp (file) víi C VÝ dụ

<i></i>

/* Ch ơng trình Xử lý in ra/Đọc vào từ mét file trong C */
#include <stdio.h>

void in_file(char *fn)
{

FILE *f; /* Khai bao bien con tro file */
int i,j;

f=fopen(fn,"w"); /* Mo file ở chế độ ghi */
if (f==NULL) /* Mở không thành công */

printf("Khong the mo file!\n");
else /* Më thành công */
{

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

for(j=0;j<5;j++)

fprintf(f,"%10d",j*i+1); /* in số j*i +1 ra file */
fprintf(f,"\n"); /* Xuèng dßng */

</div>
<span class='text_page_counter'>(93)</span><div class='page_container' data-page=93>

<i><b>93</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

void doc_file(char *fn,int a[10][5]) /* Hàm đọc file văn bản đã ghi ra ở phần trên */
{

FILE *f;
int i;

char s[100];

f=fopen(fn,"r"); /* Mở file ở chế độ đọc */
if (f==NULL)

printf("Khong the mo file!\n");
else

{

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

fgets(s,100,f);

sscanf(s,"%10d%10d%10d%10d%10d",a[i],a[i]+1,a[i]+2,a[i]+3,a[i]+4);
}

fclose(f); /* §ãng file */
printf("Da doc xong so lieu\n");
}

</div>
<span class='text_page_counter'>(94)</span><div class='page_container' data-page=94>

void main() /* Ch ¬ng tr×nh chÝnh */
{

int a[10][5],i,j;

char fn[20]="output.txt";

in_file(fn); /* In sè liƯu ra file */

doc_file(fn,a); /* §äc sè liƯu vào mảng a */
/* In mảng ra màn hình */
for(i=0;i<10;i++)

{

for(j=0;j<5;j++)

printf("%10d",a[i][j]);
printf("\n");

</div>
<span class='text_page_counter'>(95)</span><div class='page_container' data-page=95>

<i><b>95</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

3.15 Quản lý bộ nhớ

Địa chỉ (hex)

int, pointer

(4 byte = 32bits)
Địa chỉ

thấp

Địa chỉ
cao

(Với giả thiết máy tính 32-bit)

0 (0x0)
4 (0x4)
8 (0x8)
12 (0xc)
16 (0x10)
20 (0x14)

:
:

</div>
<span class='text_page_counter'>(96)</span><div class='page_container' data-page=96>

3 lo¹i không gian nhớ

Địa chỉ

thấp

Địa chỉ

cao B nh t động
Bộ nhớ tĩnh
Mã (functions)

Vïng trèng
(Heap)

(Ph¸t triĨn theo h íng này)

Dựng cho cp phỏt ng

Các biến toàn cục và

biến !=

.

</div>
<span class='text_page_counter'>(97)</span><div class='page_container' data-page=97>

<i><b>97</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

Bản đồ bộ nhớ trong 1 ch ơng trình C/C++

int x = 10
int y = 20;
void func() {
...

}

int main()
{

int i = 123;
int *p;

p = new int;
*p = 456;

...
}

Ngăn
xÕp
Stack
Vïng tÜnh
Vïng m·
Ch/Tr×nh
Heap
p (0x299b0)
y (20)
func()’s code
main()’s code
i (123)
456
x (10)
0xefffa9c
0xefffa98

(Các địa chỉ ở đây chỉ là ví dụ)

</div>
<span class='text_page_counter'>(98)</span><div class='page_container' data-page=98>

Stack đ ợc dùng để l u các biến cục bộ

void func2() {
int x, y;

}

void func1() {
int p, q;

func2();

}

int main()
{

int a, b;
func1();

<b>ã</b>_{Khi bắt đầu vào một}
hàm, một khung stack
sẽ đ ợc khởi tạo.

<b>ã</b>_{Khi hàm thực hiện}
xong, khung stack của
hàm sẽ đ ợc giải phóng.

q
x
p
y

Stack frame cho

func1

Stack frame cho

</div>
<span class='text_page_counter'>(99)</span><div class='page_container' data-page=99>

<i><b>99</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

Stack vµ stack frame

void func2(int q1, int q2) {
int e, f;

}

void func1(int p1, int p2) {
int c, d;

func2();
}

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

int a, b;
func1();
}

Các tham số của hàm cũng đ ỵc coi lµ biÕn cơc bé!

</div>
<span class='text_page_counter'>(100)</span><div class='page_container' data-page=100>

Stack và đệ quy

#include <stdio.h>
int sum(int <b>x</b>)

{

if (x == 0) {

return 0;
} else {

return x + sum(x – 1);
}

}

int main()
{

printf(“%d”, sum(5));

Stack cho phép thực hiện đệ quy

4th_x=2

5th_x=1

</div>
<span class='text_page_counter'>(101)</span><div class='page_container' data-page=101>

<i><b>101</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

3.15 Quản lý bộ nhớ Cấp phát bộ nhớ động

<i>–</i>

 _{Trong C, bộ nhớ động có thể đ ợc sử dụng một cách linh hoạt và hiệu}

quả thông qua các hàm cấp phát và giải phóng bộ nhớ động nh
calloc(), sizeof() và free()

_{Để dùng calloc() dùng cú pháp:}

(void*) calloc(unsigned int SoPT,unsigned int KTPT)

VÝ dô:

<i> struct date *date_pointer;</i>

<i> date_pointer = (struct date *) calloc( 10,sizeof(struct date) );</i>

 _{§Ĩ sư dơng free(), dïng cú pháp:}
free(pointer_var);

</div>
<span class='text_page_counter'>(102)</span><div class='page_container' data-page=102>

/* Ví dụ Danh sách liên kết*/
#include <string.h>

#include <malloc.h>
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <conio.h>
/* Định nghĩa 1 Nót */
struct node {

char data[20];
struct node *next;

struct node * initialise( void );
void freenodes( struct node * );
int insert( struct node * );

void del( struct node *, struct
node * );

void list( struct node * );

</div>
<span class='text_page_counter'>(103)</span><div class='page_container' data-page=103>

<i><b>103</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

void readline( char buff[] )
{

int ch, loop = 0;
ch = getche();
while( ch != '\r' ) {
buff[loop] = ch;
loop++;

ch = getche();
}

buff[loop] = 0;
}

struct node * initialise( void )
{

</div>
<span class='text_page_counter'>(104)</span><div class='page_container' data-page=104>

/* free memory allocated for node */
void freenodes( struct node *headptr )
{

struct node *temp;
while( headptr ) {

temp = headptr->next;
free( headptr );

headptr = temp;
}

</div>
<span class='text_page_counter'>(105)</span><div class='page_container' data-page=105>

<i><b>105</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

/* chÌn 1 nút sau nodeptr, return 1 = thành công */
int insert( struct node *nodeptr )

{

char buffer[20];

struct node *newptr;

newptr = initialise(); /* CÊp ph¸t bé nhí cho nót míi */
if( newptr == NULL ) {

return 0;
}

else { /* Điền dữ liệu và thêm vào DSách */
newptr->next = nodeptr->next;

nodeptr->next = newptr;
nodeptr = newptr;

printf("\nEnter data --->");
readline( buffer );

strcpy( nodeptr->data, buffer );
}

</div>
<span class='text_page_counter'>(106)</span><div class='page_container' data-page=106>

/* Xo¸ mét nót khái danh s¸ch */

void del( struct node *headptr, struct node
*nodeptr )

{

struct node *deletepointer,
*previouspointer;

char buffer[20];

deletepointer = headptr->next;
previouspointer = headptr;
/* Tìm nút cần xoá */

printf("\nEnter name to be deleted
--->");

readline( buffer );

while( deletepointer )
{

if( strcmp( buffer, deletepointer->data
) == 0 ) {

/* Xo¸ nót do deletepointer trá*/
previouspointer->next =

else {

/* Chun sang nót kÕ tiÕp */
deletepointer =

deletepointer->next;

previouspointer =
previouspointer->next;
}

}

/* T×m thÊy? */

if( deletepointer == NULL )

printf("\n\007Error, %s not found
or list empty\n", buffer);

else {

free( deletepointer );

/* Điều chỉnh lại nodeptr*/
nodeptr = headptr;

</div>
<span class='text_page_counter'>(107)</span><div class='page_container' data-page=107>

<i><b>107</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

/* In Danh s¸ch */

void list( struct node *headptr )
{

struct node *listpointer;
listpointer = headptr->next;
if( listpointer == NULL )

printf("\nDanh sách rỗng.\n");
else {

while( listpointer ) {

printf("Name : %20s\n", listpointer->data );
listpointer = listpointer->next;

</div>
<span class='text_page_counter'>(108)</span><div class='page_container' data-page=108>

/* Menu chÝnh */

void menu( struct node *headp, struct node *nodep )
{

int menuchoice = 1;
char buffer[20];

while( menuchoice != 4 ) {
printf("1 insert a node\n");
printf("2 delete a node\n");
printf("3 list nodes\n");
printf("4 quit\n");

printf("Enter choice -->");
readline( buffer );

menuchoice = atoi( buffer );
switch( menuchoice ) {

case 1 : if( insert( nodep ) == 0 )
printf("\n\007Insert failed.\n");
break;

case 2 : del( headp, nodep ); break;
case 3 : list( headp ); break;

</div>
<span class='text_page_counter'>(109)</span><div class='page_container' data-page=109>

<i><b>109</b></i>
<i><b>Object-Oriented Programming (OOP)</b></i>

Vµ cuèi cïng lµ hµm main()

void main()

{

struct node *headptr, *nodeptr;
headptr = initialise();

nodeptr = headptr;

headptr->next = NULL;
menu( headptr, nodeptr );
freenodes( headptr );

</div>

<!--links-->