Bài giảng ngôn ngữ lập trình c phần 2 lập trình hướng đối tượng c

PHẦN 2:
LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG
VỚI C++


CHƯƠNG 10: NHỮNG MỞ RỘNG CỦA C++
•

Nội dung:
Toán tử nhập xuất
Khai báo mọi nơi
Toán tử phạm vi
Tham chiếu
Chồng hàm
Lời gọi hàm với tham số có giá trị mặc định
Toán tử quản lý bộ nhớ động


Toán tử nhập xuất
 C++ cho phép sử dụng toán tử xuất (<<) và toán tử nhập (>>) để thay thế
cho các hàm xuất nhập chuẩn của C.
•
cout << biểu thức << . . . << biểu thức n
•
cin >> biến 1 >> . . . >> biến n
• Hai đối tượng cout và cin (được định nghĩa sẳn trong tập tin iostream.h)
tương ứng với hai thiết bị ra/vào chuẩn được sử dụng cùng với “<<“ và
“>>”. Thông thường ta hiểu cout là màn hình còn cin là bàn phím.
 Lợi điểm của việc sử dụng toán tử xuất nhập là người sử dụng không phải
quan tâm đến định dạng xuất nhập.

Ví dụ 1:
#include <iostream.h>
void main()
{
int a, b;
cout << “Nhap hai so nguyen”;
cin >> a >> b;
cout << “a+b = “ << a+b <<“\n”;
cout << “a-b = “ << a-b <<“\n”;
cout << “a*b = “ << a*b <<“\n”;
cout << “a/b = “ << a/b <<“\n”;
cout << “a%b = “ << a%b <<“\n”;
}


•
•
•
•
•
•
•
•
•
•

Khai báo mọi nơi
C++ không nhất thiết phải nhóm lên đầu câu khai báo đặt bên trong một
hàm hay trong một khối lệnh, mà có thể đặt xen kẽ với các câu lệnh xử lý.

Ví dụ 2:
void main()
{
int n; //khai báo biến n
<nhap n>
int gt = 1; //khai báo biến gt
for(int i = 1; i <= n; i++) //khai báo biến i bên trong vòng lặp
gt *= i;
cout << n << “!=“ << gt << endl;
}


•
•
•
•
•
•
•
•
•

Toán tử phạm vi
Bình thường , biến cục bộ che lấp biến toàn cục. Trong những trường hợp
cần thiết, khi muốn truy xuất tới biến toàn cục phải sử dụng toán tử phạm
vi “::” trước tên biến.
Ví dụ 3:
int x; //biến toàn cục
void main()
{

int x = 10; //x cục bộ
::x = 10; //x toàn cục
cout << x <<“\n”; // x cục bộ
cout << ::x <<“\n”; //x toàn cục
}


Tham chiếu
 C++ cho phép khai báo một biến tham chiếu dùng để tham chiếu tới một
biến tồn tại trong bộ nhớ. Mọi thay đổi trên biến tham chiếu đều làm thay
đổi chính biến được tham chiếu. Do đó có thể coi biến tham chiếu như là bí
danh khác của một biến.
• Ví dụ 4:
• void main()
• {
int n = 10;
•
int &r = n; //khai báo một biến tham chiếu r tham chiếu tới biến n
cout << “n = “ << n <<“, r = “ << r <<“\n”;
•
r += 10;
•
cout << “n = “ << n <<“, r = “ << r <<“\n”;
•
n += 10;
•
cout << “n = “ << n <<“, r = “ << r <<“\n”;
• }

 Trong C++, việc dùng khái niệm tham chiếu trong khai báo đối số của hàm
sẽ yêu cầu chương trình dịch truyền địa chỉ của biến cho hàm và hàm sẽ
thao tác trực tiếp trên biến đó. Đây là cách truyền tham số cho hàm bằng
tham chiếu.
• Ví dụ 5:
• void HoanVi(int &u, int &v)
• {
•
int tam = u; u = v; v = tam;
• }
• void main()
• {
•
int a, b;
•
<nhap a, b>
•
HoanVi(a, b);
•
<xuất a, b>
• }


 Hàm cũng có thể trả về tham chiếu. Trong trường hợp này biểu thức được
trả về trong câu lệnh return phải là tên một biến xác định từ bên ngoài
hàm, bởi vì khi đó mới có thể sử dụng được giá trị của hàm.
• Ví dụ 6:
• //Nguyên mẫu hàm
• int &fct();
• int x; //biến toàn cục

• void main()
• {
•
fct() = 10;
•
cout << x<<“\n”;
• }
• int &fct()
• {
•
return x; //trả về một tham chiếu tới biến x
• }


•

•
•
•
•
•
•
•

Chồng hàm
C++ cho phép sử dụng một tên cho nhiều hàm khác nhau, ta gọi đó là sự
chồng hàm. Trong trường hợp đó các hàm được phân biệt nhờ danh sách
kiểu tham số.
Ví dụ 7:
//hàm nguyên mẫu

int min(int a, int b); //Tìm min trong hai số nguyên
float min(float a, float b); //Tìm min trong hai số thực
char min(char a, char b); //Tìm min trong hai ký tự
int min(int a, int b, int c); //Tìm min trong ba số nguyên
int min(int t[], int n); //Tìm min trong mảng số nguyên


•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•

//Định nghĩa các hàm
int min(int a, int b)
{
return (a < b ? a : b);
}

int min(int a, int b, int c)
{
return (min(min(a, b), c);
}
float min(float a, float b)
{
return (a < b ? a : b);
}
char min(char a, char b)
{
return (a < b ? a : b);
}


•
•
•
•
•
•
•
•
•
•
•
•
•
•
•

int min(int t[], int n)
{
int res = t[0];
for(int i = 1; i < n; i++)
res = min(res, t[i]);
return res;
}
//Hàm chính
void main()
{
int u = 10, v = 20, r =30;
cout << “min(u, v) = “ << min(u, v) <<“\n”; //Hàm 1
cout << “min(u, v, r) = “ << min(u, v, r) <<“\n”; //Hàm 4
...
}


•
•
•
•
•
•
•
•
•
•
•
•
•

•

Đối số có giá trị ngầm định
Trong C++ cho phép tạo giá trị mặc định cho các đối số. Các đội này có thể
có hoặc không có tham số tương ứng trong lời gọi hàm. khi không có tham
số tương ứng, đối được khởi gán bởi giá trị mặc định.
Ví dụ 8:
void fct(int a, int b = 12); /*khai báo hàm với đối số thứ hai mang giá trị
ngầm định*/
//Định nghĩa hàm
void fct(int a, int b)
{
cout << “Đối số thứ 1:”<< a << “\n”;
cout << “Đối số thứ 2:”<< b << “\n”;
}
void main()
{
int u = 10, v = 20;
fct(u, v); //lời gọi thông thường có hai tham số
fct(u); //lời gọi chỉ một tham số
fct(); /* sẽ không được chấp nhận (vì đối số thứ nhất không có giá
trị ngầm định) */
}


•
•
•
•
•

•
•
•
•
•
•
•
•

Ví dụ 9:
void fct(int a = 0, int b = 12); /*khai báo hàm với hai đối số mang giá
trị ngầm định*/
//Định nghĩa hàm
void fct(int a, int b)
{
...
}
void main()
{
...
fct(); // được chấp nhận
}
Chú ý:
 Các đối mặc định phải được đặt ở cuối trong danh sách các đối số của
hàm.
 Khi định nghĩa hàm, nếu sử dụng khai báo nguyên mẫu thì các đối mặc
định cần được khởi gán trong nguyên mẫu chứ không phải trong định
nghĩa hàm.

Toán tử quản lý bộ nhớ động
 Bộ nhớ động là bộ nhớ mà người sử dụng có thể cấp phát hoặc giải phóng
bộ nhớ tùy theo nhu cầu.
 Toán tử cấp phát bộ nhớ động (new)
• dạng 1:
new <type>
• Xin cấp phát một bộ nhớ động đủ để chứa một biến kiểu type và trả về một
con trỏ đến vùng nhớ này nếu như cấp phát thành công, ngược lại hàm trả
về NULL
• dạng 2:
new <type>[<size>]
• Xin cấp phát một bộ nhớ động đủ chứa size phần tử kiểu type và trả về con
trỏ đến đầu vùng nhớ đó nếu như cấp phát thành công, ngược lại hàm trả về
NULL.


 Toán tử giải phóng vùng nhớ động (delete)
• Dạng 1:
delete
• Dạng 2:
delete[]
•
•
•
•
•
•
•
•
•

Ví dụ 10: cấp phát bộ nhớ động cho mảng một chiều
//khai báo nguyên mẫu hàm
void Nhap(int *a, int n);
void Xuat(int *a, int n);
//Định nghĩa hàm
void Nhap(int *a, int n)
{
...
}


•
•
•
•
•
•
•
•
•
•
•
•
•
•
•

void Xuat(int *a, int n)
{

...
}
//Hàm chính
void main()
{
int *a;
int n;
<nhập số phần tử n>
a = new int[n]; //cấp phát bộ nhớ động cho mảng 10 số nguyên
Nhap(a, n);
Xuat(a, n);
delete[]a; //giải phóng bộ nhớ động
}


•
•
•
•
•
•
•
•
•
•
•
•
•

Ví dụ 11: Cấp phát bộ nhớ động cho mảng hai chiều

//khai báo nguyên mẫu hàm
void Nhap(int **a, int m, int n);
void Xuat(int **a, int m, int n);
//Định nghĩa hàm
void Nhap(int **a, int m, int n)
{
...
}
void Xuat(int **a, int m, int n)
{
...
}


•
•
•
•
•
•
•

•
•
•
•
•
•

//Hàm chính

void main()
{
int **a; //biến con trỏ chứa địa chỉ của một con trỏ khác
int m, n, i;
<nhập số dòng m và số cột n>
//cấp phát bộ nhớ động cho mảng 2 chiều mxn
a = new int*[m]; //Cấp phát bnđ cho mảng m con trỏ nguyên
for(i = 0; i < m; i++)
a[i] = new int [n]; // Cấp phát bnđ cho mảng n số nguyên
Nhap(a, m, n); Xuat(a, m, n);
//giải phóng bộ nhớ động
for(i = 0; i < m; i++)
delete[]a[i];
delete[]a;
}