Ktlt lab full

ĐẠI HỌC BÁCH KHOA TP. HCM
KHOA CÔNG NGHỆ THÔNG TIN
THỰC HÀNH KỸ THUẬT LẬP TRÌNH
BÀI THỰC TẬP SỐ 1
Cơ bản về C++ ........................................................................................................................... 2
Cấu trúc lựa chọn ....................................................................................................................... 5
Cấu trúc lặp ................................................................................................................................ 7
Mảng và Cấu trúc ..................................................................................................................... 12
Con trỏ và Hàm trong C++....................................................................................................... 17
Giới thiệu về Lớp Đối tượng.................................................................................................... 22
Xử lý Đối tượng ....................................................................................................................... 26
Xử lý Đối tượng (tiếp theo)...................................................................................................... 31
Sự Thừa kế và Bao gộp trong C++ .......................................................................................... 36
Đa hình và Khuôn hình ............................................................................................................ 43

Cơ bản về C++
Bài thực tập này gồm các nội dung chính sau:
¾ Chương trình “hello world”
¾ Kiểu dữ liệu
¾ Chuyển đổi kiểu
¾ Toán tử
¾ Câu lệnh khai báo, gán
Câu 1: Hãy chạy thử chương trình sau:
#include <iostream.h>
int main()
{
const float PI=3.14159;
float radius = 5;
float area;
area = radius * radius * PI; // Circle area calculation
cout << “The area is “ << area << “ with a radius of 5.n”;
radius = 20; // Compute area with new radius.
area = radius * radius * PI;
cout << “The area is “ << area << “ with a radius of 20.n”;
return 0;
}
a. Chạy chương trình trên
b. Sử dụng định nghĩa define để định nghĩa hằng PI
c. Khai báo hằng PI trong file “mydef.h”, sau đó dùng chỉ thị include để thêm vào
đoạn chương trình trên
Câu 2: Tìm lỗi của đoạn chương trình sau:
main()
{
const int age=35;
cout << age << “n”;
age = 52;
cout << age << “n”;
return 0;
}
Câu 3: Hãy cho biết kết quả của đoạn chương trình sau:

#define AMT1 a+a+a
#define AMT2 AMT1 - AMT1
main()
{
int a=1;
cout << “Amount is “ << AMT2 << “n”;
return 0;
}
Câu 4: Hãy cho biết kết quả cảu những biểu thức sau:
a. 1 + 2 * 4 / 2
b. (1 + 2) * 4 / 2
c. 1 + 2 * (4 / 2)
d. 9 % 2 + 1
e. (1 + (10 - (2 + 2)))
Câu 5: Chạy đoạn chương trình sau và giải thích kết quả:
a. void main()
{
short i = -3;
unsigned short u;
cout<< sizeof(i)<< &i;
cout<<sizeof(u)<<&u;
cout << (u = i) << "n";
}
b. void main()
{
byte i = 125*4/10;
cout << i << "n";
}
Câu 6: Viết chương trình nhập vào 2 thời điểm và cho biết 2 thời điểm cách nhau bao nhiêu
giờ, phút giây.
Câu 7: Chạy chương trình sau và giải thích:
a.
int main()
{
int f, g;

g = 5;
f = 8;
if ((g = 25) || (f = 35))
cout << “g is “ << g << “ and f got changed to “ << f;
return 0;
}
b.
void main()
{
if (!0)
{ cout << “C++ By Example n”; }
int a = 0;
if ( a !=0 && 2/a >0 )
cout<< “hello”;
}
Bài tập thêm:
Câu 1: Hãy cho biết trong khai báo sau có bao nhiêu biến và kiểu dữ liệu của chúng:
int i, j, k;
char c, d, e;
float x=65.43;
Câu 2: Trong các tên biến sau, tên biến nào hợp lệ:
my_name 89_sales sales_89 a-salary
Câu 3: Cho biết kiểu dữ liệu của hằng sau:
0 -12.0 “2.0” “X” ‘X’ 65.4 -708 ‘0’
Câu 4: Viết chương trình nhập vào điểm của 3 môn toán, lý, hóa. Sau đó xuất ra điểm trung
bình theo định dạng sau:
Toan 8.5
Ly 9
Hoa 10
-----------------------------
DTB 9.17

Cấu trúc lựa chọn
¾ if
¾ if … else
¾ switch
Câu 1: Chạy đoạn chương trình sau:
// BEEP : ‘x07’
#define BEEP cout << “a n”
main()
{
int num;
cout << “Please enter a number “;
cin >> num;
if (num == 1)
{ BEEP; }
else if (num == 2)
{ BEEP; BEEP; }
else if (num == 3)
{ BEEP; BEEP; BEEP; }
else if (num == 4)
{ BEEP; BEEP; BEEP; BEEP; }
else if (num == 5)
{ BEEP; BEEP; BEEP; BEEP; BEEP; }
return 0;
}
Câu 2: Hãy chạy đoạn chương trình sau: (cout << ‘x07’; // BEEP)
#define BEEP cout << “a n”
main()
{
int num;
cout << “Please enter a number “;
cin >> num;
switch (num)
{
case (1): { BEEP;
break; }
case (2): { BEEP; BEEP;
break; }

case (3): { BEEP; BEEP; BEEP;
break; }
case (4): { BEEP; BEEP; BEEP; BEEP;
break; }
case (5): { BEEP; BEEP; BEEP; BEEP; BEEP;
break; }
}
return 0;
}
Câu 3: Hãy xóa các lệnh ‘break’. Sau đó, chạy lại đoạn chương trình trên và giải thích.
Câu 4: Dùng cấu trúc switch để viết lại đoạn chương trình sau:
if (num == 1)
{cout << “Alpha”; }
else if (num == 2)
{ cout << “Beta”; }
else if (num == 3)
{ cout << “Gamma”; }
else
{ cout << “Other”; }
Câu 5: Viết chương trình nhập vào số nguyên n gồm ba chữ số. Xuất ra màn hình theo thứ tự
tăng dần của các chữ số.
Ví dụ: n=291. Xuất ra 129.
Câu 6: Viết chương trình nhập vào ngày, tháng, năm hợp lệ. Cho biết năm này có phải là năm
nhuận hay không? In kết quả ra màn hình.
Câu 7: Viết chương trình tính tiền cước TAXI. Biết rằng:
a. KM đầu tiên là 5000đ.
b. 200m tiếp theo là 1000đ.
c. Nếu lớn hơn 30km thì mỗi km thêm sẽ là 3000
Hãy nhập số km sau đó in ra số tiền phải trả.
Câu 8: Nhập vào ngày, tháng, năm. Kiểm tra xem ngày, tháng, năm đó có hợp lệ hay không,
nếu hợp lệ cho biết ngày trước đó là bao nhiêu.
Ví dụ: Nhập 01/01/2003
Ngày trước đó 31/12/2002

Cấu trúc lặp
¾ for
¾ while
¾ do…while
Câu 1: Hãy cho biết kết quả của đoạn chương trình sau. Giải thích
int a = 1;
while (a < 4)
{
cout << “This is the outer loopn”;
a++;
while (a <= 25)
{
break;
cout << “This prints 25 timesn”;
}
}
Câu 2: Hãy chạy đoạn chương trình sau:
#include <iomanip.h>
void main()
{
float total_grade=0.0;
float grade_avg = 0.0;
float grade;
int grade_ctr = 0;
do
{
cout << “What is your grade? (-1 to end) “;
cin >> grade;
if (grade >= 0.0)
{
total_grade += grade; // Add to total.
grade_ctr ++;
} // Add to count.
} while (grade >= 0.0); // Quit when -1 entered.
grade_avg = (total_grade / grade_ctr);
cout << “nYou made a total of “ << setprecision(1) <<
total_grade << “ points.n”;

cout << “Your average was “ << grade_avg << “n”;
if (total_grade >= 450.0)
cout << “** You made an A!!”;
return 0;
}
void main()
{
int outer, num, fact, total;
cout << “What factorial do you want to see? “;
cin >> num;
for (outer=1; outer <= num; outer++)
{
total = 1;
for (fact=1; fact<= outer; fact++)
{ total *= fact; }
}
cout << “The factorial for “ << num << “ is “ << total;
return 0;
}
Câu 4: Hãy cho biết kết quả của đoạn chương trình sau:
a.
for (ctr=10; ctr>=1; ctr-=3)
{ cout << ctr << “n”; }
b.
n =10
i=1
for (i = 0 ; i < n ; i++)
cout<< ++i<<endl;
c.
for (i=1; i<=10; i++);
for (j=1; j<=5; j++)
{
if ( i == j )
continue;
else ( i>j)
break;
else
cout << i << j;

cout<< endl;
}
d.
i=1;
start=1;
end=5;
step=1;
for (; start>=end;)
{
cout << i << “n”;
start+=step;
end--;
}
Câu 5: Viết một chương trình C++ tính tổng và giá trị trung bình của n số thực chính xác đơn
được nhập vào từ người sử dụng. Trị của n cũng là một giá trị do người sử dụng nhập
vào.
Câu 6: Viết một chương trình C++ sinh ra một bảng đổi nhiệt độ từ Celcius sang Fahrenheit.
Cho nhiệt độ Celcius tăng từ 5 độ đến 50 độ với mỗi bước tăng 5 độ. Bảng kết quả in
ra có dạng:
Độ Celcius Độ Fahrenheit
-------------- -----------------
5 xxxx
10 xxxx
15 xxxx
20 xxxx
Fahrenheit = (9.0 / 5.0) * Celcius + 32.0;
Câu 7: Giá trị của số Euler e, được tính xấp xỉ bằng công thức sau:
e = 1 + 1/1! + ½! + 1/3! + ¼! + 1/5! + …
Dựa vào công thức này, viết một chương trình C++ để tính xấp xỉ giá trị của e. Hãy
dùng vòng lặp while mà dừng lại khi độ sai biệt giữa hai lần xấp xỉ nhỏ hơn 1.0E-6.
Câu 8: Viết một chương trình C++ tính tóan và trình bày số tiền tích lũy được nếu gửi tiết
kiệm 1000$ vào ngân hàng sau từng năm trong vòng 10 năm. Chương trình cũng cần
trình bày số tiền tích lũy được với lãi suất thay đổi từ 6% đến 12% với bước tăng 1%.
Như vậy, ta nên dùng hai vòng lặp lồng nhau: vòng lặp ngòai thay đổi theo lãi suất và

vòng lặp trong thay đổi theo số năm.
Công thức để tính số tiền tích lũy L = P(1+ i)n với P là số tiền gửi ban đầu, i là lãi suất,
n là số chu kì tính lãi.
Câu 9: Viết chương trình nhập số nguyên dương n. Liệt kê n số nguyên tố đầu tiên.
Bài tập thêm:
Câu 1: Chạy đoạn chương trình sau:
main()
{
goto Here;
First:
cout << “A n”;
goto Final;
There:
cout << “B n”;
goto First;
Here:
cout << “C n”;
goto There;
Final:
return 0;
}
Câu 2: Hãy dùng vòng lặp do..while để viết đoạn chương trình sau:
Ask:
cout << “What is your first name? “;
cin >> name;
if ((name[0] < ‘A’) || (name[0] > ‘Z’))
{ goto Ask; } // Keep asking until the user
// enters a valid letter.
Câu 3: Viết chương trình nhập vào một số nguyên n gồm tối đa 10 chữ số (4 bytes). In ra màn
hình giá trị nhị phân của số trên.
Câu 4: Viết một chương trình C++ đọc vào N số thực chính xác đơn và cho biết có bao nhiêu
số dương và có bao nhiêu số âm trong lọat số đó. Trị của N cũng là một giá trị do
người sử dụng nhập vào.
Câu 5: Viết chương trình nhập vào hai số nguyên dương a và b. Tìm ước số chung lớn nhất và
bội số chung nhỏ nhất của a và b.

Câu 6: Viết chương trình in ra màn hình tam giác cân rỗng có độ cao h (h nhập từ bàn phím).
Ví dụ: Nhập h = 4
*
* *
* *
* * * * * * *

Mảng và Cấu trúc
¾ Mảng 1 chiều
¾ Mảng 2 chiều
¾ Các thao tác trên mảng
¾ Các thao tác trên chuỗi
¾ Dữ liệu có cấu trúc
const int NUM = 8;
void main()
{
int nums[NUM];
int total = 0; // Holds total of user’s eight numbers.
int ctr;
for (ctr=0; ctr<NUM; ctr++)
{
cout << “Please enter the next number...”;
cin >> nums[ctr];
total += nums[ctr];
}
cout << “The total of the numbers is “ << total << “n”;
return;
}
Câu 2: Khi khai bao mảng weight như sau thì phần tử weight[5] sẽ có giá trị là bao nhiêu:
int weights[10] = {5, 2, 4};
câu 3: Cho định nghĩa mảng sau:
char teams[] = {‘E’,’a’,’g’,’l’,’e’,’s’,’0', ’R’, ‘a’,’m’,’s’,’0'};
Hãy cho biết trong những câu lệnh sau, câu lệnh nào hợp lệ:
a. cout << teams;
b. cout << teams+7;
c. cout << (teams+3);
d. cout << teams[0];
e. cout << (teams+0)[0];
f. cout << (teams+5);
Câu 4: Cho khái báo mảng sau:

int grades[3][5] = {80,90,96,73,65,67,90,68,92,84,70, 55,95,78,100};
Hãy cho biết giá trị của các phần tử sau:
a. grades[2][3]
b. grades[2][4]
c. grades[0][1]
Câu 5: Hãy viết một chương trình C++ đọc vào một mảng gồm n số thực chính xác đơn và
tìm số nhỏ nhất trong array đó n là một trị số nguyên do người sử dụng nhập vào.
Câu 6: Hãy viết một chương trình C++ đọc vào một mảng gồm n số thực chính xác đơn và
sắp xếp array đó theo thứ tự giảm dần
Câu 7: Viết hàm tìm vị trí phần tử có giá trị x xuất hiện cuối cùng trong mảng.
Câu 8: Viết hàm chèn phần tử có giá trị x vào vị trí đầu tiên của mảng.
Câu 9: Hãy viết một chương trình C++ đọc vào một ma trận n × n và chuyển vị ma trận này
và in ma trận chuyển vị ra. Chuyển vị một ma trận vuông nghĩa là:
aij ↔ aji for all i, j
Thí dụ cho ma trận
1 3 5
2 7 9
4 1 6
sau khi chuyển vi, nó trở thành
1 2 4
3 7 1
5 9 6
Câu 10:
a. Hãy khai báo một kiểu dữ liệu mang tên Car là kiểu cấu trúc mà mỗi chiếc xe (car)
có thể gồm những thông tin như trong mỗi hàng của bảng sau:
Car_Number Kms_driven Litre_used
25
1450
62
36
3240
136

44
52
68
1792
2360
2114
76
105
67
b. Dùng kiểu dữ liệu được định nghĩa ở a., viết một chương trình C++ mà đọc vào dữ
liệu được cho ở bảng trên vào thành một array gồm 5 cấu trúc. Một khi dữ liệu đã
được đọc vào, chương trình sẽ tính tóan và trình bày ra báo cáo gồm các cột: mã số
xe, số km đã đi trên mỗi lít xăng.
Bài tập thêm:
Câu 1: Viết chương trình tính tổng các phần tử cực đại trong mảng các số nguyên (phần tử
cực đại là phần tử lớn hơn các phần tử xung quanh nó).
Ví dụ: 5 2 6 3 5 1 8 6
Câu 2: Viết chương trình xoá những phần tử sao cho mảng kết quả có thứ tự tăng dần và số
lần xoá là ít nhất.
Câu 3: Hãy viết một chương trình C++ đọc vào một array gồm N số thực chính xác đơn và
tính giá trị trung bình của các phần tử trong array đó. N là một trị số nguyên do người
sử dụng nhập vào.
Câu 4: Viết chương trình tách 1 mảng các số nguyên thành 2 mảng a và b, sao cho mảng a
chứa toàn số lẻ và mảng b chứa toàn số chẵn.
Ví dụ: Mảng ban đầu: 1 3 8 2 7 5 9 0 10
Mảng a: 1 3 7 5 9
Mảng b: 8 2 10
Câu 5: Nhập vào giá trị X. Viết hàm xoá tất cả các phần tử có giá trị nhỏ hơn X.
Câu 6: Viết hàm sắp xếp ma trận theo đường ziczắc ngang

Câu 7: Viết chương trình nhập vào một chuỗi ký tự, đếm số ký tự có trong chuỗi.
Câu 8: Đổi tất cả các ký tự có trong chuỗi thành chữ thường (không dùng hàm strlwr).
Câu 9: Nhập một chuỗi bất kì, yêu cầu nhập 1 ký tự muốn xóa. Thực hiện xóa tất cả những ký
tự đó trong chuỗi.
Câu 10: Viết chương trình nhập vào một chuỗi đếm xem chuỗi có bao nhiêu từ. Các từ cách
nhau bằng khoảng trắng, dấu chấm câu: dấu chấm (.), dấu phẩy (,), dấu chấm phẩy (;),
dấu hỏi (?) và dấu chấm than (!).
Câu 10: Viết chương trình tạo một mảng các phân số. Hãy viết hàm thực hiện các công việc
sau :
a. Tính tổng tất cả các phân số (kết quả dưới dạng phân số tối giản)
b. Tìm phân số lớn nhất, phân số nhỏ nhất.
c. Sắp xếp mảng tăng dần.
Câu 11: Tổ chức dữ liệu để quản lí sinh viên bằng cấu trúc mẫu tin trong một mảng N phần
tử, mỗi phần tử có cấu trúc như sau:
- Mã sinh viên.
- Tên.
- Năm sinh.
- Điểm toán, lý, hoá, điểm trung bình.
Viết chương trình thực hiện những công việc sau:
a. Nhập danh sách các sinh viên cho một lớp học.
b. Xuất danh sách sinh viên ra màn hình.
c. Tìm sinh viên có điểm trung bình cao nhất.
d. Sắp xếp danh sách lớp theo thứ tự tăng dần của điểm trung bình.
e. Sắp xếp danh sách lớp theo thứ tự giảm dần của điểm toán.
f. Tìm kiếm và in ra các sinh viên có điểm trung bình lớn hơn 5 và không có môn
nào dưới 3.
g. Tìm sinh viên có tuổi lớn nhất.
Nhập vào tên của một sinh viên. Tìm và in ra các thông tin liên quan đến sinh viên
đó (nếu có)
Câu 12: Viết chương trình tính tiền điện hàng tháng của các hộ gia đình, thông tin các khách
hàng như sau :
- Kỳ thu, từ ngày……đến ngày.
- Tên khách hàng, mã khách hàng.
- Địa chỉ.
- Điện năng tiêu thụ (Kwh).
a. Nhập vào danh sách các khách hàng.

b. Xuất danh sách hoá đơn theo thứ tự tăng dần của điện năng tiêu thụ.
c. Tính tiền điện của các khách hàng theo quy định sau.
- 100 kw đầu tiên là 550 đ / kw
- 50 kw tiếp theo là 900 đ / kw
- 50 kw tiếp theo là 1210 đ / kw
- Thuế 10 % trên tổng số tiền phải trả
Tính tổng số tiền thu được của các khách hang

Con trỏ và Hàm trong C++
¾ Con trỏ
¾ Mảng động
¾ Hàm
¾ Đệ quy
Câu 1: Hãy cho biết kích thước của biến con trỏ kiểu byte và kiểu long
# include <iostream.h>
void main()
{
byte* a;
long* b;
cout<<sizeof(a)<<endl;
cout<<sizeof(b)<<endl;
}
Câu 2: Cho đoạn chương trình sau:
float pay;
float *ptr_pay;
pay=2313.54;
ptr_pay = &pay;
Hãy cho biết giá trị của:
a. pay
b. *ptr_pay
c. *pay
d. &pay
Câu 3: Đọc để hiểu chương trình C++ sau đây:
#include<iostream.h>
void main()
{
int a;
int *aPtr; // aPtr is a pointer to an integer
a = 7;
aPtr = &a; //aPtr set to address of a
cout << “The address of a is “ << &a
<< “nThe value of aPtr is “ << aPtr;

cout << “nnThe value of a is “<< a
<< “nThe value of *aPtr is “ << *aPtr
<< endl;
}
Chạy thử chương trình trên và giải thích kết quả của chương trình.
Câu 4: Cho một hàm như sau:
int square(int a)
{
a = a*a;
return a;
}
a. Viết chương trình C++ nhập vào số nguyên x và gọi hàm square để tính bình
phương của x và trình bày kết quả này ra.
b. Viết lại hàm square để hàm này trở thành một hàm gọi bằng địa chỉ, đặt tên
hàm mới là square2. Viết chương trình C++ nhập vào số nguyên x và gọi hàm
square2 để tính bình phương của x và trình bày giá trị của x sau khi gọi hàm.
Có nhận xét gì về giá trị của x sau khi gọi hàm?
Câu 5: Đọc hàm sau đây dùng để tính số nguyên lớn nhất mà bình phương của nó nhỏ hơn
hay bằng một trị số nguyên cho trước.
int Intqrt(int num)
{
int i;
i = 1;
do
++ i
while i*i <= num;
return(i –1);
}
Viết một chương trình C++ đọc vào một số nguyên n và gọi hàm Intqrt để tính số
nguyên lớn nhất mà bình phương của nó <= n.
Câu 5: Hãy khai báo mảng động cho ma trận hai chiều có kích thước m x n. Sau đó, kiểm tra
có phải ma trận đối xứng không.
Câu 6: Viết chương trình nhập số nguyên dương n gồm k chữ số (0 < k ≤ 5) , sắp xếp các chữ
số của n theo thứ tự tăng dần.
Ví dụ: Nhập n = 1536
Kết quả sau khi sắp xếp: 1356.
Câu 7: Cho công thức tính số tổ hợp m vật lấy từ n vật như sau:

C(n,m) = 1 nếu m = 0 hay m=n
C(n, m) = C(n-1, m) + C(n-1, m-1) nếu 0 < m < n
a. Hãy viết hàm đệ quy C++ để tính C(n,m).
b. Viết chương trình C++ nhập vào hai số nguyên n và m và gọi hàm C định nghĩa
ở câu a để tính C(n,m) và trình bày kết quả ra.
Câu 8: Hãy viết hàm đệ quy để tìm chữ số đầu tiên của số nguyên dương n.
Bài tập thêm
Câu 1: Cho định nghĩa mảng và con trỏ sau:
int ara[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int *ip1, *ip2;
Phép gán nào hợp lệ trong các phép gán sau:
a. ip1 = ara;
b. ip2 = ip1 = &ara[3];
c. ara = 15;
d. *(ip2 + 2) = 15; // Assuming ip2 and ara are equal.
void main()
{
int num;
cout<< “Please enter the numbers of input: ”
cin>>num;
int a = new int [num];
int total = 0; // Holds total of user’s eight numbers.
int ctr;
for (ctr=0; ctr<num; ctr++)
{
cout << “Please enter the next number...”;
cin >> a[ctr];
total += a[ctr];
}
cout << “The total of the numbers is “ << total << “n”;
return;
}
Câu 3: Chạy đoạn chương trình sau và giải thích

void swap(int a[], int *c1, int *c2, int *d1, int *d2);
void main()
{
int a[2], c1, c2,d1,d2;
int *x1, *x2, *y1, *y2;
a[0] = 1 ; a[1] =2;
c1 = 1; c2 =2;
d1 = 1; d2 =2;
x1 = &c1; x2 = &c2;
y1 = &d1; y2 = &d2;
swap(a, x1,x2,y1,y2);
cout<<a[0]<<a[1]<<” “
<< *x1<<*x2<<” ”
<<*y1<<*y2;
swap(a, x1,x2,y1,y2);
cout<<a[0]<<a[1]<<” “
<< *x1<<*x2<<” ”
<<*y1<<*y2;
}
void swap(int a[], int *c1, int *c2, int *d1, int *d2)
{
a[0] = 2 ; a[1] =1;
*c1=2, *c2 =1;
int* temp = d1;
d1 =d2;
d2 = temp;
}
Câu 4: Viết một hàm trả về căn bậc 4 của một đối số nguyên k. Giá trị trả về phải là một số
chính xác kép. (Hướng dẫn: nên dùng hàm thư viện sqrt( )).
Viết một chương trình C++ đọc vào một số nguyên n và gọi hàm nói trên tính căn bậc
bốn của n.
Câu 5: Hãy viết hàm đệ quy để tìm ước số chung lớn nhất của hai số nguyên dương a và b
Câu 6: Cài đặt và minh hoạ bài toán tháp Hà Nội được trình bày bên dưới.

Bài toán tháp Hà Nội (tiếng Anh gọi là Tower of Hanoi hay Towers of Hanoi) xuất phát từ
trò chơi đố Tháp Hà Nội. Mục đích của bài toán là thực hiện được yêu cầu của trò chơi. Dạng
bài toán thông dụng nhất là:
Người chơi được cho ba cái cọc và một số đĩa có kích thước khác nhau có thể cho vào các cọc
này. Ban đầu sắp xếp các đĩa theo trật tự kích thước vào một cọc sao cho đĩa nhỏ nhất nằm
trên cùng, tức là tạo ra một dạng hình nón. Người chơi phải di chuyển toàn bộ số đĩa sang một
cọc khác, tuân theo các quy tắc sau:
• một lần chỉ được di chuyển một đĩa
• một đĩa chỉ có thể được đặt lên một đĩa lớn hơn (không nhất thiết hai đĩa này phải có
kích thước liền kề, tức là đĩa nhỏ nhất có thể nằm trên đĩa lớn nhất)".
Bài toán này có lời giải chính xác. Tuy nhiên các mở rộng cho trường hợp có nhiều hơn ba
cọc cho đến nay vẫn chưa được giải cặn kẽ.
Thuật giải đệ quy
• đặt tên các cọc là A, B, C -- những tên này có thể chuyển ở các bước khác nhau
• gọi n là tổng số đĩa
• đánh số đĩa từ 1 (nhỏ nhất, trên cùng) đến n (lớn nhất, dưới cùng)
Để chuyển n đĩa từ cọc A sang cọc B thì cần:
1. chuyển n-1 đĩa từ A sang C. Chỉ còn lại đĩa #n trên cọc A
2. chuyển đĩa #n từ A sang B
3. chuyển n-1 đĩa từ C sang B cho chúng nằm trên đĩa #n
Phương pháp trên được gọi là thuật giải đệ quy: để tiến hành bước 1 và 3, áp dụng lại thuật
giải cho n-1. Toàn bộ quá trình là một số hữu hạn các bước, vì đến một lúc nào đó thuật giải
sẽ áp dụng cho n = 1. Bước này chỉ đơn giản là chuyển một đĩa duy nhất từ cọc A sang cọc B.

Giới thiệu về Lớp Đối tượng
- Cách viết chương trình có sử dụng lớp đối tượng trong môi trường Microsft Visual
C++.
- Định nghĩa hàm khởi tạo cho lớp đối tượng.
- Quản lý vùng nhớ cấp phát động (heap memory).
- Thiết kế và định nghĩa các lớp đối tượng Rectangle và CStudent.
Câu 1. a. Đọc để hiểu chương trình sau đây có sử dụng lớp đối tượng student. Hãy tổ chức
chương trình thành một file nguồn và chạy thử chương trình trên môi trường Visual C++.
class student{
private:
long int rollno;
int age;
char sex;
float height;
float weight;
public:
void getinfo();
void disinfo();
};
void student::getinfo()
{
cout << " Roll no :";
cin >> rollno;
cout << " Age :";
cin >> age;
cout << " Sex:";
cin >> sex;
cout << " Height :";
cin >> height;
cout << " Weight :";
cin >> weight;
}
void student::disinfo()
{
cout<<endl;
cout<< " Roll no = "<< rollno << endl;

cout<< " Age =" << age << endl;
cout<< " Sex =" << sex << endl;
cout<< " Height =" << height << endl;
cout<< " Weight =" << weight << endl;
}
void main()
{
student a;
cout << " Enter the following information " << endl;
a.getinfo();
cout << " n Contents of class "<< endl;
a.disinfo();
}
b. Hãy tổ chức chương trình trên thành file giao tiếp (interface file) và file thi công
(implementation file) và chạy chúng trên môi trường Visual C++.
Câu 2. Cho lớp đối tượng student được định nghĩa như trong 1.a. Hãy viết chương trình C++
hoàn chỉnh mà hàm main() khai báo một mảng (array) có kích thước là 10 để chứa các đối
tượng student, yêu cầu người dùng đọc dữ liệu của các đối tượng student trong mảng và trình
bày các đối tượng student đó ra màn hình.
Câu 3. Cho lớp đối tượng student được định nghĩa như trong 1.a. Hãy viết chương trình C++
hoàn chỉnh mà hàm main() theo các yêu cầu sau:
- Khai báo một mảng (array) có kích thước động để chứa các đối tượng student
- Yêu cầu người dùng nhập vào số nguyên n và tạo vùng nhớ heap để mảng trên có thể
chứa được n đối tượng student.
- Đọc dữ liệu của các đối tượng student vào mảng và trình bày các đối tượng student đó ra
màn hình.
- Xóa vùng nhớ heap đã tạo ở trên.
Câu 4. Kiểm tra đoạn chương trình sau đây trên máy tính:
class Int{
private:
int idata;
public:
Int(){
idata=0;
cout<<"default constructor is called"<<endl;
}
Int(int d){

idata=d;
cout<<"constructor with argument is called"<<endl;
}
void showData(){
cout<<"value of idata: "<<idata<<endl;
}
};
void main()
{
Int i;
Int j(8);
Int k=10;
Int *ptrInt = new Int();
ptrInt->showData();
delete ptrInt;
}
Nội dung xuất ra màn hình là gì khi thực thi đoạn chương trình trên? Giải thích?
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
Trong đoạn chương trình trên, câu lệnh delete ptrInt; dùng để làm gì?
................................................................................................................................................
................................................................................................................................................
Câu 5. Xây dựng một lớp đối tượng Rectangle mà gồm hai thành viên dữ liệu kiểu số thực
chính xác đơn: length và width. Lớp đối tượng có các hàm thành viên sau đây:
- hàm khởi tạo (constructor) không có thông số. Hàm này gán trị 0 cho hai thành viên dữ
liệu của đối tượng.
- hàm khởi tạo có hai thông số kiểu số thực chính xác đơn. Hàm này gán trị của hai thông
số cho hai thành viên dữ liệu của đối tượng.
- hàm perimeter() tính chu vi của một hình chữ nhật.
- hàm area() tính diện tích của một hình chữ nhật.
- thủ tục getdata( ) để yêu cầu người dùng nhập giá trị cho length và width của hình chữ
nhật

- thủ tục showdata( ) để trình bày ra màn hình length, width, chu vi và diện tính của hình
chữ nhật.
Hiện thực lớp đối tượng Rectangle vào một chương trình C++ hoàn chỉnh. Chương trình này
khai báo hai đối tượng thuộc lớp Rectangle sử dụng hai hàm khỏi tạo ở trên, đọc vào và trình
bày dữ liệu của hai đối tượng này nhằm kiểm tra sự hoạt động của các hàm thành viên.
Cải tiến chương trình: thay hai hàm khởi tạo đã định nghĩa ở trên của lớp Rectangle bằng một
hàm khởi tạo có thông số mặc định (default argument).
Câu 6. Xây dựng một lớp đối tượng CStudent gồm các thành phần dữ liệu (data members)
sau:
- mã số sinh viên (là số nguyên).
- một mảng (array) được khai báo tĩnh gồm 5 số thực chính xác đơn dùng để chứa tối đa 5
điểm số.
- một số nguyên chỉ số điểm số được nhập vào.
Các hàm thành viên (member functions) của lớp đối tượng như sau:
- hàm khởi tạo (constructor) của lớp đối tượng này để gán giá trị đầu = 0 cho tất cả các
thành viên dữ liệu của mỗi đối tượng CStudent.
- thủ tục nhập mã số sinh viên.
- thủ tục nhập một điểm số kỳ thi và cập nhập tổng số điểm đã nhập vào.
- hàm tính điểm trung bình để trả ra điểm trung bình cộng của các điểm số đã nhập.
- thủ tục xuất ra màn hình mã số sinh viên và điểm trung bình của sinh viên.
Hiện thực lớp đối tượng CStudent vào một chương trình C++ hoàn chỉnh. Chương trình này
khai báo một đối tượng thuộc lớp CStudent, đọc vào và trình bày dữ liệu của đối tượng này
nhằm kiểm tra sự hoạt động của các hàm thành viên.

Xử lý Đối tượng
- Định nghĩa hàm khởi tạo mặc định, hàm khởi tạo có tham số, hàm khởi tạo sao chép
(copy constructor) cho lớp đối tượng.
- Định nghĩa hàm hủy bỏ (destructor) cho lớp đối tượng.
- Thiết kế và định nghĩa lớp đối tượng Dyn_Student.
class Int{
private:
int idata;
public:
Int(){
idata=0;
cout<<"default constructor is called"<<endl;
}
Int(int d=9){
idata=d;
cout<<"constructor with argument is called"<<endl;
}
void showData(){
cout<<"value of idata: "<<idata<<endl;
}
};
void main()
{
Int i;
Int j(8);
Int k=10;
}
a. Giải thích lý do chương trình trên bị lỗi khi biên dịch?
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
b. Chỉnh sửa chương trình để không còn lỗi trên. Chạy thử các sửa đổi trên trong môi trường
Visual C++.

class Vector{
private:
int *value;
int dimension;
public:
Vector(int d=0){
dimension=d;
if (dimension==0)
value=NULL;
else{
value=new int[dimension];
for (int i=0; i<dimension; i++)
value[i]=0;
}
}
void showdata(){
cout<<value[i];
cout<<endl;
}
~Vector(){
if (value!=NULL)
delete value;
}
};
void main()
{
Vector v(5);
v.showdata();
Vector v2(v);
v2.showdata();
}
Giải thích tại sao chương trình bị lỗi bộ nhớ khi thực thi?
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
Thêm đoạn code sau vào phần định nghĩa của class Vector:
Vector(const Vector& v){
dimension = v.dimension;
value[i]=v.value[i];

}
Chương trình còn bị lỗi bộ nhớ khi thực thi nữa không? Giải thích?
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
Câu 3. a. Kiểm tra đoạn chương trình sau đây trên máy tính:
class some{ // doan chuong trinh a
public:
~some() {
cout<<"some's destructor"<<endl;
}
};
void main() {
some s;
s.~some();
}
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
b. Kiểm tra đoạn chương trình sau đây trên máy tính:
class some{ // doan chuong trinh b
int *ptr;
public:
some(){
ptr= new int;
}
~some(){
cout<<"some's destructor"<<endl;
if (ptr!=NULL){
cout<<"delete heap memory"<<endl;
delete ptr;
}
}
};
void main()

{
some s;
// s.~some();
}
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
Trong hàm main () của đoạn chương trình b, nếu ta bỏ đi dấu chú thích // phía trước câu lệnh
s.~some(); thì khi thực thi kết quả thế nào? Giải thích?
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
Câu 4. Cho một lớp đối tượng được định nghĩa như sau:
class Auto {
public:
Auto(char*, double);
displayAuto(char*, double);
private:
char* szCarMake;
double dCarEngine;
};
Auto::Auto(char* szMake, double dEngine){
szCarMake = new char[25];
strcpy(szCarMake, szMake);
dCarEngineSize = dCarEngine;
}
Auto::displayAuto(){
cout<< “The car make: “<< szCarMake<< endl;
cout<< “The car engine size: “<< dCarEngine<< endl;
}
void main(){
Auto oldCar(“Chevy”, 351);
Auto newCar(oldCar);
oldCar.displayAuto();
newCar.displayAuto();
}

a. Thêm vào lớp đối tượng trên một hàm khởi tạo sao chép (copy constructor) thích hợp.
b. Thêm vào lớp đối tượng trên một hàm hủy bỏ (destructor) thích hợp.
Chạy thử các sửa đổi trên trong môi trường Visual C++.
Câu 5. Xây dựng một lớp đối tượng Dyn_Student gồm các thành phần dữ liệu (data members)
như sau:
- mã số sinh viên (là số nguyên).
- một mảng động (dynamic array) dùng để chứa điểm số của sinh viên, mảng động được
hiện thực là một con trỏ kiểu số thực chính xác đơn.
- một số nguyên dùng để chỉ số điểm số của sinh viên.
Các hàm thành viên (member functions) của lớp đối tượng như sau:
- hàm khởi tạo (constructor) không có thông số, hàm này gán giá trị đầu = 0 hoặc = NULL
cho tất cả các thành viên dữ liệu của mỗi đối tượng Dyn_Student.
- hàm khởi tạo có một thông số kiểu số nguyên, hàm này gán giá trị của thông số cho
thành phần dữ liệu số điểm số của sinh viên và sau đó tạo vùng nhớ heap cho mảng
động.
- hàm khởi tạo sao chép (copy constructor) để tạo đối tượng thuộc lớp Dyn_Student từ đối
tượng tượng có sẵn.
- thủ tục nhập mã số sinh viên.
- thủ tục nhập các điểm số của sinh viên.
- hàm tính điểm trung bình để trả ra điểm trung bình cộng của các điểm số.
- thủ tục xuất ra màn hình mã số sinh viên và điểm trung bình của sinh viên.
- hàm hủy (destructor) để hủy vùng nhớ heap đã cấp phát cho mảng động.
Hiện thực lớp đối tượng Dyn_Student vào một chương trình C++ hoàn chỉnh. Chương trình
này khai báo một đối tượng thuộc lớp Dyn_Student, đọc vào và trình bày dữ liệu của đối
tượng này nhằm kiểm tra sự hoạt động của các hàm thành viên.

Xử lý Đối tượng (tiếp theo)
- Định nghĩa và sử dụng các toán tử (operator) cơ bản của một lớp đối tượng.
- Định nghĩa toán tử gán (assignment operator) cho lớp đối tượng.
- Thành phần dữ liệu static của lớp đối tượng.
Câu 1. Đọc hiểu đoạn chương trình minh họa cách định nghĩa và sử dụng toán tử (operator)
cho một lớp đối tượng. Trong ví dụ này, lớp đối tượng Complex biểu diễn các số phức được
hiện thực, toán tử hiệu (-) của 2 số phức cũng được định nghĩa.
class complex
{
float real;
float img;
public:
complex()
{
real = 0; img = 0;
}
complex(float a,float b)
{
real =a ; img = b;
}
complex operator -(complex );
void disp();
};
// Fn.for overloading of - operator for complex arithmetic
complex complex::operator-(complex a)
{
return complex(real-a.real,img-a.img);
}
// function for display of Real & Imaginary Parts
void complex::disp()
{
cout<<"The real part is : "<<real;
cout<<"The imaginary part is: "<<img;
}
void main(void)
{
complex c1(12.0,4.5),c2(8,6),c3;
cout<<"The value of c1 is:";
c1.disp();

c2.disp();
c3.disp();
c3=c1-c2;
cout<<"After c3=c1-c2, c3 is : ";
c3.disp();
getch();
}
Chạy thử chương trình trên trong Visual C++. Chương trình in ra kết quả gì? Giải thích?
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
class Vector{
private:
int *value;
int dimension;
public:
Vector(int d=0){
dimension=d;
if (dimension==0)
value=NULL;
else{
value[i]=0;
}
}
void showdata(){
cout<<value[i];
cout<<endl;
}
~Vector(){
if (value!=NULL)
delete value;
}
};

void main()
{
Vector v(5);
v.showdata();
Vector v2;
v2 = v;
v2.showdata();
}
Giải thích tại sao chương trình bị lỗi bộ nhớ khi thực thi?
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
Thêm đoạn code sau vào phần định nghĩa của class Vector:
void operator=(const Vector& v){
if (value!=NULL)
delete value;
dimension = v.dimension;
value[i]=v.value[i];
}
Chương trình còn bị lỗi bộ nhớ khi thực thi nữa không? Giải thích?
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
Câu 3. Đọc hiểu đoạn chương trình sau minh họa cách định nghĩa và sử dụng dữ liệu thành
viên static của một lớp đối tượng. Trong ví dụ này, dữ liệu thành viên static dùng để đếm số
lượng các đối tượng của lớp đối tượng đang tồn tại trên bộ nhớ.
class StaticSample {
public:
static int n;
StaticSample () { n++; };
~StaticSample () { n--; };
};

int StaticSample::n=0;
int main () {
StaticSample a;
StaticSample b[5];
StaticSample * c = new StaticSample;
cout << a.n << endl;
delete c;
cout << StaticSample::n << endl;
return 0;
}
Chạy thử chương trình trên trong Visual C++. Chương trình in ra kết quả gì? Giải thích?
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
Câu 4. Cho định nghĩa lớp đối tượng Employee dưới đây. Hãy hiện thực các hàm khởi tạo
sao chép, hàm hủy bỏ và hàm toán tử gán cho lớp đối tượng Employee để đảm bảo hàm main
theo mẫu được thực thi đúng.
#include <string.h>
class Employee{
private:
char *firstName;
char *lastName;
float payRate;
public:
Employee(const char *first, const char *last, float rate){
firstName = new char[strlen(first)+1];
strcpy(firstName, first);
lastName = new char[strlen(last)+1];
strcpy(lastName, last);
payRate = rate;
}
void showData(){
cout<<firstName<<" "<<lastName<<" is paid at rate
"<<payRate<<endl;
}
Employee(const Employee& e){
// Hiện thực hàm khởi tạo sao chép
}

Employee operator=(const Employee& e){
// Hiện thực hàm toán tử gán
}
~Employee(){
// Hiện thực hàm hủy bỏ
}
};
void main(){
Employee e1("Susan", "Baker", 2.34);
e1.showData();
Employee e3(e1);
e3.showData();
Employee *e2Ptr = new Employee("Robert", "Jones", 3.15);
e2Ptr->showData();
e3 = e1 = *e2Ptr;
e3.showData();
delete e2Ptr;
}
Câu 5. Xem lại lớp đối tượng Auto trong bài 4 của Bài thực tập số 7. Thêm vào lớp đối tượng
này một hàm toán tử gán thích hợp. Xây dựng một chương trình C++ hoàn chỉnh nhằm kiểm
tra sự hoạt động của hàm toán tử gán này.
Câu 6. Xem lại lớp đối tượng Dyn_Student trong bài 5 của Bài thực tập số 7. Thêm vào lớp
đối tượng này một hàm toán tử gán thích hợp. Xây dựng một chương trình C++ hoàn chỉnh
nhằm kiểm tra sự hoạt động của hàm toán tử gán này.

Sự Thừa kế và Bao gộp trong C++
- Tầm vực truy xuất (access specifier) của các dữ liệu thành viên được thừa kế từ lớp cơ
sở.
- Thứ tự thực thi các hàm khởi tạo và hàm hủy bỏ trong lớp dẫn xuất.
- Thiết kế và định nghĩa các lớp đối tượng theo các sơ đồ thừa kế sau:
Circle
Cylinder Sphere
Rectangle
Box
- Thiết kế và định nghĩa lớp đối tượng CRectangle có dữ liệu thành viên điểm góc trên
bên trái và điểm góc dưới bên phải là đối tượng thuộc lớp CPoint:
Câu 1. Cho lớp đối tượng Point được định nghĩa dưới đây.
class Point{
private:
int color;
protected:
double x;
double y;
public:
Point(double x=0, double y=0){
this->x=x; this->y=y;
}
void move(double dx, double dy){
x=x+dx;
y=y+dy;
}
~Point(){
cout<<"Destructor Point called";
}
};
Khai báo lớp Point_Derive1 thừa kế class Point:
class Point_Derive1:public Point{
private:
CPoint
CPoint_3D

double z;
public:
Point_Derive1();
void move(double dx, double dy, double dz);
~Point_Derive1();
};
Cho biết class Point_Derive1 có các thành viên dữ liệu (data member) và hàm thành viên
(member function) nào. Đồng thời cho biết tầm vực truy xuất (access specifier) của từng
thành viên đó:
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
class Point_Derive2:protected Point{
private:
double z;
public:
Point_Derive1();
~Point_Derive1();
};
thành viên đó:
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
class Point_Derive3:private Point{
private:
double z;
public:
Point_Derive1();
~Point_Derive1();
};

thành viên đó:
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
Câu 2. Cho chương trình sau trong đó chúng ta suy dẫn một lớp đối tượng Cylinder từ lớp đối
tượng Circle.
#include <math.h>
const double PI = 2.0 * asin(1.0);
// class declaration
class Circle
{
protected:
double radius;
public:
Circle(double = 1.0); // constructor
double calcval();
};
// implementation section for Circle
// constructor
Circle::Circle(double r)
{
radius = r;
}
// calculate the area of a circle
double Circle::calcval()
{
return(PI * radius * radius);
}
// class declaration for the derived class
// Cylinder which is derived from Circle
class Cylinder : public Circle
{
protected:
double length; // add one additional data member and
public: // two additional function members
Cylinder(double r = 1.0, double l = 1.0) : Circle(r), length(l) {}
double calcval();

};
// implementation section for Cylinder
double Cylinder::calcval() // this calculates a volume
{
return length * Circle::calcval(); // note the base function call
}
int main()
{
Circle circle_1, circle_2(2); // create two Circle objects
Cylinder cylinder_1(3,4); // create one Cylinder object
cout << "The area of circle_1 is " << circle_1.calcval() << endl;
cout << "The area of circle_2 is " << circle_2.calcval() << endl;
cout << "The volume of cylinder_1 is " << cylinder_1.calcval() << endl;
circle_1 = cylinder_1; // assign a cylinder to a Circle
cout << "nThe area of circle_1 is now " << circle_1.calcval() << endl;
return 0;
}
a. Hiện thực chương trình trên môi trường Visual C++. Xác định dữ liệu xuất của chương
trình.
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
................................................................................................................................................
b. Hãy sửa đổi chương trình trên để thêm vào một lớp dẫn xuất tên Sphere từ lớp cơ bản
Circle. Hàm thành viên chủ yếu của của Sphere là một hàm tạo lập và một hàm tên calcval()
mà trả về thể tích của khối cầu. (chủ ý công thức tính thể tích của một khối cầu bán kính R là
(4/3)π R3). Và sửa đổi hàm main() theo đó chương trình gọi tất cả các hàm thành viên của lớp
Sphere ra làm việc.
Câu 3. Tạo một lớp cơ bản tên Rectangle bao gồm hai dữ liệu length và width. Từ lớp này,
hãy dẫn xuất ra lớp tên Box mà có thêm một thành phần dữ liệu là depth. Các hàm thành viên
của lớp cơ sở gồm có một hàm tạo lập và một hàm tên area để tính diện tích của hình chữ
nhật. Lớp dẫn xuất Box nên có một hàm tạo lập và một hàm ghi đè tên area mà trả về diện
tích bề mặt của khối hình hộp và một hàm tên volume() để tính thể tích của hình hộp.

Đưa hai lớp nói trên vào một chương trình C++ hòan chỉnh trong đó gọi mọi hàm thành viên
của mỗi lớp ra làm việc. Ngòai ra, chương trình còn gọi hàm area() của lớp cơ bản để áp dụng
cho một đối tượng Box và hãy giải thích kết quả trả về của hàm này.
Câu 4. Thực thi đoạn code sau trong Visual C++ và trả lời các câu hỏi bên dưới :
class mother
{
public:
mother ()
{ cout << "000,"; }
mother (int a)
{ cout << "001,"; }
mother (const mother &obj)
{cout<<"002,";}
void f1()
{ cout <<"010,";}
void f2()
{ cout<<"011,";}
mother operator = (const mother obj)
{ cout<<"012,";
return obj; }
~mother()
{cout<<"020,";}
};
class daughter : public mother
{
public:
daughter ()
{ cout << "021,"; }
daughter (int a)
{ cout << "022,"; }
void f1()
{ cout <<"100,";}
void f2()
{ cout<<"101,";}
};
void main () {
mother m1;
mother *mPtr = new mother(3);
daughter d1(3);
cout<<endl; // Lenh cout 1
mother m2;
m2 = m1;

mPtr = &d1;
mPtr->f1();
mPtr->f2();
delete mPtr;
}
Khi chương trình thực thi đến dòng lệnh “cout<<endl; // Lenh cout 1” thì kết quả
xuất ra màn hình:
…………………………………………………………………………………………………
xuất thêm (chỉ tính kết quả mới, không tính kết quả đã ghi trong câu trước) ra màn
hình:
…………………………………………………………………………………………………
xuất thêm (chỉ tính kết quả mới, không tính kết quả đã ghi trong câu trước) ra màn
hình:
…………………………………………………………………………………………………
Khi chương trình thực thi đến hết dòng lệnh “cout<<endl; // Lenh cout 4” thì chương
trình bị lỗi bộ nhớ. Hãy giải thích lý do tại sao?
…………………………………………………………………………………………………
…………………………………………………………………………………………………
…………………………………………………………………………………………………
…………………………………………………………………………………………………
…………………………………………………………………………………………………
Câu 5. a. Hiện thực lớp CPoint theo các miêu tả về thuộc tính dữ liệu và hàm thành viên như
sau:
- Tọa độ x,y trong mặt phẳng 2 chiều.
- Định nghĩa hàm khởi tạo có hai thông số ứng với hai toạ độ x và y, mặc định cho hai
thông số này lần lượt là 0 và 0.
- Định nghĩa hàm display để hiển thị các thuộc tính ra màn hình.
- Định nghĩa hàm getInfo để yêu cầu người dùng nhập các thông tin cho thuộc tính.
- Định nghĩa các hàm set để thiết lập giá trị cho các thuộc tính.
- Định nghĩa các hàm get để truy xuất giá trị của các thuộc tính.

- Định nghĩa hàm distance nhận vào thông số là một đối tượng thuộc lớp Point để tính
khoảng cách từ đối tượng gọi hàm đến đối tượng thông số.
b. Hiện thực lớp CPoint_3D theo miêu tả sau:
- Thừa kế lớp Point ở trên.
- Có thêm thuộc tính tọa độ z.
- Định nghĩa đè (overide) các hàm của lớp Point.
c. Hiện thực lớp CRectangle để mô tả một hình chữ nhật theo miêu tả sau:
- Có điểm góc trên bên trái và điểm góc dưới bên phải. (dùng lớp đối tượng CPoint ở trên)
- Định nghĩa hàm khởi tạo có hai thông số ứng với hai thuộc tính.
- Định nghĩa hàm display để hiển thị các thuộc tính ra màn hình.
- Định nghĩa hàm getInfo để yêu cầu người dùng nhập các thông tin cho thuộc tính.
- Định nghĩa các hàm set để thiết lập giá trị cho các thuộc tính.
- Định nghĩa các hàm get để truy xuất giá trị của các thuộc tính.
- Định nghĩa hàm area để tính diện tích hình chữ nhật.

Đa hình và Khuôn hình
- Đa hình trong C++.
- Định nghĩa và sử dụng khuôn hình hàm.
- Định nghĩa và sử dụng khuôn hình lớp.
Câu 1. a. Thực thi chương trình sau trong Visual C++.
class A
{
public:
void say() {cout << "I am A";}
};
class B: public A
{
public:
void say() {cout << "I am B";}
};
void main()
{
A* ptrA;
B objB;
objB.say();
cout << endl;
ptrA = &objB;
ptrA->say();
}
Kết quả xuất ra màn hình là gì? Giải thích.
…………………………………………………………………………………………………
…………………………………………………………………………………………………
…………………………………………………………………………………………………
…………………………………………………………………………………………………
…………………………………………………………………………………………………
b. Nếu sửa đổi class A lại như sau:
class A
{
public:
virtual void say() {cout << "I am A";}
};
Kết quả xuất ra màn hình là gì? Giải thích tại sao kết quả lại khác với câu a ở trên.

…………………………………………………………………………………………………
…………………………………………………………………………………………………
…………………………………………………………………………………………………
…………………………………………………………………………………………………
…………………………………………………………………………………………………
Câu 2. Đọc hiểu chương trình C++ sau đây:
class base{
private:
int x;
float y;
public:
void getdata();
void display( );
};
class derivedB: public base {
private:
int rollno;
char name[20];
public:
void getdata();
void display( );
};
void base::getdata()
{
cout << "Enter an integer n";
cin>> x;
cout << "Enter a real number n";
cin>> y;
}
void base::display()
{
cout<< "entered numbers are x = " << x << "and y = " << y;
cout << endl;
}
void derivedB:: getdata()
{
cout << "Enter roll number of a student ? n";
cin>> rollno;
cout << "Enter name of a student ? n";
cin>> name;
}
void derivedB::display()
{
cout<< "roll number student's name " << rollno << 't'<< name;

cout << endl;
}
void main()
{
base* ptr;
derivedB obj;
ptr = &obj;
ptr->getdata();
ptr->display();
}
a. Hiện thực chương trình trên với môi trường Visual C++ và hãy giải thích kết quả xuất ra.
…………………………………………………………………………………………………
…………………………………………………………………………………………………
…………………………………………………………………………………………………
…………………………………………………………………………………………………
…………………………………………………………………………………………………
b. Trong chương trình trên, hãy sửa đổi phần khai báo lớp base như sau:
class base{
private:
int x;
float y;
public:
virtual void getdata();
virtual void display( );
};
Thực thi chương trình sửa đổi, xem xét kết quả xuất ra và giải thích tại sao kết quả lại khác
với trường hợp ở câu a.
…………………………………………………………………………………………………
…………………………………………………………………………………………………
…………………………………………………………………………………………………
…………………………………………………………………………………………………
…………………………………………………………………………………………………
Câu 3. a. Viết một khuôn hình hàm (function template) tên display() mà trình bày ra giá trị
của đối số đơn được truyền đến hàm khi hàm được gọi.
b. Đưa khuôn hình hàm ở a. vào trong một chương trình C++ mà gọi hàm bốn lần: một lần với
đối số kiểu char, một lần với đối số nguyên, một lần với đối số thực chính xác đơn và một lần
với đối số thực chính xác kép.
Câu 4. a. Viết một khuôn hình hàm (function template) tên maximum( ) mà trả về trị lớn nhất
của hai đối số được truyền đến hàm khi hàm được gọi.

b. Đưa khuôn hình hàm ở a. vào trong một chương trình C++ mà gọi hàm hai lần: một lần với
2 đối số kiểu số nguyên, một lần với 2 đối số thực chính xác đơn.
c. Định nghĩa chồng (overload) khuôn hình hàm maximum ở trên, có đối số là một mảng
kiểu T (dùng khuôn hình template), trả ra giá trị lớn nhất của mảng. Đưa khuôn hình hàm vào
trong một chương trình C++ mà gọi hàm hai lần: một lần với mảng kiểu số nguyên, một lần
với mảng kiểu số thực chính xác đơn.
Câu 5. Cho một lớp tên sample được định nghĩa như sau:
class sample{
private:
int value, value1, value2;
public:
void getdata();
void sum();
};
void sample::getdata()
{
cin >> value1 >> value2;
}
void sample::sum()
{
value = value1 + value2;
cout << “ sum of = “ << value << endl;
}
a. Hãy viết lại lớp sample thành một khuôn hình lớp (class template) sao cho các thành phần
dữ liệu value, value1, value2 thay vì có kiểu int sẽ có kiểu thông số hoá T mà có thể là nguyên
hay thực gì cũng được.
b. Đưa định nghĩa khuôn hình lớp ở câu a vào một chương trình C++ đầy đủ trong đó kiến tạo
hai đối tượng sample với kiểu thông số T được xác định lần lượt là nguyên và thực, rồi nhập
dữ liệu cho từng đối tượng và gọi hàm sum cho từng đối tượng.
Câu 6. Đọc chương trình C++ sau đây có sử dụng lớp khuôn hình Array.
// ArrayT.h
template<class T>
class Array
{
private:
T* data; //T is the type of the array
int size;
public:
Array(T* d, int s);
void showList();

void showFirst( );
};
// arrayT.cpp
#include "ArrayT.h"
template<class T>
Array<T>::Array(T* d, int s)
{
data = d;
size = s;
}
template<class T>
void Array<T>::showList()
{
cout<<"Entire list:" <<endl;
for(int x = 0; x< size; x++)
cout<< data[x]<<endl;
cout<< "----------------------"<< endl;
}
template<class T>
void Array<T>::showFirst()
{
cout<< "First element is ";
cout << data[0]<< endl;
}
void main()
{
int arraySize;
int someInts[] = {12, 34, 55};
double someDoubles[] = {11.11, 23.44, 44.55, 123.66};
arraySize = sizeof(someInts)/sizeof(someInts[0]);
Array<int> arrayOfIntegers(someInts, arraySize);
arraySize = sizeof(someDoubles)/sizeof(someDoubles[0]);
Array<double> arrayOfDoubles(someDoubles, arraySize);
// Use showList() with each array
arrayOfIntegers.showList();
arrayOfDoubles.showList();
// Use showFirst() with each array
arrayOfIntegers.showFirst();
arrayOfDoubles.showFirst();
}
Hiện thực chương trình trên môi trường Visual C++. Xác định dữ liệu xuất của chương trình.
…………………………………………………………………………………………………
…………………………………………………………………………………………………
…………………………………………………………………………………………………
…………………………………………………………………………………………………
…………………………………………………………………………………………………

Câu 7. Hiện thực lớp Vector để mô hình một vector trong không gian n-chiều theo các miêu
tả về thuộc tính dữ liệu và hàm thành viên như sau:
- Có hai thuộc tính: số chiều vector, và một mảng các phần tử (mỗi phần tử ứng với một
tọa độ của vector). Kiểu phần tử của mảng có thể là số nguyên hoặc số thực nên cần phải
sử dụng template.
- Định nghĩa hàm khởi tạo mặc định.
- Định nghĩa hàm khởi sao chép (copy constructor).
- Định nghĩa hàm hủy (destructor).
- Định nghĩa hàm toán tử gán (assignment operator)
- Định nghĩa hàm tich_vo_huong, nhận thông số vào là một vector, trả ra tích vô hướng
của đối tượng vector gọi hàm với vector thông số được truyền vào.
- Định nghĩa overload hàm tich_vo_huong, nhận thông số vào là hai vector, trả ra tích vô
hướng của hai vector này.

Ktlt lab full

More Related Content

What's hot

Similar to Ktlt lab full

More from Trần Văn Nam

Ktlt lab full