eBook Huong Dan Thuc Hanh C++

Thực hành Lập trình HĐT & C++ Mục lục

Bộ môn Hệ thống máy tính & Truyền thông Trang 1

MỤC LỤC

Giới thiệu ................................ ................................ ................................ ................2Đề cương thực hành................................ ................................ ............................... 3Chương 1 ................................ ................................ ................................ ................9

1.1. Gọi trình biên dịch: ................................ ................................ ................. 101.1.1. Gọi chương trình BorlandC (BC): ................................ .................... 101.1.2. Gọi chương trình TurboC (TC) ................................ ........................ 10

1.2. Viết một chương trình C++ đơn giản – Hello C++: ................................ 111.3. Viết một số chương trình C++:................................ ................................ 15

1.3.1. Bài 1 – Chào <tên bạn>: ................................ ................................ ...151.3.2. Bài 2 – Hàm và chương trình giải PT bậc 1, 2:................................ .....151.3.3. Bài 3 – Hàm Nhập, sắp xếp một mảng các số nguyên : .......................... 181.3.4. Bài 4 – Hàm Nhập, sắp xếp một mảng con trỏ các số nguyên :................ 211.3.5. Bài 5 – Hàm tách tên: ................................ ................................ ........221.3.6. Bài 6 – Chương trình Quản lý sinh viên: ................................ .............. 23

Chương 2 ................................ ................................ ................................ .............. 282.1. Bài 1 – Lớp Điểm: ................................ ................................ .................... 292.2. Bài 2 – Lớp Clock:................................ ................................ .................... 312.3. Bài 3 – Lớp Date: ................................ ................................ ..................... 33

Chương 3 ................................ ................................ ................................ .............. 373.1. Bài 1 – Lớp Phân số: ................................ ................................ ................ 383.2. Bài 2 – Lớp Số phức: ................................ ................................ ................ 453.3. Bài 3 – Tổ chức các lớp trong chương trình: ................................ ............... 493.4. Bài tập tự làm thêm: ................................ ................................ ................ 51

3.4.1. Bài 1: ................................ ................................ ............................... 513.4.2. Bài 2: ................................ ................................ ............................... 51

Chương 4 ................................ ................................ ................................ .............. 534.1. Bài 1 – Lớp Phân số (tái định nghĩa toán tử): ................................ .............. 544.2. Bài 2 – Lớp Thuê bao:................................ ................................ ............... 62

Chương 5 ................................ ................................ ................................ .............. 715.1. Bài 1 – Lớp Đoạn thẳng: ................................ ................................ ........... 725.2. Bài 2 – Lớp Hình ảnh:................................ ................................ ............... 785.3. Bài 3 – Lớp Chuyến bay: ................................ ................................ ........... 84

Chương 6 ................................ ................................ ................................ .............. 926.1. Bài 1 – Lớp Điểm màu: ................................ ................................ ............. 936.2. Bài 2 – Quản lý nhân sự của một trường học:................................ .............. 97

Bài tập bổ sung ................................ ................................ ................................ .....93Phụ lục 1 - Control Statement Summary ................................ ............................ 114Phụ lục 2 - Operator Summary ................................ ................................ .......... 116Phụ lục 3 - Data type Summary ................................ ................................ .......... 117Phụ lục 4 - The ASCII Character Set ................................ ................................ .118Tài liệu tham khảo................................ ................................ .............................. 109

Thực hành Lập trình HĐT & C++ Giới thiệu


GIỚI THIỆU

Giáo trình Thực hành lập trình Hướng đối tượng & C++ nhằmmục đích giúp sinh viên tự thực hành những nội dung đã học trongmôn học lý thuyết về Lập trình hướng đối tượng & C++.

Với mục tiêu này, về cấu trúc chung thì nội dung mỗi buổi thựchành sẽ bao gồm 2 phần:

- Phần hướng dẫn sinh viên thực hành từng b ước (step bystep): mục đích của phần này là cho sinh viên làm quen vớ inhững kiến thức cơ bản trong buổi thực hành. Đối với phầnnày thì sinh viên chỉ cần thực hiện chính xác theo nhữngbước hướng dẫn trong giáo trình để xem kết quả. Các bướcphức tạp sẽ được giải thích rõ ràng để sinh viên có thể hiểuđược vấn đề.

- Phần sinh viên tự thực hành: đây là phần bài tập sinh viên sẽtự giải quyết. Sinh viên sau khi làm quen với nội dung buổithực hành qua phần bài thực hành từng b ước thì có thể dùngbài tập trong phần này để kiểm tra lại mức độ hiểu bài củamình. Một số buổi thực hành sẽ không có phần bài tập tựthực hành do thời lượng không đủ thì sinh viên tự lựa chọnmột số bài tập trong phần hướng dẫn thực hành từng bước đểtự giải quyết lấy hoặc giáo viên dạy lý thuyết sẽ cung cấpthêm hoặc thực hành các bài tập trong phần bài tập bổ sung.

Cần Thơ, tháng 8 năm 2004

Thực hành Lập trình HĐT & C++ Đề cương thực hành


ĐỀ CƯƠNG THỰC HÀNHSố tiết: 30 tiết

1. Buổi 1: Mục đích:

Ôn lại ngôn ngữ C, chuyển sang cách viết của C++.Thực hiện những điểm khác biệt và những đặc điểm mới của C++.

Yêu cầu:Sử dụng thư viện hàm <iostream.h> , cách định nghĩa hàm dạng prototype,dùng toán tử new và delete cho con trỏ, cách sử dụng tham chiếu trong thamsố của hàm.Bài 1: Viết chương trình in câu “Hello C++” ra màn hình.Bài 2: Viết chương trình nhập vào tên của bạn, sau đó chương trình in radòng chữ: Chào <tên bạn>Bài 3: Viết hàm giải phương trình bậc 1: ax + b = 0

Viết hàm giải phương trình bậc 2, có gọi hàm giải phương trình bậc 1ở trên.

Bài 4: Viết hàm nhập 1 danh sách các số nguyên vào 1 mảng.Viết hàm dùng để sắp xếp 1 mảng số nguyên theo thứ tự t ăng dần.Viết chương trình nhập vào 1 mảng số nguyên, sắp xếp danh sách đótheo thứ tự tăng dần và in danh sách kết quả.

Bài 5: Viết chương trình nhập vào 1 danh sách (là con trỏ) số nguyên, sắpxếp danh sách đó theo thứ tự tăng dần và in danh sách kết quả.

Bài 6: Khai báo 1 cấu trúc là SinhViên gồm các thuộc tính :Họ tên, Lớp, Năm sinh, Điểm trung bình.Viết hàm nhập thông tin cho 1 danh sách SinhViên (kiểu con trỏ).Viết hàm In thông tin của 1 danh sách SinhViên.Viết hàm xếp loại sinh viên dựa theo điểm trung bình.Viết hàm sắp xếp danh sách sinh viên dựa theo tên.Viết hàm main() thực hiện các công việc sau :

Tạo ra 1 danh sách gồm n sinh viên Nhập dữ liệu cho danh sách đó. In danh sách đã được sắp xếp theo tên cùng với xếp loại của

sinh viên. In thông tin của sinh viên lớn tuổi nhất trong danh sách.


Sinh viên tập làm quen với phong cách lập trình h ướng đối tượng.Thiết kế 1 số lớp đơn giản. Viết các hàm thành viên của lớp đó.



Sử dụng các lớp vừa định nghĩa. Yêu cầu :

Bài 1: Thiết kế lớp Diem (Điểm trong không gian 2 chiều) gồm 2 thành phần x,ykiểu int.Các hàm thành viên gồm:

+ Gán tọa độ cho 1 điểm: void Gan (int hoanh , int tung) ;+ Nhập tọa độ cho 1 điểm: void Nhap();+ In ra màn hình tọa độ điểm theo dạng (x,y): void InDiem();+ Xuất ra giá trị hoành độ của điểm: int PutX();+ Xuất ra giá trị tung độ của điểm: int PutY();

Viết hàm main() khai thác lớp vừa định nghĩa :+ Tạo ra điểm A tọa độ (3,4). In tọa độ điểm A ra màn hình.+ Tạo ra điểm B với giá trị nhập từ bàn phím. In tọa độ điểm B ra màn hình.+ Tạo ra điểm C đối xứng với điểm B qua gốc tọa độ. In tọa độ điểm C ramàn hình.+ Tính khoảng cách từ điểm B đến tâm O.

Bài 2: Thiết kế lớp Clock gồm 3 thành phần: giờ, phút , giây .Các hàm thành viên gồm :

+ Hàm gán (dùng để khởi tạo 1 Clock)+ Hàm nhập giá trị và hàm in+ Hàm làm tròn thời gian (VD: 13:67:150 sẽ làm tròn thành 14:09:30).

Viết hàm main() khai thác lớp vừa định nghĩa.+ Tạo 1 Clock có giá trị là 9:15:38. In giá trị đó ra màn hình.+ Tạo 1 Clock bất kỳ, nhập giá trị cho nó. In ra màn hình.+ Làm tròn Clock vừa nhập ở trên (nếu được) và in ra màn hình.

Bài 3: Thiết kế lớp Date gồm 3 thành phần: ngày, tháng, n ămCác hàm thành viên gồm :

+ Hàm gán (dùng để khởi tạo 1 Date)+ Hàm nhập giá trị và hàm hiện thông tin+ Hàm kiểm tra xem ngày có hợp lệ hay không ? (VD: Ngày 31/6/2000 hay 29/2/ 1999 là không hợp lệ.)

Viết hàm main() khai thác lớp vừa định nghĩa.

3. Buổi 3 : Mục đích :

Sinh viên tiếp tục thực tập thiết kế lớp, viết các hàm phức tạp h ơn.Áp dụng viết các hàm xây dựng và hàm hủy.



Dùng nhiều cách khác nhau để khởi tạo đối tượng. Yêu cầu :

Bài 1: Chỉnh lại các lớp đã viết trong buổi 2, khai báo và định nghĩa thêm cáchàm xây dựng.Trong hàm main(), khởi tạo các đối tượng theo kiểu khác.(So sánh với cách viết trong buổi trước)Bài 2: Thiết kế lớp PhanSo (Phân số) gồm 2 thành phần: tử số và mẫu số.Các hàm xây dựng gồm :

+ Hàm xây dựng mặc nhiên : PhanSo();+ Hàm xây dựng gồm nhiều tham số: PhanSo(int , int );+ Hàm xây dựng sao chép: PhanSo(const PhanSo&);

Các hàm thành viên cơ bản gồm:+ Hàm nhập, hàm in phân số.+ Hàm nghịch đảo phân số.+ Hàm tính giá trị thực của phân số.+ Hàm cộng, trừ, nhân, chia 2 phân số. Kết quả xuất ra là 1 phân số.+ Hàm cộng, trừ, nhân, chia phân số với 1 số nguyên. Kết quả xuất ra là 1phân số.

Viết hàm main() sử dụng lớp PhanSo:+ Tạo phân số a = 3/7 , b = 4/9 . In giá tr ị chúng ra màn hình.+ Tạo 2 phân số x và y với giá trị nhập vào từ bàn phím.+ In giá trị nghịch đảo của x.+ Tính tổng của x và y và in ra màn hình.+ Tính tích của x và 10 và in ra màn hình.+ Nhập vào 1 danh sách gồm n phân số (n: nhập từ bàn phím).+ Tính tổng n phân số đó.

Bài 3 : Thiết kế lớp SoPhuc (Số phức) gồm 2 thành phần: thực và ảo.Định nghĩa các hàm xây dựng, hàm thành viên cần thiết.Viết hàm main() sử dụng lớp đó.(Thực hiện tương tự như lớp trên)Bài 4 : Tách tất cả các lớp trên thành 2 phần:

+ < Tên lớp >.hpp chứa các khai báo của lớp.+ < Tên lớp >.cpp chứa các định nghĩa hàm của lớp.Định nghĩa hàm main() trong 1 file riêng dùng sử dụng các lớp đã được định

nghĩa trong các file khác.


Sinh viên tiếp tục thực tập thiết kế lớp và định nghĩa hàm.



Sử dụng thêm các kỹ thuật như: hàm bạn, định nghĩa các toán tử. Yêu cầu:

Bài 1: Chỉnh lại lớp PhanSo, dùng cách định nghĩa toán tử để tái định nghĩa cácphép toán như:+ , - , * , / (Thay vì định nghĩa thành các hàm như trên).Định nghĩa thêm tác tử = .Định nghĩa phép toán so sánh > (lớn h ơn)Viết hàm độc lập: void SapXep(PhanSo* ds, int soluong);

dùng để sắp xếp 1 danh sách phân số theo thứ tự giảm dần.Viết lại hàm main() với cách dùng toán tử đã định nghĩa.Thực hiện thêm trong hàm main() :

+ In ra phân số có giá trị lớn nhất trong danh sách đã nhập.+ Sắp xếp danh sách phân số đó theo thứ tự giảm dần.

Bài 2: Thiết kế lớp danh bạ điện thoại gồm các thông tin sau :+ Số điện thoại. + Họ và tên người thuê bao .+ Địa chỉ của nơi đặt điện thoại. + Số phút gọi

Viết các hàm: + Hàm xây dựng, hàm hủy

+ Hàm nhập, hàm in thông tin của người thuê bao.+ Hàm xuất ra giá trị dữ liệu thành viên.+ Hàm tính cước điện thoại chưa có thuế giá trị gia tăng.Biết rằng:- Thuê bao mỗi tháng là 27.000 đ.- Đến 200 phút: 120 đ; từ phút 201 đến 1000: 80 đ; từ phút 1001 trở lên: 40

đ/phút.+ Hàm tính cước điện thoại có thuế giá trị gia t ăng (10%).

Thiết kế hàm main làm các công việc sau: + Nhập vào danh sách gồm n người thuê bao điện thoại. + Tính cước cho tất cả số thuê bao trên . + In danh sách trên và tính t ổng số tiền thu được .

+ Nhập 1 họ tên, tìm số điện thoại của người có họ tên vừa nhập trong danhsách. + In thông tin về nguời thuê bao số điện thoại 831301. + In danh sách theo thứ tự Alphabe của tên người thuê bao.


Sinh viên thiết kế lớp theo dạng: dữ liệu thành viên là đối tượng thuộc 1 lớpkhác.

Yêu cầu:



Bài 1: Thiết kế lớp DoanThang gồm:+ Thành phần dữ liệu: d1, d2 là 2 điểm đầu mút có kiểu là Diem đã định nghĩa ở

trên.+ Các hàm xây dựng và hàm hủy.+ Các hàm thành viên như:

- Nhập tọa độ của đoạn thẳng.- In giá trị 2 đầu mút của đoạn thẳng.- Tính độ dài của đoạn thẳng.- Tính góc của đoạn thẳng với trục hoành.- Hàm tịnh tiến đoạn thẳng.

Thiết kế hàm main thực hiện các công việc sau: + Tạo 2 điểm là A(2, 5) , B(20, 35). Tạo đoạn thẳng AB. Tịnh tiến AB đi đọan(5,3). + Tạo một đoạn thẳng bất kỳ CD . Nhập giá trị cho đoạn thẳng đó. + Tính độ dài CD, góc CD với trục hoành.

Bài 2: Thiết kế lớp HinhAnh ( Hình ảnh) gồm:+ Thành phần dữ liệu: Diem* ds; // Tập hợp các điểm

int soluong; // Số lượng điểm hiện cóint sltoida; // Số lượng điểm tối đa

+ Các hàm xây dựng:HinhAnh(int maxdiem); // Tạo 1 ảnh gồm tối đa maxdiem

+ Hàm hủy: ~HinhAnh();+ Các hàm thành viên như:

- Thêm 1 điểm vào hình ảnh.- Bỏ 1 điểm ở vị trí cuối cùng ra khỏi ảnh- Bỏ 1 điểm ở vị trí bất kỳ trong ảnh.- Bỏ tất cả điểm có giá trị là d ra khỏi ảnh- Hiện toàn bộ điểm có trong ảnh.- Xuất ra giá trị của điểm ở vị trí thứ i trong ảnh.

Viết hàm main() sử dụng lớp trên.Bài 3 : Thiết kế lớp ChuyenBay (Chuyến bay) gồm:

+ Thành phần dữ liệu: _ Giờ bay là đối tượng thuộc lớp Clock._ Mã số chuyến bay_ Hãng hàng không

+ Các hàm xây dựng và hàm hủy.+ Các hàm thành viên: Nhập, In, ...Viết hàm main() thực hiện công việc nh ư sau:+ Tạo ra 1 danh sách gồm n chuyến bay.+ Nhập, in danh sách đó ra màn hình.+ In ra giờ bay của chuyến bay có mã số là “VN3547”.




Sinh viên thiết kế lớp theo dạng thừa kế.Sử dụng các tính chất của thừa kế.

Yêu cầu :Bài 1: Thiết kế lớp DiemMau (Điểm có màu) thừa kế từ lớp điểm và có thêmthuộc tính màu.Bài 2: Một trường cần quản lý nhân sự gồm giáo viên và học sinh của trường.

Trong đó: tất cả các thành viên (Person) trên đều có những thông tin chung nh ư: Họ và tên, Giới tính, Năm sinh, Nơi sinh, Địa chỉ . Tuy nhiên, Giáo viên còn có thêm nh ững thông tin riêng của mình nh ư: + Số năm giảng dạy (Thâm niên) + Học vị (Đại học, Cao học, Tiến sĩ) Và Học sinh có những thông tin riêng nh ư: + Điểm 3 môn chính như : Văn, Toán, Ngoại ngữ . + Điểm trung bình ( tự tính từ các môn trên ). + Xếp loại theo tiêu chuẩn sau: Giỏi: ĐTB trên 8 và không có môn d ưới 6.5. Khá: ĐTB trên 6.5 và không có môn d ưới 5. Trung Bình: ĐTB trên 5 và không có môn dưới 3. Kém: ĐTB dưới 5. Hãy thiết kế các lớp sao cho việc quản lý nhân sự trên được hiệu quả nhất . Thiết kế hàm main làm các công việc sau:

+ Nhập vào danh sách gồm n Học sinh (n: nhập vào từ bàn phím).+ Nhập vào danh sách gồm m Giáo viên (m: nhập vào từ bàn phím).+ In các danh sách đó ra .+ In danh sách Học sinh được xếp loại Khá và Giỏi .+ In danh sách Giáo viên có thâm niên trên 10 n ăm và học vị là Cao học trở

lên .

*

* *

Thực hành Lập trình HĐT & C++ Chương 1


Chương 1

Mục tiêu của chương này:

Sau chương này, sinh viên có thể: Viết và thực thi một chương trình C++:

o Gọi chương trình BorlandC và TurboCo Tạo một chương trình mớio Một số thao tác trong việc viết ch ương trìnho Lưu chương trìnho Dịch chương trìnho Thực thi chương trình đã biên dịcho Thực thi chương trình trong khi viết chương trình (chạy thử)

Viết một số chương trình C++ đơn giản. Sử dụng các câu lệnh điều khiển. Sử dụng hàm, truyền đối số cho hàm.



1.1. Gọi trình biên dịch:Hiện nay, có rất nhiều trình biên dịch C++. Hai trình biên dịch được sử dụngrộng rãi nhất là BorlandC và TurboC.

1.1.1. Gọi chương trình BorlandC (BC):1. Mở cửa sổ Command Prompt: (đối với HĐH Windows)

Windows 2000:Chọn Start/Programs/Accessories/Command Prompt

Windows 9x:Chọn Start/Programs/Command Prompt

2. Chuyển vào thư mục chứa chương trình BC:Từ cửa sổ Command Prompt, đánh vào "cd \borlandc\bin"

(nếu chương trình BC được cài vào một thư mục khác thì thay đổi đườngdẫn cho phù hợp)

Trên màn hình Command Prompt s ẽ hiển thị thư mục hiện hành:C:\borlandc\bin>

3. Gọi chương trình BC:Đánh vào "bc" và nhấn phím Enter.

1.1.2. Gọi chương trình TurboC (TC)1. Mở cửa sổ Command Prompt: (đối với HĐH Windows)

Thực hiện giống như cách thực hiện với BorlandC

2. Chuyển vào thư mục chứa chương trình BC:Từ cửa sổ Command Prompt, đánh vào "cd \TC\bin"

(nếu chương trình TC được cài vào một thư mục khác thì thay đổi đườngdẫn cho phù hợp)

Trên màn hình Command Prompt s ẽ hiển thị thư mục hiện hành:C:\TC\bin>

3. Gọi chương trình TC:Đánh vào "tc" và nhấn phím Enter.



Giao diện và thao tác trên hai chương trình này là giống nhau. Từ đây trở đi,trong giáo trình này chỉ sử dụng chương trình BorlandC làm minh họa.

1.2. Viết một chương trình C++ đơn giản:Viết chương trình in câu "Hello C++" ra màn hình

1. Chọn menu File/New

2. Đánh vào màn hình soạn thảo đoạn chương trình sau:

#include <iostream.h>

#include <conio.h>

void main()

{

clrscr();

cout << "Hello C++";

Màn hìnhsoạn thảoTên

chương trình



}

Trong đọan chương trình này, bao gồm 2 câu lệnh: Lệnh clrscr() dùng để xóa màn hình. Lệnh cout << "Hello C++" dùng để hiển thị chuỗi Hello C++ lên

màn hình.Đối với C, ta có thể sử dụng một số hàm thông dụng mà không cần khai báothư viện hàm chứa hàm đó. Tuy nhiên, đối với C++ thì điều này là bắt buộc.Do đó, ta phải thêm hai chỉ thị tiền xử lý #include <iostream.h> (để sử dụngluồng cout) và #include <conio.h> (để sử dụng hàm clrscr()) vào trongchương trình.

Một số thao tác thường dùng trong việc soạn thảo chương trình: Đặt khoảng cách cho phím Tab: chọn menu Option\Environment\Editor và

sửa giá trị của Tab size là số khoảng trắng mỗi khi ta nhấn phím Tab (mặcnhiên là 8 nhưng giá trị thường được sử dụng là 4-5 khoảng trắng)

Phóng to/thu nhỏ cửa sổ soạn thảo: F5 Di chuyển giữa các cửa sổ: F6 Chọn khối: đưa con trỏ tới đầu/cuối khối; ấn giữ phím Shift và dùng phím mũi

tên để tạo khối. Bỏ chọn khối: thao tác giống như chọn khối, nhưng ở đây là ta chọn khối rỗng. Copy khối vào vị trí con trỏ hiện hành: Ctrl + K + C Chuyển khối đến vị trí con trỏ hiện hành: Ctrl + K + V Copy khối vào Clipboard: Ctrl + Insert Dán khối từ Clipboard vào trị ví hiện hành: Shift + Insert Xóa khối: Ctrl + K + Y hoặc Ctrl + Del

3. Lưu chương trìnhChọn menu File\Save (hoặc nhấn phím tắt F2).Đánh vào tên chương tr ình là Hello[.cpp] vào ô Save File As

Khi lưu chương trình, ta có thể nhập vào đuôi của tập tin hay không cũngđược. Nếu ta không nhập vào đuôi của tập tin thì mặc định là .cpp

4. Dịch chương trìnhChọn menu Compile\Make hoặc chọn phím tắt F9 để dịch chương trình ramã máy Hello.exeHoặc, chọn menu Compile\Build all

Để dịch một chương trình từ mã nguồn C++ (.cpp) ra chương trình thực thiđược (.exe) bao gồm hai giai đọan:

Biên dịch (compile): dịch chương trình nguồn .cpp ra mã máy .obj Liên kết (link): liên kết các hàm từ các th ư viện hàm trong chương trình

ta có sử dụng vào chương trình để tạo thành một tập tin thực thi được .exe



Công cụ Complile\Make dùng để dịch tập tin hiện hành (đang soạn thảo) ratập tin exe. Còn công cụ Compile\Build all dùng để dịch tất cả các chươngtrình trong một Project ra mã máy và sẽ dịch lại tất cả, bất kể tập tin đó có đượcdịch hay chưa.

Sau khi ra lệnh dịch chương trình, BC sẽ đưa ra thông báo quá tr ình biêndịch. Ta phải chú ý đến thông báo này để biết được chương trình dịch thànhcông hay không và tên của tập tin thực thi là gì.

Nếu kết quả không thành công, ta nhấn phím Enter để xem các thông báolỗi. Thông tin về mỗi lỗi bao gồm: tên tập tin có lệnh bị lỗi, số dòng bị lỗi vànguyên nhân gây ra lỗi.

Nếu có nhiều lỗi thì thông tin của mỗi lỗi sẽ hiển thị trên một dòng . Khi ta dichuyển đến một thông báo lỗi và nhấn Enter thì con trỏ sẽ trở lại màn hình sọanthảo và đúng ngay vị trí dòng bị lỗi ta đang chọn để ta có thể sửa lỗi.

Hộpthông báo

Tên tập tinthực thi

Thông tinbiên dịch

Kết quảbiên dịch

Biên dịchbị lỗi

Cửa sổ thông báo lỗi



5. Thoát khỏi BCChọn menu File\Exit hoặc phím tắt Alt + X.

6. Chạy chương trìnhTừ màn hình Command Prompt đánh vào tên chương tr ình vừa dịch ra:Hello

Kết quả sau khi thực thi chương trình Hello.exe

Chương trình trên gồm 2 lệnh: clrscr() và cout << "Hello C++". Lệnhclrscr() dùng để xóa màn hình và lệnh cout << "Hello C++" sẽ hiển thị câuHello C++ ra màn hình.

Chú ý:

Trong khi viết chương trình, ta có thể chạy thử chương trình mà không cần dịch ra tậptin exe bằng cách:

Chọn menu Compile\Run hoặc phím tắt Ctrl + F9.

Chương trình sẽ được thực thi trong một cửa sổ có tên là User Screen. Sau khi thựcthi xong chương trình thì BC sẽ tự động quay về màn hình soạn thảo. Nếu nh ư trongchương trình của ta không có lệnh dừng màn hình ở cuối ch ương trình - getch() – thìta sẽ không thấy được kết quả thực thi chương trình. Để trở lại màn hình User Screenxem kết quả, ta nhấn tổ hợp phím Alt + F5



1.3. Viết một số chương trình C++:1.3.1. Bài 1:Viết chương trình cho phép nhập vào tên của bạn, sau đó chương trình in radòng chữ "Chào <tên bạn>" ra màn hình

1. Gọi chương trình BC.2. Tạo một tập tin mới.3. Đánh vào đoạn chương trình sau:

//1.1: Chuong trinh cho phep nhap ten va in ra "Chao <ten>"


#include <conio.h>

void main() {

char ten[30];

clrscr();

cout << "Nhap vao ten cua ban: ";

cin.getline(ten, sizeof(ten));

cout << "Chao " << ten;

}

Trong chương trình trên, để cho phép người dùng nhập vào họ tên, ta gọiphương thức getline của luồng cin:

cin.getline(ten, sizeof(ten))

Phương thức này nhận vào 2 đối số là tên biến cần nhận giá trị và số ký tựtối đa ta muốn nhận vào. Ở đây, ta dùng hàm sizeof(ten) để lấy kích thước củabiến ten (=30) làm cho chương tr ình mềm dẻo hơn (nếu ta có thay đổi kíchthước của biến ten thì không cần phải sửa lại câu lệnh trên) .

4. Lưu lại chương trình với tên: chao.cpp5. Chạy chương trình, kết quả sẽ xuất ra như sau:

Nhap vao ten cua ban: Tran Cong An

Chao: Tran Cong An

1.3.2. Bài 2:Viết hàm giải phương trình (PT) bậc 1: ax + b = 0.Viết hàm giải phương trình bậc 2: ax2 + bx + c = 0, có gọi đến hàm giải phươngtrình bậc 1 ở trên.

Nhập vàotên của bạn

Kết quả chươngtrình xuất ra



Viết chương trình nhập vào 3 số thực a, b, c. Giải ph ương trình bậc 2ax2 + bx + c = 0 dùng hàm giải phương trình bậc hai trên.

1. Mở chương trình BC.2. Tạo một tập tin mới.3. Đánh vào đoạn chương trình sau:

//1.2: Viet ham giai PT bac 1, bac 2 va chuong trinh giai

// PT bac 2


#include <conio.h>

#include <math.h>

Trong chương trình này, có sử dụng các hàm toán học để tính căn bậc hainên ta phải khai báo thư viện hàm math.h.

Đánh tiếp đoạn chương trình của hàm giải PT bậc nhất sau://

// Ham giai phuong trinh bac nhat

//

void ptb1(float a, float b) {

float x;

if (a == 0) {

if (b == 0)

cout << "Phuong trinh vo so nghiem";

else

cout << "Phuong trinh vo nghiem";

}

else {

x = -b/a;

cout << "Phuong trinh co nghiem x = " << x;

}

}

Hàm này nhận vào hai đối số là hai hệ số a, b của ph ương trình và hiểnthị kết quả ra màn hình.

Đây chỉ là một đề nghị cho hàm giải PT bật nhất. Ta có thể viết một hàmgiải PT bậc nhất khác với khai báo (prototype) nh ư sau:

int ptb1(float a, float b, float x)

(Sinh viên tự viết xem như một bài tập)

Đánh tiếp đoạn chương trình cho hàm giải PT bậc hai như sau://

// Ham giai phuong trinh bac hai



//

void ptb2(float a, float b, float c) {

float delta, x1, x2;

if (a == 0) {

ptb1(b, c);

}

else {

delta = b*b – 4*a*c;

if (delta < 0) {

cout << "Phuong trinh vo nghiem";

}

else if (delta == 0) {

x1 = -b/(2*a);

cout << "Phuong trinh co nghiem kep: " << x1;

}

else {

x1 = (-b + sqrt(delta)) / (2*a);

x2 = (-b - sqrt(delta)) / (2*a);

cout << "Phuong trinh co 2 nghiem:" << endl;

cout << " x1 = " << x1 << endl;

cout << " x2 = " << x2 << endl;

}

}

}

Trong chương trình có sử dụng hàm sqrt() trong thư viện hàm math.h đểtính căn bậc hai của một số thực. Hàm này có prototype nh ư sau:

double sqrt(double x);

Đánh tiếp vào chương trình hàm main() sau://

// Chuong trinh chinh

//

void main() {

float a, b, c;

clrscr();

cout << "Nhap he so a: ";

cin >> a;

cout << "Nhap he so b: ";

cin >> b;

cout << "Nhap he so c: ";

cin >> c;



ptb2(a, b, c);

}

4. Lưu lại chương trình với tên: giaiptb2.cpp5. Chạy chương trình, kết quả sẽ xuất ra như sau:

Nhap he so a: 2

Nhap he so b: -3

Nhap he so c: 1

Phuong trinh co hai nghiem:

x1 = 1

x2 = 0.5

Ghi chú:Trong chương trình trên, ta tổ chức chương trình theo cấu trúc:

Khai báo thư viện hàm

Định nghĩa hàm Giải PT bậc nhất

Định nghĩa hàm Giải PT bậc hai

Định nghĩa hàm main().

Tuy nhiên, thông thường thì các chương trình được tổ chức như sau:

Khai báo thư viện hàm

Khai báo hàm Giải PTBN: void ptb1(float, float);

Khai báo hàm giải PTBH: void ptb2(float, float, float);

Định nghĩa hàm main()

Định nghĩa hàm ptb1(...) {...}

Định nghĩa hàm ptb2(...) {...}

1.3.3. Bài 3:Viết hàm nhập một danh sách số nguyên vào mảng.Viết hàm dùng để sắp xếp 1 mảng các số nguyên theo thứ tự t ăng dần.Viết chương trình nhập vào một mảng các số nguyên, sắp xếp danh sách đó theothứ tự tăng dần và in danh sách kết quả.

Nhập cáchệ số vào




//1.3: Chuong trinh sap xep mang so nguyen


#include <conio.h>

//----------------------------------------- ------

//khai bao prototype cac ham trong chuong trinh

//-----------------------------------------------

void nhapds(int [], int);

void sxepds(int [], int);

//-------------------------------------

//Chuong trinh chinh

//----------------------------------- --

void main() {

int a[100], n;

clrscr();

cout << "Nhap vao so phan tu: ";

cin >> n;

nhapds(a, n);

sxepds(a, n);

cout << "\nDanh sach sau khi sap xep:\n";

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

cout << "a[" << i << "] = " << a[i] << endl;

}

}

//----------------------------------------------

// Ham nhap mot danh sach cac so nguyen

// Dau vao:

// a: mang so nguyen can nhan gia tri

// n: so phan tu trong mang

// Dau ra: khong.

//----------------------------------------------

void nhapds(int a[], int n) {

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

cout << "Nhap phan tu thu: " << i + 1 << ": ";

cin >> a[i];

}

}



//----------------------------------------------

// Ham sap xep danh sach cac so nguyen

// Dau vao:

// a: mang so nguyen can sap xep

// n: so phan tu trong mang

// Dau ra: khong.

//----------------------------------------------

void sxepds(int a[], int n) {

for (int i=0; i < n-1; i++) {

for (int j=i+1; j < n; j++) {

if (a[i] > a[j]) {

int temp = a[i];

a[i] = a[j];

a[j] = temp;

}

}

}

}

Trong đoạn chương trình trên, ta dùng giải thuật sắp xếp Chọn để xắp xếp danhsách các số nguyên.

4 2 3 6 1

Giả sử để sắp xếp danh sách trên theo thứ tự tăng dần, ta thực hiện như sau:

1. Lấy phần tử đầu tiên trong danh sách làm mốc (phần tử trụ).4 2 3 6 1

2. So sánh với tất cả các phần tử phía sau, nếu có phần từ nào nhỏ hơnphần tử này thì đảo chỗ với phần tử đầu tiên này. Vậy, sau lần đầu tiênthì phần tử đầu trong danh sách là phần tử nhỏ nhất.

2 4 3 6 1

1 4 3 6 2

3. Thực hiện lại bước 1 và 2 cho các phần tử 2 –> (n – 1) trong danh sáchVậy, sau (n – 1) lần thực hiện bước 1 và 2, ta sẽ có danh sách sắp xếptheo thứ tự tăng dần

4. Lưu lại chương trình với tên: dsach.cpp5. Chạy chương trình, kết quả sẽ xuất ra như sau:

Nhap vao so phan tu: 4

Nhap phan tu thu 1: 4




Nhập số phần tử vàgiá trị các phần tử vào



Danh sach sau khi sap xep:

a[0] = 0

a[1] = 1

a[2] = 3

a[3] = 4

1.3.4. Bài 4:Viết chương trình nhập vào 1 danh sách (là con trỏ) số nguyên, sắp xếp danhsách đó theo thứ tự tăng dần và in danh sách kết quả.


//1.4 Ch.trinh nhap dsach con tro, sap xep va in ra mhinh


#include <conio.h>

void main() {

int *a, n, i, j;

clrscr();

cout << "Nhap vao so phan tu: ";

cin >> n;

a = new int[n];

//Nhap gia tri cho mang

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

cout << "Nhap phan tu thu " << i + 1 << ": ";

cin >> a[i];

}

//Sap xep danh sach tang dan

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

for (j=i+1; j < n; j++) {

if (a[i] > a[j]) {

int temp = a[i];

a[i] = a[j];

a[j] = temp;

}

}

}

//In danh sach da sap xep



cout << "\nDanh sach da sap xep:\n";

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

cout << "a[" << i << "] = " << a[i] << endl;

delete []a;

}

Cuối chương trình, ta phải giải phóng vùng nhớ dành cho con trỏ a bằnglệnh delete []a; vì vùng nhớ dành cho a được cấp phát “động” trong khichương trình thực thi nên ta phải giải phóng bằng lệnh delete.

Về giải thuật dùng trong chương trình thì tương tự bài 1.3.3.

4. Lưu tập tin với tên: dsachptr.cpp5. Chạy chương trình

Nhap vao so phan tu: 4





Danh sach sau khi sap xep:

a[0] = 0

a[1] = 1

a[2] = 3

a[3] = 4

1.3.5. Bài 5:Viết hàm để tách tên của một họ tên


//1.5: Chuong trinh tach ten cua mot ho ten


#include <conio.h>

#include <string.h>

void main() {

char hoten[100], ten[10];

int i; //dung de chay vong lap (bien dem)

clrscr();

cout << "Nhap vao ho ten cua ban: ";

cin.getline(hoten, sizeof(hoten));

Nhập số phần tử vàgiá trị các phần tử vào



//thuc hien tach ten, gan cho bien ten

//truoc tien, ta cat bo cac khoang trang ben phai

i = strlen(hoten) – 1;

while (i >0 && hoten[i] == 32)

hoten[i--] = '\0';

//tim vi tri khoang trang cuoi cung de tach ten ra

while ((i >= 0) && (hoten[i] != 32))

i--;

strcpy(ten, hoten + i + 1);

cout << "Ten cua ban la: " << ten;

}

4. Lưu tập tin với tên: tachten.cpp5. Chạy chương trình:

Nhap vao ho ten cua ban: nguyen phu truong

Ten cua ban la: truong

1.3.6. Bài 6:Khai báo một cấu trúc Sinhvien gồm các thuộc tính:

Họ tên, lớp, năm sinh, điểm trung bình.Viết hàm nhập thông tin cho một danh sách sinh viên (dùng con trỏ).Viết hàm In thông tin của một danh sách sinh viên.Viết hàm xếp loại sinh viên dựa trên điểm trung bình.Viết hàm sắp xếp danh sách sinh viên t ăng dần theo tên.Viết hàm main thực hiện các công việc sau:

Tạo ra danh sách gồm n sinh viên.

Nhập dữ liệu cho danh sách đó.

In danh sách đã được sắp xếp theo tên cùng với xếp lọai của SV đó.

In thông tin sinh viên lớn tuổi nhất trong danh sách.


//1.6: Chuong trinh quan ly sinh vien


#include <string.h>

#include <conio.h>

Nhập tên vào đây



typedef struct Sinhvien {

char *hoten;

char lop[30];

char namsinh[5];

float diemtb;

};

//khai bao prototype cua mot so ham trong chuong trinh

int nhap(Sinhvien *&);

void in(Sinhvien*, int);

void sapxep(Sinhvien *, int);

char *xeploai(Sinhvien);

void main() {

Sinhvien *dssv;

int n;

clrscr();

n = nhap(dssv);

sapxep(dssv, n);

cout << "\nDanh sach SV sau khi sap xep:\n";

in(dssv, n);

// Tim sinh vien co tuoi lon nhat

char max[5];

strcpy(max, dssv[0].namsinh);

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

if (strcmp(max, dssv[i].namsinh) > 0)

strcpy(max, dssv[i].namsinh);

}

cout << "\nSinh vien co so tuoi lon nhat:\n";

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

if (strcmp(dssv[i].namsinh, max) == 0)

in(&dssv[i], 1);

}

delete []dssv;

}

int nhap(Sinhvien *&svl) {

int n;

char temp[200];

cout << "Danh sach co bao nhieu SV: ";

cin >> n;

svl = new Sinhvien[n];

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

cout << "Nhap thong tin SV thu " << i + 1 << endl;

cout << "Nhap ho ten: ";

cin.ignore();



cin.getline(temp, sizeof(temp) - 1);

svl[i].hoten = strdup(temp);

cout << "Lop: ";

cin.getline(svl[i].lop, 30);

cout << "Nam sinh: ";

cin >> svl[i].namsinh;

cout << "Diem trung binh: ";

cin >> svl[i].diemtb;

}

return n;

}

void in(Sinhvien *svl, int n) {


cout << "Ho ten: " << svl[i].hoten << endl;

cout << "Lop: " << svl[i].lop << endl;

cout << "Nam sinh: " << svl[i].namsinh << endl;

cout << "Trung binh: " << svl[i].diemtb << endl;

cout << "Xep loai: " << xeploai(svl[i]) << endl;

}

}

char *xeploai(Sinhvien sv) {

if (sv.diemtb >= 9.0)

return "Xuat sac";

else if (sv.diemtb >=8.0)

return "Gioi";


return "Kha";

else if (sv.diemtb >= 5.0)

return "Trung binh";


return "Yeu";

else

return "Kem";

}

//sap xep tang dan (theo ho ten)

void sapxep(Sinhvien *svl, int n) {

for (int i=0; i<n-1; i++) {

for (int j=i+1; j<n; j++) {

if (strcmp(svl[i].hoten, svl[j].hoten) >0) {

Sinhvien temp;

temp = svl[i];

svl[i] = svl[j];

svl[j] = temp;

}

}



}

}

Trong hàm int nhap(Sinhvien *&svl) trên, ta chú ý hai điểm trong cáccâu lệnh sau:

char temp[200];

.....

cin.ignore();

cin.getline(temp, 200);

svl[i].hoten = strdup(temp);

.....

Cách để ta sử dụng một thuộc tính kiểu chuỗi dùng con trỏ (thuộc tínhhoten trong lớp trên).Ở đây, ta không cấp phát cho hoten rồi nhập giá trị trực tiếp cho nómà nhập giá trị vào một biến tạm temp rồi sau đó mới cấp phát và saochép giá trị vào cho thuộc tính này. Điều này cho phép ta cấp phát vừađủ bộ nhớ cho hoten, không bị lãng phí bộ nhớ vì sau khi thực hiệnxong phương thức nhap(...), vùng nhớ của biến temp sẽ bị giải phóng.Nếu trong phương thức này, ta cấp phát trước cho hoten và nhập giátrị cho nó mà không qua biến temp nh ư trên thì sẽ giống như ta khaibáo hoten là một chuỗi có chiều dài cố định, không có tính "động".Ví dụ, nếu ta viết đoạn chương trình nhận giá trị cho hoten lại như sau

.....

svl[i].hoten = new char(200);

cin.getline(sv[i].hoten, sizeof(sv[i].hoten) - 1);

thì giống như ta khai báotypedef struct Sinhvien {

char hoten[200];

....

};

cin.ignore(): phương thức ignore của luồng cin cho phép ta bỏ quamột số ký tự trong luống này.Lý do ta phải sử dụng hàm này là trong một số trường hợp, việc đọcgiá trị cho một biến ở phía trên sẽ làm sót lại ký tự Enter (13) trongluồng cin. Nếu như ta không bỏ qua ký tự này thì khi nhận tiếp giá trịcho một biến kiểu chuỗi thì ký tự này sẽ được gởi đến cho chuỗi đó.Kết quả là ta được một chuỗi rỗng.Hàm này có khai báo như sau (sinh viên tham kh ảo help để xem thêmchi tiết):

istream& ignore(int n = 1, int delim = EOF);

Nếu muốn tránh trường hợp này, ta có thể dùng hàm gets() trong thưviện hàm <stdio.h> để nhập giá trị cho một chuỗi. Hai lệnh:



cin.ignore();

cin.getline(temp, 200);

có thể được thay thế bằng một lệnh gets(temp);

Để đơn giản trong việc nhập chuỗi, các ví dụ sau sẽ sử dụng hàm getsTrong chương trình chính, để in danh sách những sinh viên có tuổilớn nhất, ta duyệt qua danh sách sinh viên 2 l ần: lần thứ nhất để tìmnăm sinh nhỏ nhất của các sinh viên, vòng lặp thứ 2 dùng để in ranhững sinh viên có năm sinh bằng với năm sinh nhỏ nhất đó.

strcpy(max, dssv[0].namsinh);

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

if (strcmp(max, dssv[i].namsinh) > 0)

strcpy(max, dssv[i].namsinh);

}

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

if (strcmp(dssv[i].namsinh, max) == 0)

in(&dssv[i], 1);

}

4. Lưu tập tin với tên: qlsv.cpp5. Chạy chương trình, nhập vào các số liệu sau:

Nhập vào các thôngtin gạch dưới

Các thông tinxuất ra



Chương 2


Sau chương này, sinh viên có thể:

Viết một số chương trình đơn giản bằng phương pháp LTHĐT Thiết kế một số lớp đơn giản Sử dụng các lớp vừa thiết kế



2.1. Bài 1:Thiết kế lớp Diem (Điểm trong không gian hai chiều) với mỗi điểm gồm nhữngthành viên sau:

Thuộc tính: tung độ và hoành độ

Phương thức:

o Gán tọa độ cho một điểm.o Nhập tọa độ cho một điểm.o Hiển thị ra màn hình tọa độ của một điểm theo dạng: (x, y).o Trả về giá trị của hoành độo Trả về giá trị của tung độ

Viết hàm main() thực hiện những yêu cầu sau:

Tạo một điểm A có tọa độ (3, 4). In tọa độ điểm A ra màn hình.

Tạo điểm B, nhập giá trị tọa độ cho điểm B và in tọa độ của B ra màn hình

Tạo điểm C đối xứng với B qua gốc tọa độ. In tọa độ điểm C ra màn hình

Tính khoảng cách từ điểm B đến tâm O.


//2.1 Tao va su dung lop Diem 2D don gian


#include <conio.h>

#include <math.h>

//--------------------------

// Khai bao lop Diem

//--------------------------

class Diem {

int x; //hoanh do

int y; //tung do

public:

void gan(int, int);

void nhap();

void xuat();

int hoanhdo();

int tungdo();

Diem doixung();

};



//---------------------------

//Dinh nghia lop Diem

//---------------------------

void Diem::gan(int h, int t) {

x = h;

y = t;

}

void Diem::nhap() {

cout << "Hoanh do: ";

cin >> x;

cout <<"Tung do: ";

cin >> y;

}

void Diem::xuat() {

cout << "(" << x << ", " << y << ")";

}

int Diem::tungdo() {

return y;

}

int Diem::hoanhdo() {

return x;

}

Diem Diem::doixung() {

Diem kq;

kq.gan(-x, -y);

return kq;

}

//----------------------------

//Dinh nghia ham main()

//----------------------------

void main() {

//tao diem a, gan toa do va in ra man hinh

Diem a;

a.gan(3, 4);

cout << "a ";

a.xuat();

cout << endl;

//tao diem b, nhap toa do va in ra man hinh

Diem b;

b.nhap();

cout << "b ";

b.xuat();

cout << endl;



//tao diem c doi xung diem b, hien thi toa do ra mhinh

Diem c;

c = b.doixung();

cout << "Diem doi xung voi b: ";

c.xuat();

//tinh khoang cach tu b den O

float kc;

kc = sqrt(b.tungdo()*b.tungdo() + b.hoanhdo()*b.hoanhdo());

cout << "\nKhoang cach tu b den O la: " << kc;

}

Trong chương trình này, có sử dụng các hàm toán học để tính căn bậc hainên ta phải khai báo thư viện hàm math.h.

4. Lưu chương trình với tên Diem.cpp5. Chạy chương trình, nhập vào các thông tin gạch dưới, kết quả được như sau:

2.2. Bài 2:Thiết kế lớp Clock, trong đó mỗi đối tượng Clock gồm các thành viên sau:

Thuộc tính: giờ, phút, giây

Phương thức:

o Hàm gán: dùng để khởi tạo – gán giá trị – cho 1 Clocko Hàm nhập giá trị cho 1 Clock.o Hàm xuất giá trị 1 Clock ra màn hìnho Hàm làm tròn một Clock.

VD: 13:59:130 làm tròn thành 15:1:10Viết hàm main() thực hiện những yêu cầu sau:

Tạo 1 Clock có giá trị là 9:15:38. Hiển thị giá trị Clock đó ra màn hình

Tạo 1 Clock, nhập giá trị cho Clock đó và hiển thị ra màn hình.

Làm tròn Clock vừa nhập (nếu cần) và hiển thị ra màn hình.




//2.2: Lop Clock


#include <conio.h>

//--------------------------

//Khai bao lop Clock

//--------------------------

class Clock {

int gio, phut, giay;

public:

void gan(int, int, int);

void nhap();

void xuat();

void lamtron();

};

//-----------------------------

//Dinh nghia lop Clock

//-----------------------------

void Clock::gan(int h, int m, int s) {

gio = h;

phut = m;

giay = s;

}

void Clock::nhap() {

cout << "Nhap gio: ";

cin>> gio;

cout << "Nhap phut: ";

cin >> phut;

cout << "Nhap giay: ";

cin >> giay;

}

void Clock::xuat() {

cout << gio << ":" << phut << ":" << giay;

}

void Clock::lamtron() {

//lam tron giay

phut += (giay / 60);

giay %= 60;

//lam tron phut

gio += (phut / 60);

phut %= 60;



//lam tron gio

gio %= 24;

}

//-----------------------------

//Ham main su dung lop Clock

//-----------------------------

void main() {

Clock c;

//Tao 1 clock voi gia tri la 9:15:38 va hien thi ra MH

c.gan(9, 15, 38);

cout << "Clock c: ";

c.xuat();

cout << endl;

//Tao mot Clock, nhap gtri, lam tron va hien thi ra MH

Clock d;

cout << "Nhap gia tri cho Clock d: \n";

d.nhap();

d.lamtron();

cout << "Clock d sau khi lam tron: ";

d.xuat();

}

4. Lưu chương trình với tên Clock.cpp5. Chạy chương trình, nhập vào các thông tin gạch dưới, kết quả được như sau:

2.3. Bài 3:Thiết kế lớp Date, gồm:

Thuộc tính: ngày, tháng, năm

Phương thức:

o Hàm gán: dùng để khởi tạo – gán giá trị – cho 1 Dateo Hàm nhập giá trị cho 1 Date.o Hàm xuất giá trị 1 Date ra màn hìnho Hàm kiểm tra xem một ngày có hợp lệ không?

VD: ngày 31/06/2000 hay 29/2/1999 là không h ợp lệ



Viết hàm main() khai thác lớp Date vừa định nghĩa


//2.2: Lop Date


#include <conio.h>

#include <math.h>

//-------------------------------

//Khai bao lop Date

//-------------------------------

class Date {

int ngay, thang, nam;

public:


void nhap();

void xuat();

int hople();

};

//-------------------------------------

//Dinh nghia lop Date

//-------------------------------------

void Date::gan(int d, int m, int y) {

ngay = d;

thang = m;

nam = y;

}

void Date::nhap() {

cout << "Ngay: ";

cin >> ngay;

cout << "Thang: ";

cin >> thang;

cout << "Nam: ";

cin >> nam;

}

void Date::xuat() {

cout << ngay << "/" << thang

<< "/" << nam;

}



int Date::hople() {

switch (thang) {

case 1:

case 3:

case 5:

case 7:

case 8:

case 10:

case 12:

if ((ngay <= 31) && (ngay > 0))

return 1;

else

return 0;

case 4:

case 6:

case 9:

case 11:

if ((ngay <= 30) && (ngay > 0))

return 1;

else

return 0;

case 2:

if (nam % 4 == 0) {

if ((ngay <=29) && (ngay > 0))

return 1;

}

else if ((ngay <=28) && (ngay > 0))

return 1;

return 0;

default:

return 0;

} //switch

}

//-------------------------------

//Ham main khai thac lop Date

//-------------------------------

void main() {

Date d1;

d1.gan(10, 10, 2003);

cout << "d1 = ";

d1.xuat();

cout << endl;



Date d2;

d2.nhap();

d2.xuat();

if (d2.hople())

cout << ": Ngay hop le";

else

cout << ": Ngay khong hop le";

}

Ghi chú:

Một ngày hợp lệ được tính như sau:

Tháng 1, 3, 5, 7, 8, 10, 12: 0 < ngày <= 31

Tháng 4, 6, 9, 11: 0 < ngày <= 30

Tháng 2:

o Nhuần: 0 < ngày <= 29

o Không nhuần: 0 < ngày <= 28

4. Lưu chương trình với tên Date.cpp5. Chạy chương trình, nhập vào các giá trị gạch dưới, kết quả hiển thị như sau:

Chạy chương trình lần 2, nhập lại số liệu khác để kiểm tra lại chương trình:



Chương 3


Sau chương này, sinh viên có th ể:

Thiết kế các lớp, các hàm phức tạp hơn Viết các hàm xây dựng, hàm hủy Khởi tạo đối tượng bằng nhiều cách khác nhau



3.1. Bài 1:

Thiết kế lớp Phanso (phân số), trong đó mỗi phân số bao gồm

Dữ liệu: tử số và mẫu số

Phương thức:

o Hàm xây dựng mặc nhiên.o Hàm xây dựng với hai đối số là tử số và mẫu số.o Hàm xây dựng sao chép.o Hàm nhập, xuất phân số ra màn hìnho Hàm nghịch đảo phân sốo Hàm tính giá trị thực của phân sốo Hàm cộng, trừ, nhân, chia hai phân số, kết quả là 1 phân sốo Hàm cộng, trừ, nhân, chia phân số với một số nguyên, kết q uả là 1

phân sốViết hàm main() thực hiện những yêu cầu sau:

Tạo phân số a=3/7, b=4/9. In giá trị hai phân số trên ra màn hình

Tạo 2 phân số x, y với giá trị nhập từ bàn phím và in giá trị ra màn hình

In giá trị nghịch đảo của x

Tính tổng x, y, và in ra màn hình

Tính tích x và 10 và in ra màn hình

Nhập một danh sách gồm n phân số (n nhập từ bàn phím)

Tính tống n phân số đó


//3.1. Lop Phanso


#include <conio.h>

class Phanso {

int tu;

int mau;

int uscln(int, int);

void rutgon();

public:

Phanso() {tu=0; mau=1;} //ham xdung mac nhien



Phanso(int, int);

Phanso(const Phanso&);

void nhap();

void xuat();

void gan(int, int);

Phanso nghichdao();

float trithuc();

Phanso cong(Phanso);

Phanso tru(Phanso);

Phanso nhan(Phanso);

Phanso chia(Phanso);

Phanso cong(int);

Phanso tru(int);

Phanso nhan(int);

Phanso chia(int);

};

Trong phần khai báo lớp này, ngoài những hàm thành viên theo yêu cầucủa bài toán, ta còn khai báo thêm một số hàm thành viên:


dùng để tính ước số chung lớn nhất của hai số nguyên, và:void rutgon();

dùng để rút gọn một phân số do trong các phép toán thực hiện trên phân sốthường đòi hỏi phải rút gọn phân số.

Có nhiều giải thuật được dùng để tìm ước số chung lớn nhất, ở đây tadùng giải thuật như sau:

Tìm ước số chung lớn nhất của a, b:Nếu a = b: USCLN(a, b) = aNgược lại (a != b):

Trong khi a khác b:Nếu a > b, a = a – bNgược lại, b = b - a

Ngoài ra, do hai hàm này ch ỉ hỗ trợ cho các hàm khác nh ư cộng, trừ,nhân, chia,... nên ở đây ta khai báo thuộc tính truy cập của hai hàm này làprivate. Tuy nhiên, ta cũng có thể khai báo thuộc tính truy cập là public đểcho phép người dùng gọi khi cần.

Đánh tiếp vào tập tin trên đoạn chương trình sau://-------------------------------

//cai dat cac ham thanh vien

//-------------------------------

int Phanso::uscln(int a, int b) {



if ((a==0) || (b==0)) return 0;

a = abs(a);

b = abs(b);

while (a!=b)

(a>b)? (a-=b): (b-=a);

return a;

}

void Phanso::rutgon() {

int t = uscln(tu, mau);

tu /= t;

mau /= t;

}

Phanso::Phanso(int t, int m) {

tu = t;

mau = m;

}

Phanso::Phanso(const Phanso& ps) {

tu = ps.tu;

mau = ps.mau;

}

void Phanso::nhap() {

cout << "Tu so: ";

cin >> tu;

cout << "Mau so: ";

cin >> mau;

}

void Phanso::xuat() {

cout << tu << "/" << mau;

}

Phanso Phanso::nghichdao() {

Phanso kq;

kq.tu = mau;

kq.mau = tu;

return kq;

}

float Phanso::trithuc() {

return float(tu)/mau;

}

Phanso Phanso::cong(Phanso ps) {

Phanso kq;



kq.tu = tu*ps.mau + mau*ps.tu;

kq.mau = mau*ps.mau;

kq.rutgon();

return kq;

}

Phanso Phanso::tru(Phanso ps) {

Phanso kq;

kq.tu = tu*ps.mau - mau*ps.tu;


kq.rutgon();

return kq;

}

void Phanso::gan(int t, int m) {

tu = t;

mau = m;

}

Phanso Phanso::nhan(Phanso ps) {

Phanso kq;

kq.tu = tu*ps.tu;


kq.rutgon();

return kq;

}

Phanso Phanso::chia(Phanso ps) {

Phanso kq;

kq = this->nghichdao();

kq = ps.nhan(kq);

return kq;

}

Phanso Phanso::cong(int a) {

Phanso kq(a, 1);

kq = kq.cong(*this);

return kq;

}

Phanso Phanso::tru(int a) {

Phanso kq(a, 1);

kq = this->tru(kq);



return kq;

}

Phanso Phanso::nhan(int a) {

Phanso kq(a*tu, mau);

return kq;

}

Phanso Phanso::chia(int a) {

Phanso kq(tu, mau*a);

return kq;

}

void main() {

//tao 2 phan so 3/7; 4/9 va in ra man hinh

Phanso a(3,7), b(4,9);

cout << "a = ";

a.xuat();;

cout << "b = ";

b.xuat();

cout << endl << endl;

//tao 2 phan so x, y

Phanso x, y;

cout << "Nhap x:\n";

x.nhap();

cout << "Nhap y:\n";

y.nhap();

cout << endl;

cout << "x = ";

x.xuat();

cout << endl;

cout << "y = ";

y.xuat();

cout << endl;

cout << "Nghich dao cua x = ";

x.nghichdao().xuat();

cout << endl;

//tinh tong x, y va in ra man hinh

Phanso tong;

tong = x.cong(y);

cout << "x + y = " ;

tong.xuat();



cout << endl;

//tinh tich x va 10

Phanso tichx10;

tichx10 = x.nhan(10);

cout << "Tich cua x va 10 la: ";

tichx10.xuat();


//nhap danh sach n phan so

int n;

Phanso *ds;

cout << "Nhap vao so phan tu cua danh sach: ";

cin >> n;

ds = new Phanso[n];

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

cout << "Nhap phan so thu " << i + 0 << endl;

ds[i].nhap();

}

//tinh tong

Phanso tongn;

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

tongn = tongn.cong(ds[i]);

cout << endl;

cout << "Tong n phan so: ";

tongn.xuat();

}

Trong hàm float Phanso::trithuc() , ta phải ép giá trị của một trong haitoán hạng của phép chia thành kiểu float để tính trị thực cho phân số. Nếu takhông ép kiểu thì phép toán a/b sẽ luôn cho ra 1 số nguyên.

Trong các hàm tính tổng, hiệu và tích của hai phân số, ta phải gọi đếnhàm rutgon() để rút gọn phân số còn trong hàm tính thương của hai phân sốthì ta không cần gọi vì hàm này gọi tới hàm nhân và trong hàm nhân đã cógọi tới rồi.

Hàm Phanso Phanso::chia(Phanso ps) minh họa cho ta cách viết một hàmdựa trên một hàm có sẵn.

Phanso Phanso::chia(Phanso ps) {

Phanso kq;

kq = this->nghichdao();

kq = ps.nhan(kq);

return kq;

}



Do phép chia hai phân số có thể tính thông qua phép nhân hai phân số(phân số a chia cho b bằng phân số a nhân cho nghịch đảo phân số b).

Lệnh gán kq = this->nghichdao() gán cho kq bằng nghịch đảo của phânsố hiện tại. Sau đó, nhân phân số nghịch đảo này với ps.

Các hàm cộng, trừ, nhân, chia một phân số với một số nguyên cũng đượctính thông qua các hàm cộng, trừ, nhân, chia một phân số với một phân số.

4. Lưu chương trình với tên: Phanso.cpp5. Chạy chương trình.

Kết quả xuất ra: Nghịch đảo của x Tổng x và y Tích x và 10

Nhập vào số phần tửcủa danh sách phân số.Nhập giá trị cho cácphần tử này

Tính tổng của các phầntử trong danh sách



3.2. Bài 2:

Thiết kế lớp Sophuc (số phức: a + bi), trong đó mỗi số phức bao gồm

Dữ liệu: phần thực và phần ảo

Phương thức: định nghĩa các hàm thành viên cần thiết cho lớp này (các hàmxây dựng, nhập/xuất, gán giá trị, cộng, trừ, nhân chia hai số phức )

Viết hàm main() sử dụng lớp vừa định nghĩa:

Tạo một số phức a: 3 + 2i, in số phức này ra màn hình.

Tạo một số phức b, nhập giá trị cho số phức này và in ra màn hình.

Tạo 2 số phức c, d và cho phép người dùng nhập giá trị cho hai số phức này.Hiển thị tông, hiệu, tích và thương của hai số phức này ra màn hình.


//3.2 Lop Sophuc


#include <conio.h>

//----------------------------------

//Khai bao lop Sophuc

//----------------------------------

class Sophuc {

float thuc, ao;

public:

Sophuc();

Sophuc(float, float);

void nhap();

void xuat();

void gan(float, float);

Sophuc cong(Sophuc);

Sophuc tru(Sophuc);

Sophuc nhan(Sophuc);

Sophuc chia(Sophuc);

float laythuc();

float layao();

};



Trong lớp số phức trên, ngoài những dữ liệu và các hàm thành viên c ơbản như trong mô tả của đề bài, ta còn khai báo thêm hai hàmfloat laythuc() và float layao() vì hai phần thực và ảo là dữ liệu riêngnhưng trong quá trình sử dụng một số phức thì ta thường xuyên truy xuấtđến dữ liệu của nó cho nên phải khai báo thêm hai hàm này cho phép ng ườisử dụng lấy giá trị của chúng khi cần thiết.

Đánh tiếp vào đoạn chương trình sau://-----------------------------------

//Dinh nghia cac ham thanh vien

//-----------------------------------

Sophuc::Sophuc() {

thuc = ao = 0.0;

}

Sophuc::Sophuc(float t, float a) {

thuc = t;

ao = a;

}

void Sophuc::nhap() {

cout << "Thuc: ";

cin >> thuc;

cout << "Ao: ";

cin >> ao;

}

void Sophuc::xuat() {

cout << thuc;

if (ao >= 0)

cout << " + ";

cout << ao << "i";

}

Sophuc Sophuc::cong(Sophuc p) {

Sophuc kq;

kq.thuc = thuc + p.thuc;

kq.ao = ao + p.ao;

return kq;

}

Sophuc Sophuc::tru(Sophuc p) {

Sophuc kq;

kq.thuc = thuc - p.thuc;

kq.ao = ao - p.ao;

return kq;

}



//-------------------------------------------

// (a+bi) * (c+di) = (ac - bd) + (ad + bc)i

//-------------------------------------------

Sophuc Sophuc::nhan(Sophuc p) {

Sophuc kq;

kq.thuc = thuc*p.thuc - ao*p.ao;

kq.ao = thuc*p.ao + ao*p.thuc;

return kq;

}

//-------------------------------------------

// (a+bi) / (c+di) = ((ac+bd)/(cc+dd)) +

// ((bc-ad)/(cc+dd))i

//-------------------------------------------

Sophuc Sophuc::chia(Sophuc p) {

Sophuc kq;

kq.thuc = (thuc*p.thuc + ao*p.ao)

/ (p.thuc*p.thuc + p.ao+p.ao);

kq.ao = (ao*p.thuc - thuc*p.ao)

/ (p.thuc*p.thuc + p.ao+p.ao);

return kq;

}

float Sophuc::laythuc() {

return thuc;

}

float Sophuc::layao() {

return ao;

}

void main() {

clrscr();

Sophuc p1(3, 4);

p1.xuat();

cout << endl;

Sophuc b;

cout << "Nhap b:\n";

b.nhap();

cout << "b = ";

b.xuat();

cout << endl;

Sophuc c, d;

cout << "Nhap c:\n";

c.nhap();



cout << "Nhap d:\n";

d.nhap();

cout << "c + d = ";

c.cong(d).xuat();

cout << endl;

cout << "c - d = ";

c.tru(d).xuat();

cout << endl;

cout << "c * d = ";

c.nhan(d).xuat();

cout << endl;

cout << "c / d = ";

c.chia(d).xuat();

}

Trong hàm main(), ta có sử dụng đến cú pháp sau:c.cong(d).xuat();

dùng để hiển thị tổng của c và d ra màn hình. Đây là một hình thức viếtngắn gọn khi ta chỉ cần hiển thị kết quả lên màn hình mà không cần l ưu trữlại giá trị của phép tính.

c.cong(d) sẽ trả về một đối tượng Sophuc, số phức này có giá trị là tổngcủa c và d. Sau đó, ta truy xuất tiếp đến phương thức xuat() của đối tượngnày bằng lệnh c.cong(d).xuat().

Ta có thể viết lệnh trên một cách rõ ràng h ơn bằng cách thay lệnh trênbăng những lệnh sau:

Sophuc tong;

tong = c.cong(d);

tong.xuat();

Cách viết này có một khuyết điểm nếu như đối tượng tong không đượcdùng nữa trong những phần sau của ch ương trình là ta sẽ phí bộ nhớ cho đốitượng này nhưng bù lại là tính dễ đọc của chương trình.

Trong những lệnh hiển thị kết quả các phép tính còn lại cũng t ương tự.

Một số phép toán trên số phức: Tổng:

(a+bi) + (c+di) = (a+c) + (b+d)i

Hiệu:(a+bi) - (c+di) = (a-c) + (b-d)i

Tích:(a+bi) * (c+di) = (ac-bd) + (ad+bc)i



Thương:(a+bi) * (c+di) = [(ac+bd)/(c2+d2)]

+ [(bc-ad)/(c2+d2)]i

4. Lưu chương trình với tên: Sophuc.cpp5. Chạy chương trình, sinh viên tự nhập vào các giá trị để kiểm tra chương trình.

3.3. Bài 3:

Tách tất cả các lớp đã viết thành 2 tập tin:

Tập tin chứa khai báo lớp: <tên lớp>.hpp

Tập tin chứa các định nghĩa hàm của lớp: <tên lớp>.cppĐịnh nghĩa hàm main() sử dụng lớp trong một tập tin riêng.Chú ý: có sử dụng các chỉ thị tiền xử lý để tránh trường hợp include lớp nhiềulần trong một chương trình.

Ta tách các chương tr ình ra theo sơ đồ sau:

Tuy nhiên, ta có trường hợp sau:

*.hpp

Đặt phầnkhai báo lớp

vào tập tin này

*.cpp#include "đường dẫn đến tập tin khai báo lớp .hpp"

Đặt phần định nghĩa lớp vào tập tin này

*.cpp#include "đường dẫn đến tập tin định nghĩa lớp .cpp"

Đặt đoạn mã của chương trình chính vào đây

Diem.hpp Diem.cpp#include "Diem.hpp"

Dthang.hpp#include "Diem.cpp"

Dthang.cpp#include "Dthang.hpp"

main.cpp#include "Diem.cpp"# include "Dthang.cpp"

Trong chương trình chính, sẽ include Diem.cpp hailần, một lần là lệnh #include "Diem.cpp" , một lần làkhi ta include Dthang.cpp, trong tập tin này lại cólệnh #include "Diem.cpp" một lần nữa. Chương trình sẽ bị lỗi



CDiem.cpp

#include "Phanso.hpp"

Đặt phần định nghĩa các hàm thành viêncủa lớp Phanso vào đây

Vậy, để tránh trường hợp trên thì khi phân tách các lớp ra thành các tập tintheo cấu trúc như trên, ta cũng cần chú ý đến việc sử dụng các chỉ thị tiền xửlý (#ifndef, #define, #endif,...) đ ể tránh việc include một lớp nhiều lần.

Ví dụ, ta tách lớp Phanso trong bài 3.1 như sau:

Hoặc bài lớp Diem trong bài 2.1 được tách ra như sau:

Các hằng số __CPS__ hoặc __CDIEM__ có thể đặt tùy ý.

Chú ý:

CPhanso.hpp

#ifndef __CPS__

#define __CPS__


#include <conio.h>

class Phanso {

[các thành viên c ủ a lớ p]

};

#endif

CPhanso.cpp

#include "Phanso.hpp"

Đặt phần định nghĩa các hàm thành viêncủa lớp Phanso vào đây

SdungPS.cpp

#include "Phanso.cpp"

Đặt phần mã của hàm main() vào đây

CDiem.hpp

#ifndef __CDIEM__

#define __CDIEM__


#include <conio.h>

class Phanso {

[các thành viên c ủ a lớ p]

};

#endifSdDiem.cpp

#include "Phanso.cpp"

Đặt phần mã của hàm main() vào đây



Nếu như các tập tin này không nằm cùng một th ư mục thì ta phải sửa lạiđường dẫn trong chỉ thị tiền xử lý #include để chỉ đường dẫn đến tập tin ta cầninclude.

Một điểm nữa ta cần chú ý trong việc include các tập tin không phải làthư viện hàm chuẩn vào chương trình là ta dùng cặp dấu nháy đôi ( " ) để baoquanh đường dẫn đến tập tin cần include chứ không phải cặp dấu <> nh ư trongtrường hợp include các thư viện hàm chuẩn.

Khi biên dịch hoặc chạy chương trình, ta cần chuyển thư mục làm việccủa BC về thư mục chứa các tập tin này, nếu không ghi đường dẫn đầy đủ (tuyệtđối) trong lệnh #include.

Để chuyển thư mục làm việc của BC, ta thực hiện những b ước sau:

1. Chọn menu File\Change Dir2. Hộp thoại Change Directory bật lên cho phép ta chọn thư mục làm việc của

BC.

Ta có thể chọn bằng cách đánh trực tiếp vào ô Directory Name hoặc chọntrong ô Directory tree. Sau khi chọn xong nhấn nút OK

Sau khi tách làm 3 tập tin như trên, ta biên dịch tập tin chứa hàm main() vàchạy tập tin này.

3.4. Bài tập tự làm thêm:3.4.1. Bài 1:

Sinh viên chỉnh lại các lớp đã viết trong buổi 2, khai báo và định nghĩa thêmcác hàm xây dựng. Viết lại hàm main() để khởi tạo các đối tượng theo kiểukhác (bằng hàm xây dựng)

3.4.2. Bài 2:Thiết kế chương trình quản lý sinh viên, trong đó mỗi sinh viên cần quản lýcác thông tin sau: họ tên, mã số, ngày tháng năm sinh, quê quán, mã lớp,khóa học.Ngoài các thuộc tính trên, lớp Sinhvien cần các ph ương thức sau:

Hàm xây dựng mặc nhiên (không đối số) Hàm xây dựng có đối số (để khởi tạo các thông tin cho 1 sinh vi ên. Hàm hủy, dùng để giải phóng bộ nhớ cho các con trỏ Hàm nhập thông tin Hàm xuất thông tin Hàm kiểm tra xem một sinh viên nào đó có cùng lớp hay không. Hàm kiểm tra xem một sinh viên nào đó có cùng quê quán với sinh

viên này hay không. Hàm so sánh một sinh viên nào đó có lớn tuổi hơn sinh viên này

không.

Viết hàm main() sử dụng lớp Sinhvien trên:



Tạo một sinh viên, nhập thông tin cho sinh viên đó và hiển thị thôngtin ra màn hình.

Tạo một sinh viên thứ 2, nhập thông tin cho sinh viên này. Hiển thị ramàn hình cho biết sinh viên này và sinh viên thứ nhất có cùng quêquán hay không.

Tạo một danh sách gồm n sinh viên (n: nhập từ bàn phím) Sắp xếp danh sách học sinh này theo thứ tự t ăng dần của tên sinh viên



Chương 4


Tiếp tục thực tập thiết kế lớp và định nghĩa các hàm thành viên Sử dụng các kỹ thuật: hàm bạn, định nghĩa các tác tử



4.1. Bài 1:

Chỉnh lại lớp Phanso, dùng cách định nghĩa toán tử để tái định nghĩa các phéptoán sau:

Cộng, trừ, nhân, chia hai phân số và một phân số với một số nguyên.

Định nghĩa thêm tác tử =

Phép toán so sánh lớn hơn, nhỏ hơn

Các phép toán xuất nhập.Viết hàm sắp xếp một mảng các phân số theo thứ tự giảm dần.Viết hàm main() thực hiện những yêu cầu nh ư trong bài 3.1 và thêm các yêu cầusau:

In ra phân số có giá trị lớn nhất trong danh sách đã nhập

Sắp xếp danh sách phân số đó theo thứ tự giảm dần.(SV có thể định nghĩa thêm các hàm khác nếu thấy cần thiết)


//3.2. Lop Phanso – Tai dinh nghia tac tu


#include <conio.h>

class Phanso {

int tu;

int mau;


void rutgon();

public:

Phanso() {tu=0; mau=1;} //ham xdung mac nhien

Phanso(int, int);

Phanso(const Phanso&);

void gan(int, int);

void nhap();

void xuat();

Phanso nghichdao();

Phanso &operator = (const Phanso &);



Phanso operator + (const Phanso &);

Phanso operator - (const Phanso &);

Phanso operator * (const Phanso &);

Phanso operator / (const Phanso &);

friend Phanso operator + (const Phanso &, int);

friend Phanso operator – (const Phanso &, int);

friend Phanso operator * (const Phanso &, int);

friend Phanso operator / (const Phanso &, int);

int operator > (const Phanso &);

};

Trong phần khai báo lớp Phanso này, các phép toán trên phân số sẽ đượcviết bằng cách tái định nghĩa tác tử. Cách viết này cho phép ta dùng cú phápquen thuộc hơn.

Ví dụ: trong bài 3.1, để tính tổng các phân số x = y + z, ta dùng cú phápx= y.cong(z). Cú pháp này tuy không phức tạp nhưng mất đi vẻ tự nhiên củaviệc thực hiện các phép toán trên các phân số (ví dụ nh ư tính tổng hai sốnguyên ta lại dùng cú pháp a = b + c).

Tái định nghĩa tác tử cho phép ta dùng cú pháp một cách tự nhiên hơn khithực hiện các phép toán trên các đối tượng kiểu Phanso.

Ví dụ: để cộng hai phân số sau khi đã tái định nghĩa tác tử cộng (+), tadùng cú pháp sau: x = y + z. Rõ ràng là so với cú pháp cộng hai phân sốtrong bài 3.1 thì cú pháp này tự nhiên hơn.

Chú ý:

Ngoài cách tái định nghĩa tác tử như trên – dùng hàm thành viên – ta cũng cóthể tái định nghĩa toán tử bằng hàm độc lập. Khai báo như sau:

friend Phanso operator + (Phanso &, Phanso &);

friend Phanso operator – (Phanso &, Phanso &);

friend Phanso operator * (Phanso &, Phanso &);

friend Phanso operator / (Phanso &, Phanso &);

Đối với tái định nghĩa tác tử bằng hàm thành viên và tái định nghĩa bằng hàmđộc lập thì tái định nghĩa bằng hàm thành viên sẽ ít hơn một đối số.

Lý do là khi ta tái định nghĩa bằng hàm thành viên:

Phanso operator + (Phanso &);

thì toán hạng bên trái toán tử sẽ được hiểu ngầm là đối tượng mà ta đang xét

Ví dụ: khi ta viết x = y + z thì sẽ được dịch ra là:

x = y.operator + (z) .

Còn khi ta tái định nghĩa bằng hàm độc lập, thì hai đối số của hàm chính làhai toán hạng của toán tử. Và khi ta dùng toán tử này, ví dụ: x = y + z thì sẽđược dịch ra là x = operator + (x, y). Đây chính là sự khác biệt giữa hai cáchtái định nghĩa.



Và cũng do trong cách tái định nghĩa bằng hàm thành viên, một đối số bêntrái của toán tử luôn được hiểu ngầm và toán tử tái định nghĩa thì không có tínhngiao hoán cho nên đối vối những toán tử mà đối đối số bên trái không phải làđối tượng của lớp đang xét thì ta không thể tái định nghĩa bằng hàm thành viênđược.

Ví dụ: tái định nghĩa toán tử cộng giữa một phân số với một số nguyênx = y + z với y là số nguyên và z là phân số thì ta chỉ có thể tái định nghĩa bằnghàm độc lập:

friend Phanso operator + (int, Phanso &);

Trong khai báo lớp, có khai báo thêm hàm tái định nghĩa tác tử sosánh lớn hơn (>). Hàm này đề bài không có yêu cầu nhưng do ta phải sắpxếp danh sách các phân số nên cần so sánh giá trị của hai phân số. Ta có thểdùng cách khác là viết hàm trả về giá trị của một phân số để trong hàm sắpxếp ta có thể gọi hàm này để so sánh giá trị của hai phân số.

Một điểm cần chú ý nữa là trong lớp Phanso này, ta không cần hàmxây dựng sao chép vì hàm xây dựng sao chép chỉ cần thiết k hi dữ liệu thànhviên của lớp có con trỏ. Yêu cầu viết hàm xây dựng sao chép trong bài nàychỉ có tác dụng thực hành mà thôi.

Đánh tiếp vào chương trình đọan mã sau://-------------------------------

//cai dat cac ham thanh vien

//-------------------------------

int Phanso::uscln(int a, int b) {

while (a!=b)

(a>b)? (a-=b): (b-=a);

return a;

}

void Phanso::rutgon() {

int t = uscln(tu, mau);

tu /= t;

mau /= t;

}

Phanso::Phanso(int t, int m) {

tu = t;

mau = m;

}

Phanso::Phanso(const Phanso& ps) {

tu = ps.tu;

mau = ps.mau;

}



void Phanso::gan(int t, int m) {

tu = t;

mau = m;

}

void Phanso::nhap() {

cout << "Tu so: ";

cin >> tu;

cout << "Mau so: ";

cin >> mau;

}

void Phanso::xuat() {

cout << tu << "/" << mau;

}

Phanso Phanso::nghichdao() {

Phanso kq;

kq.tu = mau;

kq.mau = tu;

return kq;

}

Phanso& Phanso::operator = (const Phanso &p) {

tu = p.tu;

mau = p.mau;

return *this;

}

//

// Cac phep toan giua hai phan so

//

Phanso Phanso::operator + (const Phanso &p) {

Phanso kq;

kq.tu = tu*p.mau + mau*p.tu;

kq.mau = mau*p.mau;

kq.rutgon();

return kq;

}

Phanso Phanso::operator - (const Phanso &p) {

Phanso kq;

kq.tu = tu*p.mau - mau*p.tu;

kq.mau = mau*p.mau;

kq.rutgon();

return kq;

}



Phanso Phanso::operator * (const Phanso &p) {

Phanso kq;

kq.tu = tu*p.tu;

kq.mau = mau*p.mau;

kq.rutgon();

return kq;

}

Phanso Phanso::operator / (const Phanso &p) {

Phanso kq;

kq = *this * p.nghichdao();

return kq;

}

//

//Cac phep toan giua mot phan so va mot so nguyen

//

Phanso operator + (const Phanso &p, int n) {

Phanso kq;

kq.gan(n, 1);

kq = p + kq;

return kq;

}

Phanso operator - (const Phanso &p, int n) {

Phanso kq(n, 1);

kq = p - kq;

return kq;

}

Phanso operator * (const Phanso &p, int n) {

Phanso kq(n, 1);

kq = p*kq;

return kq;

}

Phanso operator / (const Phanso &p, int n) {

Phanso kq(1, n);

kq = p * kq;

return kq;

}

//

//Ham tai dinh nghia tac tu lon hon



//Ham tra ve gia tri 1 neu dung

// 0 neu sai

//

int Phanso::operator > (const Phanso &p) {

if ((float)tu/mau > (float)p.tu/p.mau)

return 1;

else

return 0;

}

//sap xep danh sach theo thu tu tang dan

void sapxep(Phanso *ds, int soluong) {

for (int i=0; i<soluong-1; i++) {

for (int j=i+1; j<soluong; j++) {

if (ds[i] > ds[j]) {

Phanso t;

t = ds[i];

ds[i] = ds[j];

ds[j] = t;

}

}

}

}

Trong phần định nghĩa các hàm thành viên trên, ta có sử dụng nhiều cáchviết nhằm mục đích là để sinh viên làm quen với nhiều cách sử dụng đốitượng.

Ví dụ, xét hai hàm thành viên sau:Phanso operator + (const Phanso &p, int n) {

Phanso kq;

kq.gan(n, 1);

kq = p + kq;

return kq;

}

Phanso operator - (const Phanso &p, int n) {

Phanso kq(-n, 1)

kq = kq + kq;

return kq;

}

Phép cộng một phân số p với một số nguyên n có thể được xem là phépcộng phân số p với phân số n/1. Do đó, ta tạo một phân số kq có giá trị làn/1 và cộng với phân số p. Tương tự cho phép trừ phân số cho một sốnguyên.



Cái khác giữa cách viết hai hàm ở đây là câu lệnh tạo phân số kq = n/1.Trong hàm tái định nghĩa tác tử +, ta dùng câu lệnh Phanso kq và kg.gan(n,

1) trong khi trong hàm tái đ ịnh nghĩa tác tử -, ta chỉ dùng một câu lệnhPhanso kq(-n, 1) để tạp ra phân số n/1.

Tuy nhiên, khi viết chương trình thì ta nên chọn 1 cách viết thống nhấttrong chương trình đối với những thao tác giống nhau. Cách đầu tiên thì rõràng nhưng dài hơn còn cách 2 thì ngắn hơn nhưng lại không trong sángbằng cách 1.

Viết tiếp hàm main() cho chương trình sau://-------------------------------------

//Chuong trinh chinh

//-------------------------------------

void main() {

//tao 2 phan so 3/7; 4/9 va in ra man hinh

Phanso a(3,7), b(4,9);

cout << "a = ";

a.xuat();

cout << ", b = ";

b.xuat();


//tao 2 phan so x, y

Phanso x, y;

cout << "Nhap x:\n";

x.nhap();

cout << "Nhap y:\n";

y.nhap();

cout << endl;

cout << "x = ";

x.xuat();

cout << endl;

cout << "y = ";

y.xuat();

cout << endl;

cout << "Nghich dao cua x = ";

x.nghichdao().xuat();

cout << endl;

//Tinh thuong x va y

Phanso thuong;

thuong = x / y;

cout << "x / y = ";

thuong.xuat();

cout << endl;



//tinh tong x, y va in ra man hinh

Phanso tong;

tong = x + y;

cout << "x + y = " ;

tong.xuat();

cout << endl;

//tinh tich x va 10

Phanso tichx10;

tichx10 = x * 10;

cout << "Tich cua x va 10 la: ";

tichx10.xuat();


//nhap danh sach n phan so

int n;

Phanso *ds;

cout << "Nhap vao so phan tu cua danh sach: ";

cin >> n;

ds = new Phanso[n];

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

cout << "Nhap phan so thu " << i + 0 << endl;

ds[i].nhap();

}

//tinh tong

Phanso tongn(0,1);

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

tongn = tongn + ds[i];

cout << endl;

cout << "Tong n phan so: ";

tongn.xuat();

//in ra phan so co gia tri lon nhat

Phanso max;

max = ds[0];

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

if (ds[i] > max)

max = ds[i];

}

cout << endl;

cout << "Phan so lon nhat trong danh sach la: ";

max.xuat();

cout << endl;



//in ra danh sach theo thu tu giam dan

sapxep(ds, n);

cout << "Danh sach sap xep theo thu tu giam dan: ";

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

ds[i].xuat();

cout << " ";

}

}

Chú ý:

Ta chú ý các dòng lệnh in đậm trong hàm main(). Sau khi tái định nghĩa cáctoán tử trong lớp Phanso thì ta có thể dùng các toán tử trên các phân số nh ư cáckiểu dữ liệu cơ bản khác.

Ví dụ:tong = x + y;

if (ds[i] > max)

Với tong, x, y, max, ds[i] là những đối tượng kiểu Phanso

4. Lưu chương trình lại với tên: Pso2.cpp5. Chạy chương trình, nhập vào các số liệu để kiểm tra chương trình:

4.2. Bài 2:

Thiết kế lớp Thuebao đơn giản dùng để ghi nhận thông tin của một thuê baođiện thoại bao gồm các thông tin sau:

Số điện thoại

Họ tên người thuê bao

Địa chỉ của thuê bao (số ký tự không xác định)

Nhập vào các số liệuđược gạch dưới

Kết quả xuất ra

Nhập tiếp các sốliệu gạch dưới

Kết quả xuất ra



Số phút gọiNgoài ra, còn có các hàm thành viên sau:

Hàm xây dựng, hàm hủy

Hàm nhập, hàm in thông tin của thuê bao

Hàm tính cước điện thọai chưa có thuế giá trị gia tăng. Biết rằng:Tiền cước = tiền thuê bao + tiền cuộc gọi

Tiền thuê bao mỗi tháng là 27.000 đồngTiền cuộc gọi:

Số phút Đơn giá (đ)Từ phút 1 đến 200 120Từ phút 201 đến 1000 80Từ phút 1001 trở đi 40

Hàm tính cước có thuế giá trị gia tăng

Tái định nghĩa tác tử nhập >>, cho phép nhập th ông tin cho một thuêbao từ bàn phím

Tái định nghĩa tác tử xuất >> để xuất thông tin thuê bao ra màn hìnhViết hàm main() thực hiện những yêu cầu sau:

Nhập danh sách gồm n thuê bao (n: nhập từ bàn phím)

Tính cước cho tất cả các thuê bao trên

In danh sách và tổng số tiền thu được

Nhập 1 họ tên, tìm số điện thoại của người có họ tên vừa nhập

Nhập 1 số điện thoại, in thông tin của thuê bao có số điện thọai đó

In danh sách thuê bao theo thứ tự tăng dần của họ tên


//4.2. Lop Thuebao


#include <conio.h>

#include <string.h>

#include <stdio.h>

//---------------------------------



// Khai bao lop

//---------------------------------

class Thuebao {

char sodt[15];

char hoten[50];

char *diachi;

int sophut;

public:

Thuebao();

Thuebao(char*, char *, char *, int = 0);

Thuebao(const Thuebao&);

void nhap();

void xuat();

Thuebao& operator = (const Thuebao&);

friend ostream& operator << (ostream &, const Thuebao &) ;

friend istream& operator >> (istream &, Thuebao &);

float tinhcuoc();

float cuocVAT();

char *laysodt() {return sodt;}

char *layhoten() {return hoten;}

char *laydiachi() {return diachi;}

int laysophut() {return sophut;}

};

Hàm xây dựng Thuebao(char*, char *, char *, int = 0) chỉ dùng thamsố mặc nhiên cho tham số cuối cùng vì đối với một thuê bao thì nếu đã cóthông tin thì không thể thiếu một trong 3 thông tin đầu tiên nên tất cả cáctham số trước đều là tham số bắt buộc.

Ngoài các hàm thành viên như yêu cầu của bài tập, ta còn có thêm các hàm:char *laysodt() {return sodt;}

char *layhoten() {return hoten;}

char *laydiachi() {return diachi;}

int laysophut() {return sophut;}

cho phép người dùng lấy giá trị các thuộc tí nh của đối tượng Thuebao vìtrong các thao tác sắp xếp, tìm kiếm ta cần truy xuất tới các thuộc tính này.Và do các hàm này rất ngắn nên ta viết dạng hàm inline.

Lớp này có dữ liệu là con trỏ nên ta cần viết hàm xây dựng sao chép vàhàm tái định nghĩa toán tử gán cho lớp này.



Đánh tiếp phần định nghĩa lớp sau://---------------------------------

// Dinh nghia lop

//---------------------------------

//

// Cac ham xay dung, xay dung sao chep

//

Thuebao::Thuebao() {

strcpy(sodt, "");

strcpy(hoten, "");

diachi = (char*) NULL;

sophut = 0;

}

Thuebao::Thuebao(char *dt, char *ht, char *dc, int sp) {

strcpy(sodt, dt);

strcpy(hoten, ht);

diachi = strdup(dc);

sophut = sp;

}

Thuebao::Thuebao(const Thuebao& t) {

strcpy(sodt, t.sodt);

strcpy(hoten, t.hoten);

diachi = strdup(t.diachi);

sophut = t.sophut;

}

//

// Cac ham nhap/xuat thong tin cho Thuebao

//

void Thuebao::nhap() {

cin >> *this;

}

void Thuebao::xuat() {

cout << *this;

}

//

// Cac ham tai dinh nghia tac tu =, xuat/nhap

//

Thuebao& Thuebao::operator = (const Thuebao& t) {

strcpy(sodt, t.sodt);

strcpy(hoten, t.hoten);

diachi = strdup(t.diachi);

sophut = t.sophut;



return *this;

}

ostream& operator << (ostream &out, const Thuebao &tb) {

out << "Thue bao: " << tb.sodt;

out << " - HT: " << tb.hoten;

out << " - DC: " << tb.diachi;

out << " - DT: " << tb.sodt;

return out;

}

istream& operator >> (istream &in, Thuebao &tb) {

char temp[200];

cout << "So dien thoai: ";

in >> tb.sodt;

cout << "Ho ten: ";

gets(tb.hoten);

cout << "Dia chi: ";

gets(temp);

tb.diachi = strdup(temp);

cout << "So phut: ";

in >> tb.sophut;

return in;

}

//

// Các ham tinh cuoc khong thue va co thue

//

float Thuebao::tinhcuoc() {

float kq;

if (sophut <= 200)

kq = sophut * 120.0;

else if (sophut <=1000)

kq = 200*120.0 + (sophut-200)*80.0;

else

kq = 200*120.0 + 800*80.0 + (sophut-1000)*40.0;

return kq + 27000;

}

float Thuebao::cuocVAT() {

return (tinhcuoc() + tinhcuoc()*0.1);

}



Trong hàm xây dựng, ta cần chú ý cách khởi tạo giá trị cho các loại biếnkhác nhau. Ví dụ giữa hai cách khởi tạo sau đây:

strcpy(hoten, "");

diachi = (char*) NULL;

Do hoten là một mảng ký tự, đã được cấp phát vùng nhớ nên ta chỉ cầnkhởi tạo giá trị ban đầu. Còn đối với diachi là một con trỏ nên ta có thể cóhai cách khởi tạo giá trị:

Cấp phát vùng nhớ cho con trỏ (VD: diachi = new char[200] ) Cho con trỏ trỏ về NULL

Trong bài tập này, ta sử dụng cách thứ 2 do cách thứ nhất làm mất đi tính"động" của độ dài của thuộc tính diachi.

Và ứng với những cách khởi tạo giá trị cho các thuộc tính, ta sẽ có cáccách nhập giá trị khác nhau cho chúng. Trong bài này, ta có cách nhập giátrị cho thuộc tính diachi như sau:

gets(temp);

tb.diachi = strdup(temp);

Ở đây, ta sẽ nhập giá trị tạm vào biến temp và sẽ cấp phát vùng nhớ vàcopy giá trị cho thuộc tính diachi chính xác với giá trị mà người dùng đãnhập vào. Điều này cho phép chúng ta xây dựng một thuộc tính diachi mangtính chất "động" hoàn toàn.

Đối với các hàm tái định nghĩa tác tử xuất và nhập, ta chỉ có thể viết dạnghàm bạn vì tác tử này có dạng như sau: cout << obj hoặc cin >> obj. Toánhạng bên trái của hai toán tử này không phải kiểu đối tượng mà là luồngnhập/xuất nên không thể viết dạng h àm thành viên.

Sau khi đã tái định nghĩa hai tác tử xuất/nhập rồi thì trong hàm thành viênnhap(), xuat() ta không cần viết lại mà chỉ cần gọi đến hai hàm này:

void Thuebao::nhap() {

cin >> *this;

}

void Thuebao::xuat() {

cout << *this;

}

Con trỏ this trỏ đến chính đối tượng đang xét, *this cho ta tham khảo đếnnội dung của con trỏ này, nó chính là nội dung của đối tượng đó. Như vậy làlệnh cout << *this sẽ xuất nội dung của đối tượng ra luồng cout (việc xuấtmột đối tượng vào luồng cout đã được định nghĩa trong hàm tái định nghĩatác tử xuất). Tương tự cho hàm nhap().Đánh vào hàm main() của chương trình://---------------------------------


//---------------------------------

void main() {



Thuebao *ds;

int n;

clrscr();

cout << "Nhap so thue bao: ";

cin >> n;

ds = new Thuebao[n];

//nhap thong tin cho n Thuebao


cout << "Nhap thong tin thue bao thu " << i + 1;

cout << endl;

cin >> ds[i];

}

//In danh sach thue bao va tong so tien thu duoc

float tongcuoc=0.0;

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

cout << ds[i] << endl;

cout << "---------------" << endl;

tongcuoc +=ds[i].tinhcuoc();

}

cout <<"Tong cuoc thu duoc: " << tongcuoc << endl;

getch();

clrscr();

//tim kiem thue bao

char ht[50];

cout << "Nhap ho ten thue bao can tim: ";

gets(ht);

cout << "Ket qua tim kiem: " << endl;

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

if (strcmp(ht, ds[i].layhoten()) == 0)


}

//tim kiem thong tin thue bao

char dt[15];

cout << "Nhap so dien thoai cua thue bao can tim: ";

gets(dt);

cout << "Ket qua tim kiem: " << endl;

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

if (strcmp(dt, ds[i].laysodt()) == 0)


}



getch();

clrscr();

//sap xep danh sach theo thu tu ho ten thue bao

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


if (strcmp(ds[i].layhoten(),ds[j].layhoten())>0) {

Thuebao t = ds[i];

ds[i] = ds[j];

ds[j] = t;

}

}

}

cout << "Danh sach thue bao sau khi sap xep " << endl;

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


cout << "---------------" << endl;

}

}

Những dòng mã được in đậm minh họa cho ta thấy cách sử dụng nhữngtoán tử nhập/xuất trên các đối tượng.

Trong chương trình trên, ta cũng có sử dụng đến phương thức ignore củaluồng cin: cin.ignore(). Công dụng của phương thức này đã được trình bàytrong bài 1.3.6.

4. Lưu chương trình với tên Thuebao.cpp5. Chạy chương trình, nhập vào các thông tin để kiểm tra chương trình:

1. Nhập vào các thôngtin được gạch dưới

2. Các thông tin sausẽ được xuất ra

(ds thuê bao)

3. Nhấn Enter



4. Đánh vào tênthuê bao cần tìm

5. Đánh vào sốđiện thoại cần tìm

6. Enter để xemds đã sắp xếp



Chương 5


Thiết kế lớp với dữ liệu thành viên là đối tượng của lớp khác



5.1. Bài 1:Thiết kế lớp Doanthang gồm các thành phần sau:

Thuộc tính: gồm tọa độ điểm đầu và điểm cuối đoạn thẳng, là hai đốitượng thuộc lớp Diem đã thiết kế trong bài 2.1 (sử dụng lớp Diem đãđược tách ra trong bài 3.3)

Các hàm xây dựng và hàm hủy

Các hàm thành viên:

o Nhập tọa độ của đọan thẳng

o In tọa độ của đọan thẳng (tọa độ điểm đầu và điểm cuối)

o Tính độ dài đoạn thẳng

o Tính góc giữa đoạn thẳng với trục hoành

o Hàm tịnh tiến đọan thẳng.Thiết kế hàm main() thực hiện những yêu cầu sau:

Tạo 2 điểm A(2, 5) và B(20, 35). Tạo đọan thẳng AB, tịnh tiến AB đi mộtđoạn (5, 3).

Tạo một đoạn thẳng CD bất kỳ. Nhập giá trị cho đoạn thẳng đó.

Tính độ dài CD, góc giữa CD với trục hoành.

1. Mở chương trình BC.2. Mở tập tin Cdiem.hpp trong bài 3.3, bổ sung thêm một số thành viên nh ư sau:

//

//2.1. Khai bao lop Diem

//

#ifndef __CDIEM__

#define __CDIEM__

class Diem {

int x; //hoanh do

int y; //tung do

public:

Diem();

Diem(int, int);

Diem(const Diem &);

void gan(int, int);

void nhap();

void xuat();

int hoanhdo();

int tungdo();



Diem doixung();

void doi(int, int); //d ờ i tọ a độ mộ t điể m

};

#endif

Các khai báo hàm được in đậm là các khai báo hàm mới thêm vào. Lý domà ta phải thêm vào các hàm là do trong buổi 2 và 3 (bài 2.1và 3.3), ta mớichỉ thực hành cách viết các lớp đơn giản, chưa thực hành phần hàm xây dựngnên trong phần này, trước khi sử dụng lớp này để xây dựng các lớp khác thìta thêm vào các hàm để cho lớp này hoàn chỉnh hơn.

Các hàm thêm vào bao gồm 2 hàm xây dựng, 1 hàm xây dựng sao chép:Diem();

Diem(int, int);

Diem(const Diem &);

và hàm dùng để dời tọa độ một điểm:void doi(int, int);

3. Mở tập tin Cdiem.cpp, thêm vào các định nghĩa hàm vừa thêm trên:#include "cdiem.hpp"


//


//

Diem::Diem() {

x = y = 0;

}

Diem::Diem(int t, int h) {

x = h;

y = t;

}

Diem::Diem(const Diem& d) {

x = d.x;

y = d.y;

}


x = h;

y = t;

}

void Diem::nhap() {


cin >> x;



cout <<"Tung do: ";

cin >> y;

}

void Diem::xuat() {

cout << "(" << x << ", " << y << ")";

}


return y;

}


return y;

}


Diem kq;

kq.gan(-x, -y);

return kq;

}

void Diem::doi(int dx, int dy) {

x += dx;

y += dy;

}

Các hàm in đậm là các hàm vừa được thêm vào.4. Đánh vào đoạn chương trình cho lớp Doanthang sau:

//5.1. Lop Doanthang

#include "CDiem.cpp"


#include <conio.h>

#include <math.h>

//------------------------------

// Thiet ke lop Doanthang

//------------------------------

class Doanthang {

Diem dau, cuoi;

public:

Doanthang();

Doanthang(const Diem&, const Diem&);

Doanthang(int, int, int, int);

void nhap();



void xuat();

float dodai();

float gochoanh();

void tinhtien(int, int);

};

//------------------------------

// Dinh nghia lop Doanthang

//------------------------------

Doanthang::Doanthang() : dau(), cuoi() { }

Doanthang::Doanthang(const Diem& d, const Diem& c)

: dau(d), cuoi(c) { }

Doanthang::Doanthang(int dx, int dy, int cx, int cy)

: dau(dx, dy), cuoi(cx, cy) { }

void Doanthang::nhap() {

cout << "Nhap diem dau:\n";

dau.nhap();

cout << "Nhap diem cuoi:\n";

cuoi.nhap();

}

//

// In toa do ra man hinh duoi dang (x1, y1) - (x2, y2)

// Voi (x1, y1) la toa do diem dau

// (x2, y2) la toa do diem cuoi

//

void Doanthang::xuat() {

dau.xuat();

cout << " - ";

cuoi.xuat();

}

float Doanthang::dodai() {

float kq;

kq = sqrt(pow(dau.hoanhdo() - cuoi.hoanhdo(), 2) +

pow(dau.tungdo() - cuoi.tungdo(), 2));

return kq;

}

void Doanthang::tinhtien(int dx, int dy) {

dau.doi(dx, dy);

cuoi.doi(dx, dy);

}

float Doanthang::gocX() {



float kq;

kq = (180*asin((cuoi.tungdo()-

dau.tungdo())/dodai())/ M_PI);

return kq;

}

Chú ý:

Các hàm xây dựng trong lớp này đều gọi đến hàm xây dựng của lớp Diemđể khởi tạo cho hai đối tượng dau và cuoi.Ví dụ:Doanthang::Doanthang(int dx, int dy, int cx, int cy)

: dau(dx, dy), cuoi(cx, cy) { }

Cú pháp lệnh : dau(dx, dy), cuoi(cx, cy) cho phép ta gọi hàm xâydựng hai đối số của đối tượng dau và cuoi của lớp Doanthang. Do tronghàm này, ta chỉ cần khởi tạo giá trị cho hai đối tượng này nên thân hàmkhông có dòng lệnh nào { }.

Hàm pow(x, y) trong định nghĩa hàm dodai (hàm tính độ dài đọan thẳng)dùng để tính xy. Hàm này được chứa trong thư viện hàm math.hĐộ dài đọan thẳng được tính theo công thức sau:

22 )21()21( yyxxd

với (x1, y1) là tọa độ điểm đầu và (x2, y2) là tọa độ điểm cuối

Hàm tính góc giữa đoạn thẳng và trục hoành:

Gọi góc giữa đoạn thẳng và trục hoành là

Ta có dyy /)(sin 12 (d: độ dài đoạn thẳng)

PIa /))sin(*180(

Nên ta có công thức như sau:

(180*asin((cuoi.tungdo()-dau.tungdo())/dodai())/M_PI)

Với asin(x) là hàm tính asin của một góc, được định nghĩa trong thư việnhàm math.h và M_PI là hằng số pi cũng được định nghĩa trong thư việnhàm math.h.

Đánh vào hàm main() của chương trình://------------------------------


//------------------------------

void main() {

clrscr();

Diem a(2, 5), b(20, 35);



Doanthang ab(a, b);

cout << "Doan thang AB: ";

ab.xuat();

ab.tinhtien(5, 3);

cout << endl;

cout << "Doan thang AB sau khi tinh tien (5, 3): ";

ab.xuat();

Doanthang cd;


cout << "Nhap gia tri doan thang CD:\n";

cd.nhap();

cout << endl;

cout << "Do dai doan thang CD: " << cd.dodai();

cout << endl;

cout << "Goc giua CD va truc hoanh: " << cd.gocX();

}

5. Lưu chương trình với tên là: Dthang.cpp.6. Chạy chương trình:

Do trong chương trình chính, ta có include một số lớp từ những tập tin khác nêntrước khi chạy chương trình, ta cần thực hiện những bước sau:

Nếu trong chương trình chính ta dùng lệnh #include "đường dẫn tuyệt đối đếntập tin Cdiem.cpp" thì ta có thể chạy chương trình mà không cần thực hiệnthêm bước nào cả. Ví dụ: #include "E:\btap_cpp\Cdiem.cpp"

Nếu như các tập tin Cdiem.hpp, Cdiem.cpp, Dthang.cpp đ ặt cùng một thưmục và trong chương trình chính ta dùng lệnh #include "Cdiem.cpp" như trênthì ta thực hiện như sau:1. Chọn menu File\Change Dir2. Hộp thoại Change Directory bật lên cho phép ta chọn thư mục làm việc của

BC.Đánh trực tiếp vào ô Directory Name đường dẫn đến thư mục chứa các tậptin trên, hoặc chọn thư mục chứa các tập tin này trong ô Directory tree.Sau khi chọn xong nhấn nút OK

7. Kết quả thực hiện chương trình:



5.2. Bài 2:

Thiết kế lớp Hinhanh gồm các thành phần dữ liệu sau:

Diem *ds: Tập hợp các điểm ảnh trong một hình ảnh

int soluong: số lượng điểm ảnh hiện tại trong ảnh

int sltoida: số lượng điểm ảnh cho phép tối đa trong một ảnhVà các hàm thành viên sau:

Hàm xây dựng: Hinhanh(int maxdiem);

Hàm hủy

Hàm thêm một điểm ảnh vào ảnh

Hàm bỏ một điểm ở vị trí cuối cùng ra khỏi ảnh

Hàm bỏ tất cả các điểm có giá trị là d (tọa độ) ra khỏi ảnh

Hàm hiện toàn bộ tất cả các điểm trong ảnh

Xuất ra giá trị (tọa độ) của điểm ảnh thứ i trong ảnh.Thiết kế hàm main() thực hiện những yêu cầu sau:

Tạo ra một ảnh với số lượng điểm ảnh do người dùng nhập vào

Cho xuất giá trị các điểm ảnh ra màn hình

Cho phép người dùng chọn vị trí của một điểm ảnh cần xóa và xóa điểmảnh này ra khỏi ảnh. In giá trị các điểm ảnh ra màn hình.

Cho phép người dùng nhập vào giá trị điểm ảnh cần xóa. Xóa điểm ảnhnày và hiển thị giá trị ảnh ra màn hình.

1. Mở chương trình BC.2. Tạo một tập tin mới.3. Đánh vào khai báo lớp Hinhanh như sau:

Nhập vào tọa độcủa đoạn thẳng



//5.2. Lop Hinhanh

#include "CDiem.cpp"

#include "iostream.h"

#include "conio.h"

//-----------------------------

// Khai bao lop Hinhanh

//-----------------------------

class Hinhanh {

Diem *ds;

int soluong;

int sltoida;

public:

Hinhanh(int);

~Hinhanh();

int them(Diem);

int them(int, int);

int them();

int xoa();

int xoa(int);

int xoa(Diem);

int xoa(int, int);

void hien();

void hien(int);

};

Trong khai báo lớp này, chúng ta có sử dụng khái niệm tái định nghĩahàm cho các hàm thêm điểm vào ảnh và xóa điểm ra khỏi ảnh:

int them(Diem); Đối số là điểm cần thêm vào ảnh.int them(int, int); Đối số là giá trị của điểm cần thêm vào

ảnh.int them(); Hàm không đối số, cho phép người sử

dụng nhập trực tiếp giá tr ị của điểm ảnhcần thêm vào từ bàn phím.

int xoa(); Xóa một điểm ở cuối ảnhint xoa(int); Đối số của hàm là vị trí của điểm cần xóa

int xoa(Diem);

Đối số của hàm là một Điểm mà ta cầnxóa tất cả các điểm có giá trị của điểmnày ra khỏi ảnh

int xoa(int, int); Đối số của hàm là giá trị điểm cần xóa

Tất cả các hàm thêm, xóa này đều có trị trả về là int dùng để trả về kếtquả thực hiện việc thêm/xóa. Nếu thực hiện thành công, hàm trả về giá trị 1,ngược lại sẽ trả về giá trị 0.



Hàm hiện cũng được tái định nghĩa: void hien() dùng để hiển thị tất cảcác điểm trong ảnh ra màn hình, void hien(int i)dùng để hiển thị một điểmtại vị trí i trong ảnh ra màn hình.

Do trong lớp Hinhanh này, do có con trỏ Diem *ds sẽ được cấp phátđộng trong quá trình khởi tạo đối tượng nên lớp này cần một hàm hủy để giảiphóng vùng nhớ cho con trỏ này khi con trỏ ( đối tượng) bị hủy.Đánh tiếp vào tập tin trên phần định nghĩa lớp://-----------------------------

// Dinh nghia lop Hinhanh

//-----------------------------

Hinhanh::Hinhanh(int maxdiem) {

sltoida = maxdiem;

ds = new Diem[sltoida];

soluong = 0;

}

Hinhanh::~Hinhanh() {

delete []ds;

}

//

// Ham them mot Diem vao cuoi anh

// Ham tra ve 1 neu thanh cong,0 neu khong them duoc

//

int Hinhanh::them(Diem d) {

if (soluong < sltoida) {

ds[soluong++] = d;

return 1;

}

else

return 0;

}

//

// - Ham them mot Diem (voi gia tri do

// nguoi dung nhap vao) vao cuoi anh.

// - Ham tra ve 1 neu them thanh cong

// 0 neu khong them duoc

//

int Hinhanh::them() {

if (soluong < sltoida) {

cout << "Nhap toa do cho diem moi: \n";

ds[soluong++].nhap();

return 1;

}

else

return 0;

}



//

// - Ham them mot Diem co gia tri (x, y) vao cuoi anh.

// - Ham tra ve 1 neu them thanh cong

// 0 neu khong them duoc

//

int Hinhanh::them(int x, int y) {

Diem d(x, y);

return them(d);

}

//

// Ham xoa 1 diem cuoi trong anh

// Ham tra ve 1 neu xoa thanh cong

// 0 neu khong xoa duoc

//

int Hinhanh::xoa() {

if (soluong >0) {

soluong--;

return 1;

}

else

return 0;

}

//

// Ham xoa diem tai vi tri thu i ra khoi anh



//

int Hinhanh::xoa(int i) {

if (i > 0 && i <= soluong) {

for (int j=i-1;j<soluong; j++)

ds[j] = ds[j+1];

soluong--;

return 1;

}

else

return 0;

}

//

// Ham xoa diem co gia tri d ra khoi anh



//

int Hinhanh::xoa(Diem d) {

int kq=0;



if (soluong > 0) {

for (int i=0; i<soluong; i++) {

if (ds[i].tungdo() == d.tungdo() &&

ds[i].hoanhdo() == d.hoanhdo()) {

xoa(i+1);

kq = 1;

}

}

}

return kq;

}

//

// Ham xoa diem co toa do (x, y) ra khoi anh



//

int Hinhanh::xoa(int x, int y) {

if (soluong > 0) {

for (int i=0; i<soluong; i++) {

if (ds[i].hoanhdo() == x &&

ds[i].tungdo() == y)

xoa(i);

}

return 1;

}

else

return 0;

}

// Ham hien tat ca cac diem trong anh

void Hinhanh::hien() {

for (int i=0; i< soluong; i++) {

ds[i].xuat();

cout << ", ";

}

}

// Ham hien diem thu i trong anh

void Hinhanh::hien(int i) {

if (i > 0 && i <=soluong)

ds[i-1].xuat();

else

cout << "Khong co diem anh tai vi tri " << i;

}



Hàm:int Hinhanh::them(int x, int y) {

Diem d(x, y);

return them(d);

}

dùng để thêm một điểm có giá trị (x, y) ra màn hình. Do ta đã viết hàmthem(Diem d) trong chương trình nên trong hàm này, khi có giá tr ị điểm cầnthêm vào là (x, y), ta chỉ cần tạo một điểm có giá trị (x, y) và gọi đến hàmthem(Diem d) đã viết.

Trong các hàm xóa cũng xử lý tương tự, ta có thể gọi tới hàm đã viếttrước để thực hiện hàm sau, điều này cho phép chương trình ngắn gọn vàđơn giản hơn.

Đánh tiêp vào tập tin trên chương trình chính sau://------------------------------


//------------------------------

void main() {

int n, v;

Hinhanh *h;

clrscr();

cout << "Ban muon tao mot anh co bao nhieu diem anh: ";

cin >> n;

h = new Hinhanh(n);

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

h->them();

cout << "Cac diem trong hinh:\n";

h->hien();

cout << endl;

cout << "Nhap vao vi tri diem anh ban muon xoa: ";

cin >> v;

if (h->xoa(v) == 0)

cout << "Khong xoa duoc";

else {

cout << "Anh sau khi xoa: ";

h->hien();

}

Diem x;


cout << "Nhap vao gia tri diem ban muon xoa: \n";

x.nhap();

if (h->xoa(x) == 0)

cout << "Khong co diem co gia tri ban muon xoa";

else {



cout << "Anh sau khi xoa: ";

h->hien();

}

getch();

}

4. Lưu chương trình lại với tên Hinhanh.cpp.5. Chạy chương trình, nhập vào các số liệu để kiểm tra chương trình sau:

5.3. Bài 3:

Thiết kế lớp Chuyenbay gồm các thành phần dữ liệu sau:

Giờ bay: là đối tượng kiểu Clock (đã thiết kế trong bài 2.2 và bài 3.3)

Mã số chuyến bay

Tên hãng hàng khôngVà các hàm thành viên sau:

Hàm xây dựng, hàm hủy

Hàm thành viên nhập, in.Thiết kế hàm main() thực hiện những yêu cầu sau:

1. Nhập vào sốđiểm của ảnh

2. Nhập giá trịcho các điểm

(phần gạch dưới)

3. Giá trị cácđiểm sẽ hiệnlên màn hình

4. Nhập vàovị trí điểm

cần xóa

5. Hình saukhi xóa điểm

thứ 2

6. Nhập giátrị các điểm

cần xóa

7. Ảnh sau khixóa các điểm

(1, 1)



Tạo một danh sách gồm n chuyến bay.

Nhập, in danh sách các chuyến bay đó ra màn hình

Cho phép người dùng chọn mã số một chuyến bay, hiển thị giờ bay củachuyến bay đó ra màn hình

In danh sách các chuyến bay theo thứ tự tăng dần của giờ bay.

Trong chương trình, ta sẽ sử dụng lại lớp Clock đã được tách ra trong bài 3.3.Tuy nhiên, lớp Clock được tạo trong buổi 2 chưa hoàn chỉnh (thiếu các hàm xâydựng, hàm truy xuất giá trị các dữ liệu thành viên,...) nên ta sẽ hoàn chỉnh lớp nàytrước khi sử dụng nó.

1. Mở chương trình BC.2. Mở tập tin CClock.hpp trong bài 3.3 và thêm một số hàm để được như sau:

//

//Khai bao lop Clock

//

#ifndef __CCLOCK__

#define __CCLOCK__

class Clock {

int gio, phut, giay;

public:

Clock(int=0, int=0, int=0);

Clock(const Clock&);


void nhap();

void xuat();

void lamtron();

int laygio() {return gio;}

int layphut() {return phut;}

int laygiay() {return giay;}

int operator < (Clock);

};

#endif

Những hàm in đậm là những hàm mới thêm vào, bao gồm: hai hàm xâydựng, 3 hàm trả về giá trị của 3 dữ liệu thành viên và một hàm tái định nghĩatoán tử so sánh nhỏ hơn (<).

Trong đó, các hàm laygio(), layphut() và laygiay() sẽ được viết inline.3. Mở tập tin CClock.cpp trong bài 3.3 để thêm vào các định nghĩa hàm cho các khai

báo hàm mới:



#include "CClock.hpp"


Clock::Clock(int h, int m, int s) {

gio = h;

phut = m;

giay = s;

}

Clock::Clock(const Clock &c) {

gio = c.gio;

phut = c.phut;

giay = c.giay;

}

void Clock::gan(int h, int m, int s) {

gio = h;

phut = m;

giay = s;

}

void Clock::nhap() {

cout << "Nhap gio: ";

cin>> gio;

cout << "Nhap phut: ";

cin >> phut;

cout << "Nhap giay: ";

cin >> giay;

}

void Clock::xuat() {

cout << gio << ":" << phut << ":" << giay;

}

void Clock::lamtron() {

//lam tron giay

phut += (giay / 60);

giay %= 60;

//lam tron phut

gio += (phut / 60);

phut %= 60;

//lam tron gio

gio %= 24;

}

int Clock::operator < (Clock c) {



c.lamtron();

lamtron();

long g1, g2;

g1 = gio*10000L + phut*100 + giay;

g2 = c.gio*10000L + c.phut*100 + c.giay;

return (g1 < g2);

}

Ta chú ý đến phần in đậm trong lệnh sau trong hàm tái định nghĩa toán tửso sánh: g1 = gio*10000L + phut*100 + giay;

10000L trong lệnh gán trên chính là hằng kiểu long. Sở dĩ ta phải khaibáo đây là một hằng kiểu long vì nếu ta chỉ để 10000 thì sẽ được hiểu đây làmột hằng kiểu int. Trong trường hợp đó, nếu gio > 3 thì gio*10000 là mộtbiểu thức int*int kết quả là một số int tràn miền giá trị (miền giá trịcủa một số int là -32.768 – 32.767) kết quả sai.

4. Tạo một tập tin mới.5. Đánh vào khai báo lớp Chuyenbay như sau:

//-----------------------------

// 5.2 Khai bao lop Chuyenbay

//-----------------------------

#include "CClock.cpp"


#include <conio.h>

#include <string.h>

#include <stdio.h>

class Chuyenbay {

Clock gb;

char macb[7];

char *hanghk;

public:

Chuyenbay();

Chuyenbay(Clock, char*, char*);

Chuyenbay(const Chuyenbay&);

~Chuyenbay();

Clock laygb() {return gb;}

char* laymacb() {return macb;}

char* layhanghk() {return hanghk;}

void nhap();

void xuat();

int operator < (const Chuyenbay &);



Chuyenbay& operator = (const Chuyenbay &);

};

Các hàm in đậm là những hàm khai báo (định nghĩa) thêm ngoài nhữnghàm đề bài yêu cầu.

Hàm xây dựng sao chép và hàm tái định nghĩa phép gán cần thiết cho lớpcó dữ liệu thành viên là con trỏ, nếu không có hai hàm này thì phép gán đốitượng hoặc truyền đối tượng cho hàm có thể bị sai.

Hàm tái định nghĩa toán tử so sánh nhỏ hơn cho phép so sánh hai chuyếnbay dựa trên giờ bay, phục vụ cho việc sắp xếp các chuyến bay. Một chuyếnbay bay trước sẽ nhỏ hơn chuyến bay bay sau.

3 hàm trả về dữ liệu thành viên của đối tượng cho phép lấy giá trị các dữliệu trong quá trình tìm kiếm.

Đánh tiêp phần định nghĩa lớp Chuyenbay và ch ương trình chính vàotập tin trên://-----------------------------

// Dinh nghia lop Chuyenbay

//-----------------------------

Chuyenbay::Chuyenbay() : gb() {

strcpy(macb, "");

hanghk = (char*)NULL;

}

Chuyenbay::Chuyenbay(Clock c, char* macb, char* hanghk) {

gb = c;

strcpy(this->macb, macb);

this->hanghk = strdup(hanghk);

}

Chuyenbay::Chuyenbay(const Chuyenbay& c) {

gb = c.gb;

strcpy(macb, c.macb);

hanghk = strdup(c.hanghk);

}

Chuyenbay::~Chuyenbay() {

delete []hanghk;

}

void Chuyenbay::nhap() {

char temp[200];

cout << "Nhap ma chuyen bay: ";

cin >> macb;

cout << "Nhap gio bay:\n";

gb.nhap();

cout << "Nhap ten hang hang khong: ";



gets(temp);

hanghk = strdup(temp);

}

void Chuyenbay::xuat() {

cout << "Chuyen bay: " << macb;

cout << ", cua hang: " << hanghk;

cout << " - Gio bay: ";

gb.xuat();

}

int Chuyenbay::operator < (const Chuyenbay &c) {

return (gb < c.gb);

}

Chuyenbay& Chuyenbay::operator = (const Chuyenba y &c) {

if (hanghk == (char*) NULL)

delete []hanghk;

gb = c.gb;

strcpy(macb, c.macb);

hanghk = strdup(c.hanghk);

return *this;

}

//-----------------------------


//-----------------------------

void main() {

Chuyenbay *ds;

int n;

clrscr();

cout << "So luong chuyen bay: ";

cin >> n;

cout << endl;

ds = new Chuyenbay[n];


cout << "Nhap chuyen bay thu " << i+1 << endl;

ds[i].nhap();

cout << endl;

}

//in danh sach cac chuyen bay ra man hinh

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

cout << i+1 << ". ";

ds[i].xuat();



cout << endl;

}

//tim gio bay cua mot chuyen bay

char macb[7];

cout << endl;

cout << "Nhap vao ma chuyen bay can tim: ";

cin >> macb;

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

if (strcmp(ds[i].laymacb(), macb) == 0) {

ds[i].xuat();

break;

}

}

//sap xep danh sach chuyen bay

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


if (ds[j] < ds[i]) {

Chuyenbay t = ds[i];

ds[i] = ds[j];

ds[j] = t;

}

}

}

//in danh sach chuyen bay ra man hinh


cout << "Danh sach chuyen bay sau khi sap xep: \n";

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

ds[i].xuat();

cout << endl;

}

}

6. Lưu chương trình lại với tên là Cbay.cpp7. Chạy chương trình, nhập dữ liệu để kiểm tra kết quả:

1. Nhập số chuyến bay



2. Nhập thông tin vềcác chuyến bay

3. Nhập mãchuyến bay

cần tìm



Chương 6


Thiết kế lớp theo dạng thừa kế. Sử dụng các tính chất của thừa kế.



6.1. Bài 1:Thiết kế lớp Diemmau (điểm có màu) thừa kế từ lớp Diem và có thêm thuộc tínhmàu với các yêu cầu giống như đối với lớp Diem.Ngoài ra, sinh viên cần tái định nghĩa thêm các toán tử nhập, xuất cho lớp này.

1. Mở chương trình BC.2. Mở tập tin Cdiem.hpp trong bài 3.3, kiểm tra lại lớp này như sau:

//2.1 Lop Diem 2D don gian

#ifndef __CDiem__

#define __CDiem__


#include <conio.h>

#include <math.h>

//

// Khai bao lop Diem

//

class Diem {

int x; //hoanh do

int y; //tung do

public:

Diem();

Diem(int, int);

Diem(const Diem &);

void gan(int, int);

void nhap();

void xuat();

int hoanhdo();

int tungdo();

Diem doixung();

void doi(int, int);

};

#endif

3. Mở tập tin CDiem.cpp, kiểm tra lại lớp này như sau:#ifndef __CDiemCPP__

#define __CDiemCPP__

//


//



#include "cdiem.hpp"

Diem::Diem() {

x = y = 0;

}

Diem::Diem(int t, int h) {

x = h;

y = t;

}

Diem::Diem(const Diem& d) {

x = d.x;

y = d.y;

}


x = h;

y = t;

}

void Diem::nhap() {


cin >> x;

cout <<"Tung do: ";

cin >> y;

}

void Diem::xuat() {

cout << "(" << x << ", " << y << ")";

}


return y;

}


return x;

}


Diem kq;

kq.gan(-x, -y);

return kq;

}

void Diem::doi(int dx, int dy) {



x += dx;

y += dy;

}

#endif

4. Mở một tập tin mới cho lớp Điểm màu, đánh vào khai báo lớp như sau:#include "CDiem.cpp"


#include <conio.h>

#include <string.h>

#include <stdio.h>

//

// Khai bao lop Diemmau

//

class Diemmau : public Diem {

char mau[15];

public:

Diemmau(int=0, int=0, char* ="White");

Diemmau(Diem, char * = "White");

Diemmau(const Diemmau&);

void gan(int, int, char*);

void doimau(char*);

void nhap();

void xuat();

char* laymau() { return mau;}

Diemmau doixung();

};

Lớp Diemmau thừa kế từ lớp Diem, ngoài các thuộc tính của một Diem,lớp Diemmau còn có thêm thuộc tính là màu.

Cũng giống như lớp Diem, lớp Diemmau có một số hàm thành viên nh ư:hàm xây dựng, hàm xây dựng sao chép, hàm gán giá trị, nhập, xuất,...

Trong lớp này, không có dữ liệu thành viên là con trỏ nên thực sự làkhông cần xây dựng sao chép, ta thêm vào hàm này chỉ có tính chất thựchành.

5. Đánh tiếp vào tập tin trên các định nghĩa của lớp Diemmau như sau://

// Dinh nghia lop Diemmau

//

Diemmau::Diemmau(int x, int y, char* m) : Diem(x, y) {

strcpy(mau, m);

}



Diemmau::Diemmau(Diem d, char *m) : Diem(d) {

strcpy(mau, m);

}

Diemmau::Diemmau(const Diemmau &d)

:Diem(d.hoanhdo(), d.tungdo()) {

strcpy(mau, d.mau);

}

void Diemmau::gan(int x, int y, char* m) {

Diem::gan(x, y);

strcpy(mau, m);

}

void Diemmau::doimau(char* m) {

strcpy(mau, m);

}

void Diemmau::nhap() {

Diem::nhap();

cout << "Nhap mau: ";

gets(mau);

}

void Diemmau::xuat() {

Diem::xuat();

cout << ", mau: " << mau;

}

Diemmau Diemmau::doixung() {

Diemmau kq(this->Diem::doixung(), mau);

return kq;

}

Trong phần định nghĩa hàm thành viên này, ta cần chú ý đến cách dùngcủa một số lệnh in đậm trên.

Trong lệnh Diemmau kq(this->Diem::doixung(), mau) , lệnhthis->Diem::doixung() trả về một điểm đối xứng với đối tượng đang xét.Như vậy, lệnh này tạo một điểm có tọa độ đối xứng và có màu trùng với vớiđiểm đang xét.

6. Đánh tiếp vào tập tin trên đọan mã của chương trình chính như sau://


//

void main() {



clrscr();

Diemmau a(3, 4);

cout << "Diem a: ";

a.xuat();

cout << endl << "Nhap gia tri cho Diem b:" << endl;

Diemmau b;

b.nhap();

cout << "Diem b: ";

b.xuat();

Diemmau c(0,0, "do");

c = b.doixung();

cout << endl << "Diem c doi xung voi b: ";

c.xuat();

}

Chương trình chính trên chỉ minh họa sơ lược cách sử dụng lớpDiemmau, sinh viên có thể bổ sung thêm một số trường hợp sử dụng khác.

7. Lưu tập tin chứa lớp Diemmau và chương trình chính trên với tên Diemmau.cpp.8. Chạy chương trình, đánh vào một số dữ liệu để kiểm tra như sau:

6.2. Bài 2:Một trường cân quản lý nhân sự bao gồm giáo viên và học sinh của tr ường.Trong đó, tất cả các thành viên (Person) đều có những thông tin chung như:

Họ tên, giới tính, năm sinh, nơi sinh, địa chỉ.Ngoải ra, mỗi giáo viên còn có những thông tin như:

Số năm giảng dạy (thâm niên)

Học vị (đại học, cao học, tiến sĩ)Và mỗi học sinh còn có những thông tin như:

Điểm các môn Toán, Lý, Hóa

Điểm trung bình

Xếp loại: dựa trên điểm trung bình (ĐTB).

o Giỏi: ĐTB trên 8 và không có môn dưới 6.5

Nhập các giátrị vào

Kết quảxuất ra



o Khá: ĐTB trên 6.5 và không có môn dưới 5.

o Trung bình: ĐTB trên 5 và không có môn dưới 3

o Kém: ĐTB dưới 5.Hãy sử dụng tính kế thừa trong lập trình hướng đối tượng để thiết kế các lớp sử dụngtrong việc quản lý nhân sự trong trường trên.Thiết kế hàm main() thực hiện các công việc sau:

Nhập vào danh sách gồm nhọc sinh (n: nhập từ bàn phím)

Nhập vào danh sách gồm m giáo viên (m: nhập từ bàn phím)

In ra các danh sách đó

In danh sách học sinh được xếp lọai khá giỏi

In danh sách giáo viên có thâm niên trên 10 năm và h ọc vị là Cao học trở lên

1. Mở chương trình BC.2. Tạo một tập tin mới và đánh vào đoạn mã cho lớp Person như sau:

// 6.2 Lop Person

#ifndef __CPerson__

#define __CPerson__


#include <string.h>

#include <fstream.h>

#include <conio.h>

#include <stdio.h>

//

// Phan khai bao lop Person

//

class Person {

char *hoten;

char gioitinh[4];

char namsinh[11];

char noisinh[100];

char diachi[100];

public:

Person();

Person(char*, char*, char*, char*, char*);

Person(const Person&);

~Person() {delete []hoten;}

void gan(char*, char*, char*, char*, char*);

void nhap();



void xuat();

friend ostream& operator << (ostream&, const Person&);

friend istream& operator >> (istream&, Person&);

};

//

// Dinh nghia cac ham thanh vien cua lop Person

//

Person::Person() {

hoten = (char*)NULL;

strcpy(gioitinh, "");

strcpy(namsinh, "");

strcpy(noisinh, "");

strcpy(diachi, "");

}

Person::Person(char* ht, char* gt, char* nams, char* noi s, char* dc) {

hoten = strdup(ht);

strcpy(gioitinh, gt);

strcpy(namsinh, nams);

strcpy(noisinh, nois);

strcpy(diachi, dc);

}

Person::Person(const Person &p) {

hoten = strdup(p.hoten);

strcpy(gioitinh, p.gioitinh);

strcpy(noisinh, p.noisinh);

strcpy(namsinh, p.namsinh);

strcpy(diachi, p.diachi);

}

void Person::gan(char* ht, char* gt, char* nams, char* nois, char* dc) {

if (hoten != (char*)NULL);

delete []hoten;

hoten = strdup(ht);

strcpy(gioitinh, gt);

strcpy(namsinh, nams);

strcpy(noisinh, nois);

strcpy(diachi, dc);

}

void Person::nhap() {

cin >> *this;

}

void Person::xuat() {



cout << *this;

}

ostream& operator << (ostream& out, const Person& p) {

out << "Ho ten: " << p.hoten;

out << " - " << p.gioitinh << endl;

out << "Sinh ngay: " << p.namsinh;

out << ", tai: " << p.noisinh;

out << endl << "Dia chi: " << p.diachi;

return out;

}

istream& operator >> (istream& in, Person &p) {

char temp[200];

cout << "Nhap ho ten: ";

gets(temp);

p.hoten = strdup(temp);

cout << "Gioi tinh: ";

in >> p.gioitinh;

cout << "Nam sinh: ";

in >> p.namsinh;

cout << "Noi sinh: ";

gets(p.noisinh);

cout << "Dia chi: ";

gets(p.diachi);

return in;

}

Trong lớp này, có dữ liệu thành viên là con trỏ - hoten – nên cần thiếtphải có hàm xây dựng sao chép và hàm hủy.

Trong hàm xây dựng và xây dựng sao chép, khi cần gán giá trị cho thuộctính hoten, ta chỉ cần dùng lệnh hoten = strdup(ht) nhưng trong hàm void

Person::gan(...), trước khi gán giá trị thì ta thực hiện việc kiểm tra nh ư sau:if (hoten != (char*)NULL);

delete []hoten;

Ta cần phải thực hiện lệnh kiểm tra này vì khi hàm này được gọi thì cóthể là con trỏ hoten của đối tượng đã trỏ đến một vùng nhớ nào đó và đã cógiá trị rồi. Nếu ta không xóa vùng nhớ này thì có thể dẫn đến trường hợp sau

*hoten *hoten

Vùng nhớ này không cònđược trỏ đến nhưng cũngchưa được giải phóng

strdup(ht)



Trước khi thực hiện Sau khi thực hiện

Còn trong hàm xây dựng và hàm xây dựng sap chép, ta không cần thựchiện kiểm tra và giải phóng vùng nhớ cho hoten vì hàm này sẽ được gọi khimột đối tượng mới được tạo ra nên chắc chắn là hoten chưa được cấp phátvùng nhớ.

3. Lưu tập tin trên với tên là CPerson.cpp.4. Mở một tập tin mới, đánh vào đoạn mã cho lớp Hocsinh như sau:

// 6.2 Lop Hocsinh

#ifndef __CHocsinh__

#define __CHocsinh__

#include "CPerson.cpp"


#include <string.h>

#include <conio.h>

class Hocsinh : public Person {

float van, toan, ngoaingu;

float max();

public:

Hocsinh();

Hocsinh(char*, char*, char*, char*, char*, float, float,

float);

void nhap();

void xuat();

friend ostream& operator << (ost ream&, const Hocsinh&);

friend istream& operator >> (istream&, Hocsinh&);

float trungbinh();

char* xeploai();

};

//

// Dinh nghia cac ham thanh vien cua lop Hocsinh

//

Hocsinh::Hocsinh() : Person() {

van = toan = ngoaingu = 0.0;

}



Hocsinh::Hocsinh(char* ht, char* gt, char* nams, char* nois,

char* dc, float v, float t, float nn)

: Person(ht, gt, nams, nois, dc) {

van = v;

toan = t;

ngoaingu = nn;

}

void Hocsinh::nhap() {

cin >> *this;

}

void Hocsinh::xuat() {

cout << *this;

}

float Hocsinh::trungbinh() {

return (van + toan + ngoaingu)/3.0;

}

float Hocsinh::max() {

float m;

m = (van > toan)? van : toan;

m = (m > ngoaingu)? m : ngoaingu;

return m;

}

char* Hocsinh::xeploai() {

float tb = trungbinh();

float m = max();

if (tb >=8.0) {

if (m >= 6.5)

return "Gioi";

else

return "Kha";

}

else if (tb >=6.5) {

if (m >= 5.0)

return "Kha";

else


}

else if (tb >= 5.0) {

if (m >=3.0)




else

return "Yeu";

}

else

return "Yeu";

}

//

// Tai dinh nghia cac luong vao/ra chuan

//

ostream& operator << (ostream& out, const Hocsinh &hs) {

out << (Person)hs;

cout << endl;

out << "Van: " << hs.van << ", Toan: " << hs.toan;

out << ", Ngoai ngu: " << hs.ngoa ingu;

out << " - Trung binh: " << hs.trungbinh();

out << endl << "Xep loai: " << hs.xeploai();

return out;

}

istream& operator >> (istream& in, Hocsinh& hs) {

in >> *(Person*)&hs;

cout << "Diem van: ";

in >> hs.van;

cout << "Diem toan: ";

in >> hs.toan;

cout << "Ngoai ngu: ";

in >> hs.ngoaingu;

return in;

}

#endif

Trong lớp hocsinh, ta có tạo hàm float max() dùng để tìm điểm lớn nhấttrong các môn học. Hàm này được khai báo thuộc tính truy cập là private vìchỉ phục vụ cho hàm char* Hocsinh::xeploai() bên trong lớp.

Trong hàm tái định nghĩa tác tử xuất/nhập, ta có gọi đến hàm tái địnhnghĩa tác tử xuất/nhập của lớp cha để xuất/nhập các thuộc tính thừa kế từ lớpcha.

ostream& operator << (ostream& out, const Hocsinh &hs) {

out << (Person)hs;

...

}

istream& operator >> (istream& in, Hocsinh& hs) {

in >> *(Person*)&hs;



....

}

Ta chú ý đến hai câu lệnhđược in đậm của hai hàm trên: lệnh out <<

(Person)hs; có nghĩa là ép kiểu đối tượng hs thuộc lớp Hocsinh về lớpPerson và xuất đối tượng này ra màn hình. Lệnh in >> *(Person*)&hs; cũngthực hiện ép kiểu đối tượng hs thuộc lớp Hocsinh về kiểu Person và nhập giátrị cho đối tượng này (có nghĩa là nhập giá trị cho những thuộc tính mà đốitượng hs thừa kế từ lớp cha của nó).

Tuy nhiên trong hàm tái tái định nghĩa nhập, ta dùng cách ép kiểu là*(Person*)&hs chứ không phải là (Person)hs như hàm nhập vì hàm nhập cầnthay đổi giá trị đưa vào, do đó ta phải ép kiểu về con trỏ và truyền con trỏ đócho hàm này thì trong hàm mới có thể thay đổi được giá trị của đối tượngđược ép kiểu.

5. Lưu tập tin trên với tên CHsinh.cpp.6. Mở một tập tin mới, đánh vào đoạn mã cho lớp Giaovien như sau:

#ifndef __CGvien__

#define __CGvien__



#include <string.h>

#include <conio.h>

class Giaovien : public Person {

int sonamGD;

char hocvi[20];

public:

Giaovien();

Giaovien(char*, char*, char*, char*, char*, int, char*);

void nhap();

void xuat();

int thamnien() { return sonamGD; }

char* layhocvi() { return hocvi; }

friend ostream& operator << (ostream&, const Giaovien&);

friend istream& operator >> (istream&, Giaovien &);

};

//

// Dinh nghia cac ham thanh vien cua lop Giaovien

//

Giaovien::Giaovien() : Person() {



sonamGD = 0;

strcpy(hocvi, "");

}

Giaovien::Giaovien(char* ht, char* gt, char* nams, char* nois, char* dc,

int sn, char* hv)

: Person(ht, gt, nams, nois, dc) {

sonamGD = sn;

strcpy(hocvi, hv);

}

void Giaovien::xuat() {

cout << *this;

}

void Giaovien::nhap() {

cin >> *this;

}

ostream& operator << (ostream& out, const Giaovien& gv) {

out << (Person)gv;

out << endl << "So nam giang day: " << gv.sonamGD;

out << endl << "Hoc vi: " << gv.hocvi;

return out;

}

istream& operator >>(istream& in, Giaovien& gv) {

in >> *((Person*)&gv);

cout << "So nam giang day: ";

in >> gv.sonamGD;

cout << "Hoc vi: ";

gets(gv.hocvi);

return in;

}

Các giải thuật và cách viết lớp Giaovien giống với lớp HocsinhTrong lớp này, ta có hai hàm inline là thamnien() và layhocvi(). Đây là

hai hàm trả về giá trị của thuộc tính số năm công tác và học vị, chỉ gồm mộtlệnh return nên được viết inline

7. Lưu tập tin với tên CGvien.cpp.8. Mở một tập tin mới, đánh vào đoạn mã cho chương trình chính như sau:

//Chuong trinh chinh su dung lop Person –Giaovien-Hocsinh




#include "CGvien.cpp"

#include "CHsinh.cpp"


#include <conio.h>

#include <stdio.h>

void main() {

Hocsinh *dshs;

Giaovien *dsgv;

int n, m;

//Cap phat vung nho cho dshs;

cout << "Danh sach gom bao nhieu hoc sinh: ";

cin >> n;

dshs = new Hocsinh[n];

//Nhap sanh sach n hoc sinh

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

cout << "Nhap hoc sinh thu " << i+1 << ": \n";

if (cin.peek() == '\n') //xoa ky tu \n trong cin

cin.ignore(1, '\n'); //neu co

cin >> dshs[i];

}

//Cap phat vung nho cho dsgv

cout << "Danh sach gom bao nhieu giao vien: ";

cin >> m;

dsgv = new Giaovien[m];

if (cin.peek() == '\n') //xoa ky tu \n trong cin

cin.ignore(1, '\n'); //neu co

//Nhap danh sach gom m Giaovien

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

cout << "Nhap giao vien thu " << i+1 << ":\n";

cin >> dsgv[i];

}

//in cac sanh sach vua nhap

cout << "Danh sach hoc sinh:\n";

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

cout << dshs[i] << endl;

cout << "Nhan enter de xem tiep...";

getch();

clrscr();



cout << "Danh sach giao vien:\n";

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

cout << dsgv[i] << endl;


getch();

clrscr();

//In danh sach Hocsinh duoc xep loai kha gioi

cout << "Danh sach hoc sinh kha, gioi: \n";

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

if ( (strcmp(dshs[i].xeploai(), "Gioi") == 0) ||

(strcmp(dshs[i].xeploai(), "Kha") == 0))

cout << dshs[i] << endl;

}


getch();

clrscr();

//In ra danh sach Giao vien co tham nien > 10 nam

//va hoc vi la cao hoc tro len

cout << "Danh sach Giao vien co tham nien > 10 nam “;

cout << “va hoc vi la cao hoc tro len: \n";

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

char* t = strupr(strdup(dsgv[i].layhocvi()));

if ( (dsgv[i].thamnien() > 10) &&

(strcmp(t, "DAI HOC") != 0))

cout << dsgv[i] << endl;

}

delete []dshs;

delete []dsgv;

}

9. Lưu tập tin trên với tên ps_hs_gv.cpp.10. Thực thi chương trình chính trên, nhập vào một số dữ liệu để kiểm tra:

Nhập các thông tinđược gạch dưới



Kết quả xuất ranhư sau

Thực hành Lập trình HĐT & C++ Bài tập bổ sung


Bài tập bổ sung

1. Thiết kế lớp Dathuc (đa thức) để biểu diễn các đa thức dạng:f(x) = an*xn + an-1* xn-1 + … + a2*x2 + a1*x1

Thành phần dữ liệu gồm 1 tập hợp của: hệ số và số mũ.Các phép toán gồm:

Nhập một đa thức. In đa thức. Sắp xếp đa thức theo thứ tự giảm dần. Tính giá trị của đa thức nếu biết giá trị biến x. Cộng, trừ, nhân, chia 2 đa thức

Viết hàm main(0 để thử nghiệm tính đúng đắn của lớp Đa thức trên

2. Một ngân hàng cần thiết kế chương trình để quản lý các dạng tiền gửi tiết kiệmbằng ngôn ngữ C++. Trong đó, một lần gửi tiết kiệm cần những thông tin sau:Họ tên người gửi, địa chỉ người gửi, số CMND, ngày gửi, số tiền gửi, loại tiềngửi.Loại tiền gửi gồm các dạng sau:

STT Loại tiền gửi Lãi suất (%/tháng)1 Không kỳ hạn 0.22 Kỳ hạn 3 tháng 0.53 Kỳ hạn 6 tháng 0.64 Kỳ hạn 9 tháng 0.655 Kỳ hạn 12 tháng 0.726 Kỳ hạn 24 tháng 0.75

Khi khách hàng rút tiền thì nhân viên ngân hàng sẽ tính lãi cho khách hàng:a. Nếu khách hàng rút tiền trước kỳ hạn thì sẽ tính lãi suất bằng lãi suất kỳ hạn

phía trước.Ví dụ: Gửi kỳ hạn 6 tháng bắt đầu từ 05/01/2000 với số tiền là 1.000.000đ,nhưng đến ngày 11/05/2000 đến rút tiền (4 tháng 6 ngày) thì lãi suất sẽ tính: 4 tháng lãi suất 0.5% (kỳ hạn 3 tháng) = 4* 0.5/100 *1000000 = 20.000đ 6 ngày lãi suất 0.2% (không kỳ hạn) = 6/30 * 0.2/100 *1000000 = 400đ

b. Nếu khách hàng rút sau thời hạn thì sẽ được cộng dồn lãi vào vốn và gửi lại.Ví dụ: Gửi kỳ hạn 3 tháng bắt đầu từ 01/05/2000, số tiền là 1.000.000 đnhưng đến ngày 05/08/2000 mới đến rút tiền (7 tháng) thì sẽ tính như sau: Đến 05/04/2000 (3 tháng), tiền vốn là:

3* 0.5/100 * 1.000.000 + 1.000.000 = 1.015.000đ Đến 05/07/2000 (từ tháng thứ 3 đến tháng thứ 6), tiền vốn là:

3* 0.5/100 + 1.015.000 + 1.015.000 = 1.03 0.225đ Đến 05/08/2000 (tháng thứ 7), tiền lãi là:

1* 0.2/1000* 1.030.225 = 2060.45đ (ti ền vốn là 1.030.225đ)c. Tiền gửi không kỳ hạn phải gửi qua 10 ngày mới tính tiền lãi (kể nh ư 30

ngày/tháng)Anh/Chị hãy thiết kế lớp TienguiTK trên (sử dụng lớp Date có sẵn). Trong đó,phải có các hàm dùng để tính lãi, tính số tiền phải trả khi đến hạn, tính ngày đếnhạn là ngày mấy, hàm cập nhật khi khách gửi tiền tiếp tục,…



3. Một cửa hàng sách cần tin học hóa việc mua bán sách trong cửa hàng.Thông tin cần được quản lý bao gồm:Thông tin về các tựa sách (tác phẩm):

Mã số sách, tên sách, tên tác giả, tên nhà xuất bản, n ăm xuất bản, số trang.Thông tin về việc nhập sách về:

Mã số sách, số lượng, đơn giá hiện tại.Thông tin về việc bán sách:

Mã số sách, số lượng, đơn giá bán.Khi nhập một tựa sách: Nếu như tựa sách đó chưa có trong danh sách (mới được nhập lần đầu) thì

phải thêm thông tin của tựa sách đó vào danh sách các tựa sách, đồng thờiđưa thêm các thông tin về việc nhập sách.

Nếu như đã có thì tăng số lượng tồn và điều chỉnh đơn giá nhập hiện tại.Thông tin về các quyển sách sẽ được lưu trữ bằng một mảng động khi xử lý đểtăng tính hiệu quả và mềm dẻo của chương trình.

Các thông tin về tựa sách, nhập, xuất sẽ được lưu trữ vào tập tin.Yêu cầu: anh/chị hãy thiết kế chương trình theo yêu cầu trên.

4. Ta có một số các đối tượng hình học sau: Điểm Đoạn thẳng Đường tròn Hình chữ nhậtMỗi dạng đối tượng sẽ gồm có các thuộc tính riêng và các hàm t ương ứng.Yêu cầu: Hãy tạo ra danh sách gồm n phần tử là các đối tượng hình học bất kỳ

(chương trình sẽ tự động tạo ra một cách tự nhiên) In ra màn hình tên chủng loại của các đối tượng đó.

Ví dụ: Nếu đối tượng là điểm thì in ra: “Day la mot diem”Nếu đối tượng là hình tròn thì in ra: “Day la mot hinh tron”

Bổ sung thêm 1 dạng đối tượng khác là hình tam giác. Thực hiện t ương tựnhư trên.

(Hướng dẫn: dùng hàm ảo)

0..n1..n 0..n Mã số sáchTên sáchTên tác giảTên nhà xuất bảnNăm xuất bảnSố trang

Tựa sách

Mã số sáchSố lượngĐơn giá hiện tại

Nhập

Mã số sáchSố lượngĐơn giá bán

Xuất1..n



5. Anh/chị có nuôi một số các con vật như sau: Chó Mèo Vịt GàMỗi con vật sẽ có một tên riêng và một tiếng keo riêng biệt.Yêu cầu được đặt ra như sau: Anh/Chị nuôi n con vật tổng cộng Hãy cho từng con vật kêu theo dạng tiếng kêu riêng của nó(Hướng dẫn: dùng hàm ảo)

6. Anh/Chị hãy thiết kế lớp FileDBF dùng để truy xuất trực tiếp tập tin c ơ sở dữliệu của Foxpro for DOS (*.DFB) với các tính n ăng như: Đếm xem có bao nhiêu mẩu tin In ra cấu trúc file có bao nhiêu trường và kiểu dữ liệu của từng trường, độ lớn. In ra dữ liệu của mẫu tin thứ i nào đó In ra dữ liệu của một trường nào đó In ra toàn bộ dữ liệu của một file Đánh dấu xóa một mẫu tin Thêm một mẫu tin trống vào cuối Chỉnh sửa dữ liệu một mẫu tin …Biết rằng cấu trúc của một tập tin DBF nh ư sau:Header:

Số thứ tự (byte) Số bytes Ý nghĩa0 1 Có giá trị là 0x031 3 Ngày cập nhật sau cùng (yy/mm/dd)4 4 Số mẩu tin hiện có8 2 Chiều dài cấu trúc đầu tập tin

10 2 Chiều dài một mẩu tin12 20 Chưa sử dụng (version 1.0)

32 * 1 32 Header của vùng dữ liệu (field) thứ 1… 32

32 * n 32 Header của vùng dữ liệu (field) thứ n32 * (n+1) + 1 1 0x0D (ngăn cách với phần dữ liệu)

Nếu file DBF có n trường dữ liệu thì chiều dài cấu trúc đầu tập tin = 32 + 32 * n+1

Cấu trúc header một vùng dữ liệu:Số thứ tự (byte) Số bytes Ý nghĩa

0 11 Tên vùng dữ liệu, theo mã ASCII11 1 Kiểu dữ liệu của vùng12 4 Địa chỉ bắt đầu của vùng dữ liệu16 1 Chiều dài dữ liệu17 1 Số lẻ thập phân (nếu có)18 14 Chưa sử dụng (version 1.0)



Kiểu dữ liệu có thể là: C (character), N (numeric), L (logic), D (date), M (memo) .Tất cả kiểu dữ liệu trong phần khai báo đều lưu dưới dạng mã nhị phân.

Cấu trúc một mẫu tin: Mỗi mẫu tin bắt đầu bằng 1 byte dùng để đánh dấu bỏ mẫu tin hay không. Nếu

bằng 0x20 thì không bị đánh dấu bỏ, nếu bằng 0x2A thì đã bị đánh dấu bỏ. Trong mỗi mẩu tin, các vùng dữ liệu được ghi liền nhau với chiều dài đã được

khai báo trong phần header của mỗi vùng dữ liệu. Trong tập tin, các mẫu tin được ghi liên tiếp nhau, không có ranh giới hay ký

hiệu gì ngăn cách Các lọai dữ liệu được lưu trong mẫu tin như sau::

o Loại C: ký tự được lưu bằng mã ASCIIo Loại N: số được lưu vào bằng các ký tự số, giống như lưu một chuỗi số

Ví dụ: số -1.35 sẽ được lưu bằng chuỗi: 45, 49, 46, 51, 53o Loại D: được lưu vào bằng các ký tự số theo dạng YYYYMMDD

Ví dụ: 16/12/1999 được lưu: 49, 57, 57,57, 49, 51, 49, 54o Loại L: lưu bằng một ký tự dạng [Y|y] / [N|n] hoặc [T|t] / [F|f]o Loại M ta không xét.

*

* *

Thực hành Lập trình HĐT & C++ Phụ lục


Phụ lục 1

Control Statement Summary

Statement General Form Example

break break; for (n = 0; n <= 100; n++) {scanf(“%f”, &x);if (x < 0) {

printf(“ERROR – NEG Value for X”);break;

}......

}

continue continue; for (n = 0; n <= 100; n++) {scanf(“%f”, &x);if (x < 0) {

printf(“ERROR – NEG Value for X”);continue;

}......

}

do – while dostatement;

while (expression);

do {printf(“%d \n”, digit++);

} while (digit <= 9);

for for (exp1; exp2; exp3)statement;

for (digit = 0; digit <= 10; digit++)printf(“%d\n”, digit);

if if (expression)statement;

if (x < 0)printf(“%f”, x);

if – else if (expression)statement 1

elsestatament 2;

if (status == ‘s’)tax = 0.20 * pay;

elsetax = 0.14 * pay;

return return statement; return (n1 + n2);

switch switch expression {case expression 1:

statement 1;

choise = getchar();switch (choise) {

case ‘R’:



statement 2;......break;

case expression 2:statement 1;statement 2;......break;

.....default:

statement 1;statement 2;.......

}

printf(“RED”);break;

case ‘W’:printf(“WHILE”);break;

case ‘B’:printf(“BLUE”);break;

default:printf(“Error”);

while while (expression)statement;

while (digit <= 9)printf(“%d\n”, digit++);



Phụ lục 2

Operator Summary

Statement Operator Association

Function, array, structure number,pointer to structure member

() [] . -> L – R

Unary operators - ++ -- ! ~

* & sizeof (type)

R – L

Arithmetic multiply, divide andremainder

* / % L – R

Arithmetic add and subtract + - L – R

Bitwise shift operators << >> L – R

Relational operators < <= > >= L – R

Equality operators == != L – R

Bitwise and && L – R

Bitwise exclusive or ^ L – R

Bitwise or | L – R

Logical and && L – R

Logical or || L – R

Conditional operators ? : R – L

Assignment operators = += -= *= /= %=

&= ^= |= <<= >>=

R – L

Comma operators , L – R

Ghi chú: Các nhóm toán tử trên được liệt kê theo thứ tự ưu tiên. Các toán tử nhóm nhóm trên cóđộ ưu tiên cao các toán tử trong nhóm dưới. Các toán tử trong cùng nhóm có cùng thứtự ưu tiên sẽ được kết hợp theo thứ tự được cho trong cột thứ 3 của bảng trên.



Phụ lục 3

Data type Summary

Type Length Conversion Char Range

unsigned char 8 bits c 0 to 255

char 8 bits c -128 to 127

unsigned int 16 bits d | u 0 to 65,535

short int 16 bits d | hd -32,768 to 32,767

int 16 bits d -32,768 to 32,767

unsigned long 32 bits lu 0 to 4,294,967,295

long 32 bits ld -2,147,483,648 to 2,147,483,647

float (7) 32 bits f 3.4 * (10**-38) to 3.4 * (10**+38)

double (17) 64 bits lf 1.7 * (10**-308) to 1.7 * (10**+308)

long double (17) 80 bits Lf 3.4 * (10**-4932) to 1.1 * (10**+4932)



Phụ lục 4

The ASCII Character Set

Thực hành Lập trình HĐT & C++ Tài liệu tham khảo


TÀI LIỆU THAM KHẢO

1. Bruce Eckel. Thinking in C++. Prentice Hall. Jun 20002. Phạm Thị Xuân Lộc. Giáo trình Lập trình hướng đối tượng và C++. Đại học Cần Thơ.

1999.

eBook Huong Dan Thuc Hanh C++

Documents

Transcript of eBook Huong Dan Thuc Hanh C++