Lớp_Đối tượng...............................

NHP, Khoa CNTT, Trường ĐHHHVN
Chương 2. Đối tượng và lớp
2.1. Định nghĩa đối tượng, lớp.
2.2. Khai báo lớp, đối tượng.
2.3. Cấu tử và hủy tử.
2.4. Thành phần tĩnh, hàm bạn, lớp bạn.
2.5. Định nghĩa chồng toán tử.

 Đối tượng (object): là một thực thể tồn tại trong hệ thống. Mỗi
đối tượng xác định bằng 3 yếu tố:
 định danh đối tượng: xác định duy nhất đt trong hệ thống, phân biệt các
đt với nhau
 trạng thái của đt: là các thuộc tính mô tả đt
 hoạt động của đt: là những hành động mà đt có thể thực hiện được.

Ví dụ: Bài toán quản lý nhân viên, mỗi nhân viên là một đối tượng.
– Nhân viên tên là Huy, tuổi 28, hệ số lương 3.00; … là một đối tượng,
Kết quả của việc trừu tượng hóa các đối tượng của thế giới thực
thành các đối tượng lập trình là sự kết hợp giữa dữ liệu (thuộc
tính) và các hàm (phương thức).

2.1. Định nghĩa đối tượng, lớp
 Lớp (class) là một kiểu dữ liệu mới được dùng để định nghĩa
các đối tượng.
 Một lớp có vai trò như một kế hoạch hay một bản mẫu.
 Việc viết hay tạo ra một lớp mới không sinh ra bất cứ một đối
tượng nào trong chương trình.

2.2. Khai báo lớp, đối tượng
Khai báo lớp
class tên_lớp [: <kiểu thừa kế> lớp_cha]{
private: // Khai báo các thành phần dữ liệu (thuộc tính) riêng
// Khai báo các phương thức (hàm) riêng
protected: // Khai báo các thành phần dữ liệu được bảo vệ
// Khai báo các phương thức được bảo vệ
public: // Khai báo các thành phần dữ liệu chung
// Khai báo các phương thức chung
};

Khai báo lớp
 class SV{
private:
string ten;
int masv;
float d1, d2, d3;
public:
SV(){ten=“”; masv=0; d1=d2=d3=0.0;}
void nhap();
void xuat();
float tong(){return d1+d2+d3;}
 };
void SV::nhap(){
cout<<“Nhap ten sv: ”;
cin>>ten;
cout<<“Nhap ma sv: ”;
cin>>masv;
cout<<“Nhap diem: ”;
cin>>d1>>d2>>d3;
}
void SV::xuat(){
cout<<“Ho ten ”<<ten<<endl;
cout<<“Ma sv:
”<<masv<<endl;
cout<<“D mon 1: ”<<d1<<endl;
cout<<“Tong diem:
”<<tong()<<endl;
}

Khai báo đối tượng
 Giống như khai báo biến thông thường
 Tên_lớp tên_đối_tượng;
 Ví dụ:
 SV a;
 SV b[10];
 SV *p;
 …
Truy cập:
 tên_đối_tượng.tên_pt/tên_tp
 tên_đối_tượng->tên_pt/tên_tp //với con trỏ
a.ten
a.nhap()
a.tong()
p->xuat()
p->ns
…

Các thành phần trong lớp
 Các từ khóa private, protected, public quy định phạm vi sử dụng
của các tp dữ liệu hoặc pt.
từ khóa trong lớp ngoài lớp bạn bè thừa kế
pri x x
pro x x x
pub x x x x

Con trỏ this
 Tất cả các phương thức hoặc tp dữ liệu phải được gọi thông
qua đối tượng nào đó,
 Con trỏ this tham chiếu đến đối tượng đang gọi hàm thành
phần,
 Con trỏ this trong C++ là một từ khóa đề cập đến thể hiện hiện
tại của lớp,

Con trỏ this
class Employee {
private:
int id;
string name;
float salary;
public:
Employee(int id, string name, float salary) {
this->id = id;
this->name = name;
this->salary = salary;
}
void display() {
cout << this->id << " " << this->name << " " << this->salary << endl;
}
};
int main() {
Employee e1 = Employee(101, "Vinh", 500);
Employee e2(102, "Hoa", 1000);
e1.display();
e2.display();
return 0;
}

Con trỏ this

2.3. Cấu tử và hủy tử.
 Cấu tử (constructor): hàm thành phần có nhiệm vụ khởi tạo giá
trị ban đầu cho dữ liệu của đối tượng.
 Đặc điểm:
– trùng tên với tên lớp
– có nhãn public
– không có kiểu trả về
– có hoặc không có tham số (hàm tạo ngầm định)
– tự động được gọi khi đt được khai báo
– nếu không xd tường minh thì chương trình tự sinh ra một hàm tạo
không tham số, không nội dung

Cấu tử
class MyClass{
const int ci;
int x;
public:
MyClass():ci(0),x(0){}
};
hoặc MyClass(): ci(0){x=0;}

Cấu tử
class PS{
int ts, ms;
public:
PS():ts(1), ms(2){}
PS(int t, int m=9){ts=t; ms=m;}
};
PS a; // dùng hàm mặc định
PS b(2); // dùng hàm có tham số
PS x[10], y[5]={{3}, {5, 6}, 7, PS(2, 3)};

Cấu tử sao chép (Copy Constructor)
 Nhiệm vụ của hàm thiết lập sao chép là tạo ra một đối tượng giống hệt
một đối t
ượng đã có.
 Tạo đối tượng mới và sao chép nội dung của đối tượng cũ sang đối
tượng mới.
 ten_lop (const ten_lop &obj)
{
// phần thân của copy constructor
}

Huỷ tử (Destructor)
 Là phương thức dùng để huỷ bỏ đối tượng
 Chỉ có duy nhất một hàm hủy trong một lớp.
 Có tên trùng với tên lớp, có dấu ~ phía trước.
 Không có tham số.
 Không có kiểu trả về.
 Được gọi tự động khi đối tượng đi ra khỏi phạm vi:
– Kết thúc hàm
– Kết thúc chương trình
– Kết thúc một block
– Toán tử delete được gọi

Cấu tử, huỷ tử, cấu tử sao chép

2.4. Thành phần tĩnh, hàm bạn, lớp bạn
 Thành phần tĩnh:
– Thuộc tính tĩnh
– Phương thức tĩnh
 Hàm bạn, lớp bạn

2.4. Thành phần tĩnh, ...
 Thuộc tính tĩnh (static attribute) là những thuộc tính thuộc về bản
thân lớp chứ không thuộc về bất cứ thực thể nào của nó.
 1 thuộc tính tĩnh sẽ giống như 1 biến toàn thể, nghĩa là có thể
được truy cập từ bất cứ đâu trong đoạn mã
 Khai báo: thêm từ khoá static vào đầu dòng khai báo thuộc tính
 class Ten_Lop{
static int x;
int y;
public:
Ten_Lop(){...}
};
Khởi tạo giá trị thuộc tính static ở bên ngoài lớp
int Ten_Lop::x = 5;

2.4. Thành phần tĩnh, ...
 Phương thức tĩnh (static method) là những phương thức thuộc về
bản thân lớp chứ không thuộc về bất cứ thực thể nào của nó.
 Có thể coi là những hàm bình thường được xếp vào trong khai
báo lớp nhưng lại không tác động gì đến các thuộc tính của lớp.
class TenLop{
public:
TenLop();
static void phuongThuc();
};
void TenLop::phuongThuc(){
cout << "Xin chao !" << endl;
}
int main(){
TenLop::phuongThuc();
TenLop a;
a.phuongThuc(); //sai
return 0;
}

2.4. Thành phần tĩnh – ví dụ
#include <iostream>
using namespace std;
class PS{
public:
PS(int t, int m);
~PS();
static int soThucThe();
private:
int ts, ms;
static int soLuong;
};
int PS::soLuong = 0;
PS::PS(int t, int m) : ts(t), ms(m){
soLuong++;
}
PS::~PS(){
soLuong--;
}
int PS::soThucThe(){
return soLuong; //Tra ve gia trị cua bien dem
}
int main(){
PS x(1, 2);
PS y(3, 5);
cout << "Da tao ra " << PS::soThucThe() << " phan so." << endl;
return 0;
}

2.4. ...hàm bạn, lớp bạn
 Trong OOP, khái niệm quan hệ bạn ( friend ) nghĩa là trao quyền truy cập hoàn toàn tới tất
cả các thành viên của 1 lớp cho 1 hàm.
 Khi khai báo 1 hàm bạn đồng nghĩa với việc chúng ta hủy hoàn toàn tính đóng gói của lớp
bởi lẽ 1 đoạn mã bên ngoài lớp có thể dễ dàng thay đổi nội dung của lớp.
 Hàm tự do là bạn của lớp
 Hàm của lớp A là bạn của lớp B
 Lớp A là bạn của lớp B

2.4. ...hàm bạn, lớp bạn
 Khai báo
class A{
//nội dung của A
friend void fct();
};
void fct(){
//nội dung hàm fct
}
class B;
class A{
//nội dung của A
friend class B;
};
class B{
//nội dung của B
};

2.4. ...ví dụ
 Xây dựng lớp SV.
 Xây dựng hàm sắp xếp danh sách sv theo tên.

2.4. ...ví dụ
 Cách 1: dùng hàm bạn
#include <iostream>
class SV{
string ten;
int ma;
double d1, d2, d3;
public:
SV();
void nhap();
void in();
friend void sxep(SV a[], int spt);
};
void sxep(SV a[], int spt){
for(int i=0; i<spt-1; i++)
for(int j=i+1; j<spt; j++)
if(a[i].ten > a[j].ten)
{
SV tg=a[i];
a[i]=a[j];
a[j]=tg;
}
}
int main(){
SV a[100];
int spt;
//...
sxep(a, n);
//...
}

2.4. ...ví dụ
 Cách 2: dùng lớp bạn
#include <iostream>
class DSSV;
class SV{
string ten;
int ma;
double d1, d2, d3;
public:
SV();
void nhap();
void in();
friend class DSSV;
};
class DSSV{
int spt;
SV *a;
public:
void nhap();
void in();
void sxep();
};
void DSSV::sxep(){
for(int i=0; i<spt-1; i++)
for(int j=i+1; j<spt; j++)
if(a[i].ten > a[j].ten)
{
SV tg=a[i];
a[i]=a[j];
a[j]=tg;
}
}
int main(){
DSSV ds;
ds.nhap();
ds.sxep();
ds.in();
return 0;
}

2.5. Chồng toán tử (operator overloading)
 Khái niệm chồng (quá tải) toán tử
 Ưu nhược điểm của chồng toán tử
 Cách quá tải hàm toán tử
 Khả năng và giới hạn của chồng toán tử
 Ví dụ một số toán tử cơ bản

Khái niệm chồng toán tử
 Với biểu thức a+b, ký hiệu + tuỳ theo kiểu của a và b có thể biểu
thị:
– phép cộng hai số nguyên,
– phép cộng hai số thực độ chính xác đơn (float),
– phép cộng hai số thực chính xác đôi (double),
– phép cộng một số nguyên vào một con trỏ,
– Phép cộng 2 ma trận,
– Phép cộng 2 phân số,
– …

Khái niệm chồng toán tử
 Ví dụ: Xây dựng lớp PS có:
– Thuộc tính: ts, ms
– Phương thức: khởi tạo, nhập, xuất
– Hàm bạn: cong(PS a, PS b) - cộng 2 phân số
– hoặc phương thức cong(…) – cộng 2 phân số

class PS{
int ts, ms;
public:
PS(int t=1, int m=2){
ts=t;
ms=m;
}
void nhap();
void xuat();
friend PS cong(PS a, PS b);
};
PS cong(PS a, PS b)
{
PS c;
c.ts=a.ts*b.ms+a.ms*b.ts;
c.ms=a.ms*b.ms;
return c;
}
…
PS x , y(2, 3) , z(1, 5);
x = cong(y, z);
? x=y+z;

Ví dụ-lớp PS
class PS{
int ts, ms;
public:
ts=t;
ms=m;
}
void nhap();
void xuat();
friend PS operator+(PS a, PS b);
};
PS operator+(PS a, PS b)
{
PS c;
c.ms=a.ms*b.ms;
return c;
}
…
PS x, y(2, 3), z(1, 5);
x=y+z;//kết quả 13/15

 Xét biểu thức a+b
+ là toán tử
a, b là toán hạng
 Một số toán tử trong C++
– các toán tử toán học: +, -, *, /, %
– các toán tử quan hệ: >, <, >=, <=, ==, !=
– toán tử logic: !, &&, ||
– toán tử >>, <<
– toán tử -, ++, --
– toán tử new, delete, sizeof, ?:
– .v.v.

 Phân loại toán tử
– Toán tử một ngôi: -, ++, --, *, &, ~, !, sizeof (KIỂU)
– Toán tử 2 ngôi: +, -, *, /, >, <, ...
– Toán tử 3 ngôi: ?:

Các hàm được
định nghĩa
chồng
Các toán tử
cũng là các hàm
(hàm toán tử)
Chồng toán tử là gì?
Các toán tử
cũng được định
nghĩa chồng
Định nghĩa lại các
toán tử sao cho
chúng có thể thực
hiện với các toán
hạng khác nhau.

Ưu nhược điểm của chồng toán tử
 Làm cho các chương trình dễ viết hơn, cũng dễ hiểu hơn,
dễ bảo trì
 Có thể thay thế toán tử chồng bằng một hàm
 Chồng toán tử là cách duy nhất gọi một hàm KHÁC cách
gọi thông thường
– x=cong(y, z);
– x=y+z;

Ví dụ: Xây dựng lớp PS
 Cách 1: có hàm cong(PS a, PS b) để cộng phân số a
và phân số b
 Cách 2: toán tử + để cộng phân số a và phân số b

Quy tắc xây dựng hàm toán tử
 Hàm toán tử có thể được quá tải là phương thức của lớp hoặc hàm bạn:
– Nếu là phương thức thì số tham số của hàm bằng số ngôi của toán tử -1
– Nếu là hàm bạn thì số tham số của hàm bằng số ngôi
 Một trong số các toán hạng phải là đối tượng
 Khai báo: kiểu_hàm operator op(các tham số)
– op: là ký hiệu toán tử tương ứng
– operator: là từ khoá để khai báo hàm toán tử
– PS operator+(PS a, PS b);

Cách xây dựng
kiểu_hàm operator op (các tham số)
{
//nội dung hàm toán tử
}
op: toán tử cần quá tải (+, -, *, /, …)
Tên hàm Dùng để
operator+ định nghĩa phép +
operator* định nghĩa phép nhân *
operator/ định nghĩa phép chia /
operator+= định nghĩa phép tự cộng +=
operator!= định nghĩa phép so sánh khác nhau

Cách xây dựng
class PS{
int ts, ms;
public:
ts=t;
ms=m;
}
void nhap();
void xuat();
};
PS operator+(PS a, PS b)
{
PS c;
c.ts=a.ts*b.ms + a.ms*b.ts;
c.ms=a.ms*b.ms;
return c;
}
…
PS x, y(2, 3), z(1, 5);
Nguyên mẫu
Định nghĩa hàm
Gọi hàm
x=operator+(y, z);

Cách xây dựng
class PS{
int ts, ms;
public:
ts=t;
ms=m;
}
void nhap();
void xuat();
PS operator+(PS b);
};
PS PS::operator+(PS b)
{
PS c;
c.ts = this->ts * b.ms + this-> ms * b.ts;
c.ms = this->ms * b.ms;
return c;
}
…
PS x, y(2, 3), z(1, 5);
Nguyên mẫu
Định nghĩa hàm
Gọi hàm
x=y.operator+(z);

Cách xây dựng- dạng hàm bạn
class PS{
int ts, ms;
public:
…
friend PS operator-(PS a);
};
PS operator+(PS a, PS b){
PS c;
c.ms=a.ms*b.ms;
return c;
}
PS operator-(PS a){
a.ts=-a.ts;
return a;
}
…
x=y+z;//gọi hàm toán tử +
x=-t;//gọi hàm toán tử -
//x=operator+(y, z);
//x=operator-(t);

Cách xây dựng-dạng hàm của lớp
class PS{
int ts, ms;
public:
PS operator+(PS b);
PS operator-();
};
PS PS::operator+(PS b){
PS c;
c.ts=ts*b.ms+ms*b.ts;
c.ms=ms*b.ms;
return c;
}
PS PS::operator-(){
ts=-ts;
return *this;
}
…
x=y+z; //gọi hàm toán tử +
x=-t; //gọi hàm toán tử -
//x=y. operator+(z);
//x=t.operator-();

Quy tắc xây dựng
 Dạng phương thức: khuyết tham số thứ nhất (toán hạng thứ
nhất
 Toán hạng bên trái nhất của toán tử được overload phải là 1
đối tượng của kiểu class mà toán hạng khai báo.
 Toán hạng bên trái nhất trở thành tham số *this ngầm định.
Tất cả các toán hạng khác trở thành tham số hàm.

Khả năng và giới hạn của chồng toán tử
 Phần lớn toán tử trong C++ đều có thể định nghĩa chồng, trừ các toán tử:
“::”, “.”, “?:” “ sizeof”, …
 Chỉ có thể overload các toán tử đã tồn tại.
 Phải giữ được thứ tự ưu tiên và tính kết hợp của toán hạng được overload.
 Các toán tử sau : =, [ ], ( ), -> phải được quá tải thông qua hàm thành viên
 <<, >>: phải được quá tải thông qua hàm bạn
 ++ và -- cần hai hàm toán tử khác nhau cho mỗi phép toán

Một số ví dụ
 Quá tải toán tử so sánh
 Quá tải toán tử <<, >>
 Quá tải toán tử ++, --
 Quá tải toán tử =
 Quá tải toán tử [ ]
 Quá tải toán tử +=, -=, …

Quá tải toán tử so sánh (>, <, …)
class PS{
int ts, ms;
public:
PS(int t=1, int m=2){ts=t; ms=m;}
friend bool operator>(PS a, PS b);
friend bool operator==(PS a, PS b);
};
bool operator>(PS a, PS b){
return (float)a.ts/a.ms>(float)b.ts/b.ms;
}
bool operator==(PS a, PS b){
return (float)a.ts/a.ms==(float)b.ts/b.ms;
}
main(){
PS x(2, 3), y(1, 5);
if(x==y) //operator==(x, y)
cout<<"Hai ps bang nhau";
else
cout<<"Hai ps ko bang nhau";
}

Quá tải toán tử <<, >>
class PS{
…
friend istream &operator>>(istream &is, PS &x);
friend ostream &operator<<(ostream &os, PS &x);
};
istream &operator>>(istream &is, PS &x){
cout<<"Nhap tu so, mau so: ";
is>>x.ts>>x.ms;
return is;
}
ostream &operator<<(ostream &os, PS &x){
os<<x.ts<<"/"<<x.ms<<endl;
return os;
}
int main(){
PS a;
cout<<"Moi ban nhap dl:n";
cin>>a;
cout<<"nPhan so ban vua nhap: "<<a;
}

Qúa tải toán tử <<, >>
class NV{
private:
string ten;
int manv;
float hsl;
public:
NV(string name="", int ma=0,float hs=0){
ten=name;
manv=ma;
hsl=hs;
}
friend istream &operator>>(istream &is, NV &p);
friend ostream &operator<<(ostream &os, NV &p);
friend bool operator>(NV p, NV q);
friend class DSNV;
};
istream &operator>>(istream &is, NV &p){
is>>p.ten;
is>>p.manv;
is>>p.hsl;
return is;
}
ostream &operator<<(ostream &os, NV &p){
os<<p.ten<<“ ”
<<p.manv<<“ ”
<<p.hsl<<endl;
return os;
}
bool operator > (NV p, NV q){
return p.hsl>q.hsl;
}

Qúa tải toán tử <<, >>
class DSNV{
int snv;
NV *a;
public:
DSNV(int n=0){
snv=n;
a=NULL;
}
~DSNV(){
delete []a;
snv=0;
}
NV &operator[](int i){
return a[i];
}
friend istream &operator>>(istream &is, DSNV &p);
friend ostream &operator<<(ostream &os, DSNV &p);
void sxep();
};

Quá tải toán tử ++, --
 Toán tử ++ và – có 2 dạng sử dụng là đứng trước và đứng sau
toán hạng
 Ví dụ: ++a hoặc a++ (--a hoặc a--)
 Cần xây dựng 2 dạng hàm chồng cho mỗi toán tử trên
– operator++() cho dạng ++a
– operator++(int) cho dạng a++

Toán tử ++, --
#include<iostream>
class PS{
int ts, ms;
public:
ts=t;
ms=m;
}
friend istream &operator>>(istream &is, PS &p);
friend ostream &operator<<(ostream &os, PS &p);
PS& operator++();//++x
PS& operator++(int);//x++
};
PS& PS::operator++(){
++ts;
return *this;
}
//////////////////////////////////////
PS& PS::operator++(int){
static PS temp;
temp.ts=ts;
temp.ms=ms;
ts++;
return temp;
}

Toán tử ++, --
istream &operator>>(istream &is, PS &p){
cout<<"Nhap ts, ms: ";
is>>p.ts>>p.ms;
return is;
}
//////////////////////////////////////////////////////
ostream &operator<<(ostream &os, PS &p){
os<<p.ts<<"/"<<p.ms<<endl;
return os;
}
int main()
{
PS a(1,2);
cout<<a;
++a;
cout<<a;
a++;
cout<<a;
PS b;
b=a++;//b=3/2, a=4/2
cout<<"a= "<<a<<"b= "<<b;
PS c;
c = ++a;
cout<<"a= "<<a<<"c= "<<c;
}

Overload toán tử [ ]
Chỉ có thể overload toán tử [ ] thông qua hàm thành viên.
Lý do của việc hàm quá tải return một tham chiếu là vì vế trái của
toán tử gán ( = ) phải là một l-value.
Giá trị được return bằng tham chiếu hoặc con trỏ có thể là l-value
hoặc r-value. Giá trị được return bằng giá trị chỉ có thể là r-value.
l-value là 1 giá trị có địa chỉ.
Nên kiểm tra giá trị của index có ra ngoài phạm vi index của mảng
hay không.

Overload toán tử [ ]
class DS {
public:
float &operator [] (int index);
DS();
private:
float *a;
int spt;
};
float &DS::operator[] (int index) {
return (*this).(*(a+index));
}
float & operator[](int i) {
return a[i];
}

Qúa tải toán tử [ ] - Phải là hàm của lớp
class DS{
int spt;
PS *a;
public:
DS(int n=5){
spt=n;
a=new PS[spt];
}
friend istream &operator>>(istream &is, DS &p);
friend ostream &operator<<(ostream &os, DS &p);
//void sxep();
PS& operator[](int i);//phai la ham cua lop
DS& operator=(DS &b);//phai la ham cua lop
};
DS& DS::operator=(DS &b){
if(this==&b){cout<<"nHai dt la mot";}
else{
delete a;
a=new PS[spt=b.spt];
for(int i=0; i<spt; i++)
a[i]=b.a[i];
}
return *this;
}
///////////////////////////////////////
PS& DS::operator[](int i){
if(0<=i && i<spt) return a[i];
}

Quá tải toán tử [ ] - Phải là hàm của lớp
stream &operator>>(istream &is, DS &p){
cout<<"Nhap so phant tu: "; is>>p.spt;
p.a=new PS[p.spt];
for(int i=0; i<p.spt; i++)
is>>p[i];//is>>p.operator[](i);
return is;
}
///////////////////////////////////////
ostream &operator<<(ostream &os, DS &p){
for(int i=0; i<p.spt; i++)
os<<p[i];//os<<p.operator[](i);
return os;
}
int main(){
DS x;
cin>>x;
cout<<x;
cout<<"ps thu 3 "<<x[2];
}

class NV{
private:
string ten;
int manv;
float hsl;
public:
NV(string name="", int ma=0,float hs=0){
ten=name;
manv=ma;
hsl=hs;
}
friend istream &operator>>(istream &is, NV &p);
friend ostream &operator<<(ostream &os, NV &p);
friend bool operator>(NV p, NV q);
friend class DSNV;
};

class DSNV{
int snv;
NV *a;
public:
DSNV(int n=0){
snv=n;
a=NULL;
}
~DSNV(){
delete []a;
snv=0;
}
NV &operator[](int i){
return a[i];
}
friend istream &operator>>(istream &is, DSNV &p);
friend ostream &operator<<(ostream &os, DSNV &p);
void sxep();
};

Toán tử gán =
 A=B; // hiểu là A.operator=(B);
 B có thể là tham trị hoặc tham chiếu
 Việc truyền bằng tham trị đòi hỏi sự có mặt của hàm thiết lập sao
chép, hơn thế nữa sẽ làm cho chương trình chạy chậm vì mất thời
gian sao chép một lượng lớn dữ liệu.
 Vì vậy, b sẽ được truyền cho hàm operator= dưới dạng tham
chiếu.

Toán tử gán
DS &operator=(DS & p);//bổ sung vào khai báo lớp
DS &DS::operator=(DS &p) {
if (this !=&p){
delete v;
a=new float [spt=p.spt];
for(int i=0; i<n; i++) *(a+i)=p.(*(a+i));
}
else cout<<"Hai doi tuong la motn";
return *this;
}

Lớp_Đối tượng...............................

More Related Content

Similar to Lớp_Đối tượng............................... (20)

Lớp_Đối tượng...............................

Editor's Notes