Bài tập đa năng hóa toán tử số ảo năm 2024

Đã có app VietJack trên điện thoại, giải bài tập SGK, SBT Soạn văn, Văn mẫu, Thi online, Bài giảng....miễn phí. Tải ngay ứng dụng trên Android và iOS.

Theo dõi chúng tôi miễn phí trên mạng xã hội facebook và youtube:

Các bạn có thể mua thêm khóa học JAVA CORE ONLINE VÀ ỨNG DỤNG cực hay, giúp các bạn vượt qua các dự án trên trường và đi thực tập Java. Khóa học có giá chỉ 300K, nhằm ưu đãi, tạo điều kiện cho sinh viên cho thể mua khóa học.

Nội dung khóa học gồm 16 chuơng và 100 video cực hay, học trực tiếp tại https://www.udemy.com/tu-tin-di-lam-voi-kien-thuc-ve-java-core-toan-tap/ Bạn nào có nhu cầu mua, inbox trực tiếp a Tuyền, cựu sinh viên Bách Khoa K53, fb: https://www.facebook.com/tuyen.vietjack

Follow facebook cá nhân Nguyễn Thanh Tuyền https://www.facebook.com/tuyen.vietjack để tiếp tục theo dõi các loạt bài mới nhất về Java,C,C++,Javascript,HTML,Python,Database,Mobile.... mới nhất của chúng tôi.

long GetTime (void); // số giây tính từ nửa đêm void GetTime (int &hours=0, int &minutes=0, int &seconds=0);

̈ Số lượng ̈ Kiểu dữ liệu

n Có thể dùng đối số mặc định.

void main() { int h, m, s; long t = GetTime(); // Gọi hàm ??? GetTime(h, m, s); // Gọi hàm ??? }

̈ Thứ tự

Từng cặp hàm nào sau đây là đa năng hóa hàm. 1. void HV(int a, int b); 2. void HV(int *a, int *b); 3. void HV(int &a, int &b); Cặp hàm (1,2) Cặp hàm (2,3)

Đa năng hoá toán tử

n Định nghĩa các phép toán trên đối tượng.

n Các phép toán có thể tái định nghĩa:

Đơn hạng

• * ! ~ & ++ -- () -> -> new delete Nhị hạng
• / % & | ^{<< >> = += -= /= %= &= |=} = <<= >>= == != < > <= >= && || [] () ,

n Các phép toán không thể tái định nghĩa:

. .* :: ?: sizeof

Giới hạn của đa năng hoá toán tử

n toán tử gọi hàm () - là một toán tử nhiều ngôi.n Thứ tự ưu tiên của một toán tử không thể đượcthay đổi bởi đa năng hóa.n Tính kết hợp của một toán tử không thể được thayđổi bởi đa năng hóa. Các tham số mặc định khôngthể sử dụng với một toán tử đa năng hóa.n Không thể thay đổi số các toán hạng mà một toántử yêu cầu.n Không thể thay đổi ý nghĩa của một toán tử làmviệc trên các kiểu có sẵn.n Không thể dùng đối số mặc định.

Đa năng hoá toán tử

####### n Khai báo và định nghĩa toán tử thực chất không khác với

####### việc khai báo và định nghĩa nghĩa một loại hàm bất kỳ

####### nào khác

####### n sử dụng tên hàm là "operator @" cho toán tử "@"

̈ để overload phép "+", ta dùng tên hàm "operator +"

####### n Số lượng tham số tại khai báo phụ thuộc hai yếu tố:

̈ Toán tử là toán tử đơn hay đôi ̈ Toán tử được khai báo là hàm toàn cục hay phương thức của lớp aa@bb aa@(bb) hoặc operator@(aa,bb) @aa aa@( ) hoặc operator@(aa) aa@ aa@(int) hoặc operator@(aa,int) Là phương thức của lớp Là hàm toàn cục

Đa năng hoá toán tử

####### n Ví dụ: Sử dụng toán tử "+" để cộng hai đối

####### tượng lớp Complex và trả về kết quả là

####### một Complex

̈ Ta có thể khai báo hàm toàn cục sau const Complex operator+(const Complex& num1, const Complex& num2); n "x+y" sẽ được hiểu là "operator+(x,y)" n dùng từ khoá const để đảm bảo các toán hạng gốc không bị thay đổi ̈ Hoặc khai báo toán tử dưới dạng thành viên của Complex: const Complex operator+(const Complex& num); n đối tượng chủ của phương thức được hiểu là toán hạng thứ nhất của toán tử. n "x+y" sẽ được hiểu là "x+(y)" Complex x(5); Complex y(10); ... z = x + y;

Đa năng hoá toán tử bằng hàm thành viên

n Khi đa năng hóa (), [], -> hoặc =, hàm toán tử phải được khai báo là hàm thành viên của lớp n Toán tử một ngôi hàm không có tham số, toán tử 2 ngôi hàm sẽ có 1 tham số class Point { public: Point (int x, int y) { Point::x = x; Point::y = y; } Point operator + (Point &p) { return Point(x + p,y + p); } Point operator - (Point &p) { return Point(x - p, y - p); } private: int x, y; }; void main() { Point p1(10,20), p2(10,20); Point p3 = p1 + p2; Point p4 = p1 - p2; Point p5 = p3 + (p4); Point p6 = p3 – (p4); }; Có 1 tham số (Nếu là toán tử hai ngôi)

n a @ b: a @(b)

n x @ b: với x là thuộc kiểu float, int, ...

không thuộc kiểu lớp đang định nghĩa

̈operator @ (x, b)Đa năng hoá toán tử bằng hàm thành viên

Đa năng hoá toán tử bằng hàm toàn cục

####### n Nếu toán hạng cực trái của toán tử là đối tượng thuộc lớp

####### khác hoặc thuộc kiểu dữ liệu có sẵn

̈ thường khai báo friend class Point { public: Point (int x, int y) { Point::x = x; Point::y = y; } friend Point operator + (Point &p, Point &q); friend Point operator - (Point &p, Point &q) ; private: int x, y; }; Point operator + (Point &p, Point &q) {return Point(p + q,p + q); } Point operator - (Point &p, Point &q) {return Point(p - q,p - q); } void main() { Point p1(10,20), p2(10,20); Point p3 = p1 + p2; Point p4 = p1 - p2; Point p5 =operator + (p3, p4); Point p6 = operator – (p3, p4); }; Có 2 tham số (Nếu là toán tử hai ngôi)

Đa năng hoá toán tử bằng hàm toàn cục

n Ví dụ về phép cộng cho Complex, ta có thể khaibáo hàm định nghĩa phép cộng tại mức toàn cục:

const Complex operator+(const Complex& num1, const Complex& num2);

n Khi đó, ta có thể định nghĩa toán tử đó như sau:

const Complex operator+(const Complex& num1,const Complex& num2) { Complex result(num1 + num2); return result; }

n Giải pháp: dùng hàm friend

####### ̈ friend cho phép một lớp cấp quyền truy nhập tới các

####### phần nội bộ của lớp đó cho một số cấu trúc được chọn

Truy nhập các thành viên private value

####### n Để khai báo một hàm là friend của một lớp, ta phải khai

####### báo hàm đó bên trong khai báo lớp và đặt từ khoá friend

####### lên đầu khai báo.

####### n Lưu ý: tuy khai báo của hàm friend được đặt trong khai

####### báo lớp và hàm đó có quyền truy nhập ngang với các

####### phương thức của lớp, hàm đó không phải phương thức

####### của lớp

class Complex { public: Complex(int value = 0); ~Complex(); ... friend const Complex operator + (const Complex& num1, const Complex& num2); ... };

Đa năng hoá toán tử bằng hàm toàn cục

####### n Không cần thêm sửa đổi gì cho định nghĩa của hàm đã

####### được khai báo là friend.

̈ Định nghĩa trước của phép cộng vẫn giữ nguyên const Complex operator+(const Complex& num1, const Complex& num2) { Complex result(num1 + num2); return result; }

Đa năng hoá toán tử bằng hàm toàn cục

Khi nào dùng toán tử toàn cục?

####### n Đối với toán tử được khai báo là phương thức của lớp,

####### đối tượng chủ (xác định bởi con trỏ this) luôn được hiểu

####### là toán hạng đầu tiên (trái nhất) của phép toán.

̈ Nếu muốn dùng cách này, ta phải được quyền bổ sung phương thức vào định nghĩa của lớp/kiểu của toán hạng trái

####### n Không phải lúc nào cũng có thể overload toán tử bằng

####### phương thức

̈ phép cộng giữa Complex và float cần cả hai cách Complex + float và float+ Complex ̈ cout << obj; ̈ không thể sửa định nghĩa kiểu int hay kiểu của cout ̈ lựa chọn duy nhất: đa năng hoá toán tử bằng hàm toàn cục

Đa năng hoá toán tử xuất <<

####### n prototype như thế nào? xét ví dụ:

̈ cout << num; // num là đối tượng thuộc lớp Complex

####### n Toán hạng trái cout thuộc lớp ostream, không thể sửa

####### định nghĩa lớp này nên ta overload bằng hàm toàn cục

̈ Tham số thứ nhất : tham chiếu tới ostream ̈ Tham số thứ hai : kiểu Complex, n const (do không có lý do gì để sửa đối tượng được in ra) ̈ giá trị trả về: tham chiếu tới ostream (để thực hiện được cout << num1 << num2;)

####### n Kết luận:

ostream& operator<<(ostream& out, const Complex& num)

Đa năng hoá toán tử xuất <<

####### n Khai báo toán tử được overload là friend của lớp Complex

class Complex { public: Complex(float R = 0, float I = 0); ~Complex(); ... friend ostream& operator<<( ostream& out, const Complex& num); ... };

####### n Định nghĩa toán tử

ostream& operator<<(ostream& out, const Complex& num) { out << “(“<

Đa năng hoá toán tử nhập >>

n prototype như thế nào? xét ví dụ:

####### ̈ cin >> num; // num là đối tượng thuộc lớp Complex

n Toán hạng trái cin thuộc lớp istream, không thể

sửa định nghĩa lớp này nên ta overload bằng hàmtoàn cục

####### ̈ Tham số thứ nhất : tham chiếu tới istream

####### ̈ Tham số thứ hai : kiểu Complex,

####### ̈ giá trị trả về: tham chiếu tới istream

####### (để thực hiện được cin >> num1 >> num2;)

n Kết luận:

####### istream& operator>>(istream& in, Complex& num)

Đa năng hoá toán tử nhập>>

####### n Khai báo toán tử được overload là friend của lớp Complex

class Complex { public: Complex(float R = 0, float I = 0); ~Complex(); ... friend istream& operator>>( istream& in, Complex& num); ... };

####### n Định nghĩa toán tử

istream& operator>>(istream& in, Complex& num) { cout<<“Nhap phan thuc:”; in >> num; cout<<“Nhap phan ao:”; in >> num; return in; // Return a reference to the modified stream };

Đa năng hoá toán tử [ ]

####### n Thông thường để xuất ra giá trị của 1 phần tử tại vị trí

####### cho trước trong đối tượng.

####### n Định nghĩa là hàm thành viên.

####### n Để hàm toán tử [ ] có thể đặt ở bên trái của phép gán

####### thì hàm phải trả về là một tham chiếu

class Vector { private: int Size; int *Data; public: Vector(int S = 2, int V = 0); ~Vector(); void Print() const; int & operator [ ] (int i); }; int& Vector::operator [] (int i) { static int tam = 0; return (i > 0) && (I < Size)? Data[i] : tam; }

Đa năng hoá toán tử [ ]

####### n Ví dụ:

class Vector { private: int Size;int Data; public: Vector(int S = 2,int V = 0); ~Vector(); void Print() const; int & operator [ ] (int i); }; int& Vector::operator [ ] (int i) { static int tam = 0; return ( i > 0) && (i < Size)? Data[i] : tam; } ... int main() { Vector V(5,1); V(); for(int I=0;I<5;++I) V[I]=(I+1); V(); V[0]=10;V V(); return 0; }

Đa năng hoá toán tử ()

n Định nghĩa là hàm thành viên.

class Matrix { public: Matrix (const short rows, const short cols); ~Matrix (void) {delete elems;} double& operator () (const short row, const short col); friend ostream& operator << (ostream&, Matrix&); friend Matrix operator + (Matrix&, Matrix&); friend Matrix operator - (Matrix&, Matrix&); friend Matrix operator * (Matrix&, Matrix&); private: const short rows; // số hàng const short cols; // số cột double *elems; // các phần tử }; double& Matrix::operator () (const short row, const short col) { static double dummy = 0; return (row >= 0 && row < rows && col >= 0 && col < cols) ? elems[row *cols

• col] : dummy; } void main() { Matrix m(3,2); m(1,1) = 10; m(1,2) = 20; m(2,1) = 30; m(2,2) = 40; m(3,1) = 50; m(3,2) = 60; cout<

Chuyển kiểu

n Muốn thực hiện các phép cộng:

void main() { Point p1(10,20), p2(30,40), p3, p4, p5; p3 = p1 + p2; p4 = p1 + 5; p5 = 5 + p1; };

Có thể định nghĩa thêm 2 toán tử:

class Point { //... friend Point operator + (Point, Point); friend Point operator + (int, Point); friend Point operator + (Point, int); };

Chuyển kiểu (tt)

void main() { Point p1(10,20), p2(30,40), p3, p4, p5; p3 = p1 + p2; p4 = p1 + 5; // tương đương p1 + Point(5) p5 = 5 + p1; // tương đương Point(5) + p1 } class Point { //... Point (int x) { Point::x = Point::y = x; } friend Point operator + (Point, Point); }; Chuyển kiểu 5 ó Point(5)

n Chuyển đổi kiểu: ngôn ngữ định nghĩa sẵn.

Định nghĩa phép chuyển đổi kiểu

Chuyển kiểu (tt)

n Một toán tử chuyển đổi kiểu có thể được sửdụng để chuyển đổi một đối tượng của một lớpthành đối tượng của một lớp khác hoặc thànhmột đối tượng của một kiểu có sẵn.n Định nghĩa là hàm thành viên không tĩnh vàkhông là hàm friend.n Prototype của hàm thành viên này có cúpháp:

####### ̈operator ();

Chuyển kiểu (tt)

class Number { private: float Data; public: Number(float F = 0) { Data = F; } operator float() { return Data; } operator int() { return (int)Data;} }; int main() { Number N1(9), N2(2); float X = (float)N1; //Gọi operator float() cout << X << endl; int Y = (int)N2; //Gọi operator int() cout << Y << endl; Number Z = 3; return 0; }

Ví dụ:

Khởi tạo ngầm định

n Được định nghĩa sẵn trong ngôn ngữ:

####### VD: Point p1(10,20); Point p2 = p1;

n Sẽ gây ra lỗi (kết quả SAI) khi bên trong đối tượngcó thành phần dữ liệu là con trỏ.

####### VD: Matrix m(5,6); Matrix n = m;

Lỗi sẽ xảy ra do khởi tạo ngầm bằng cách gán tương ứng từng thành phần.

Khởi tạo ngầm định (tt)

Khi lớp có thành phần dữ liệu con trỏ,phải định nghĩa hàm xây dựng sao chép

class Point { int x, y; public: Point (int =0; int =0 ); // Khong can thiet DN Point (const Point& p) { x= p; y = p; } // ........... }; // ............... class Matrix { //.... Matrix(const Matrix&); }; Matrix::Matrix (const Matrix &m) : rows(m), cols(m) { int n = rows * cols; elems = new double[n]; // cùng kích thước for (register i = 0; i < n; ++i) // sao chép phần tử elems[i] = m[i]; }

Gán ngầm định

n Được định nghĩa sẵn trong ngôn ngữ:

####### ̈ Gán tương ứng từng thành phần.

####### ̈ Đúng khi đối tượng không có dữ liệu con trỏ.

####### VD: Point p1(10,20); Point p2; p2 = p1;

n Khi thành phần dữ liệu có con trỏ, bắt buộc phảiđịnh nghĩa phép gán = cho lớp.

class Matrix { //.... const Matrix& operator = (const Matrix &m) { if (rows == m && cols == m) { // phải khớp int n = rows * cols; for (register i = 0; i < n; ++i) // sao chép các phần tử elems[i] = m[i]; } return *this; } }; Hàm thành viên

Phép gán =

####### n Một trong những toán tử hay được overload nhất

̈ Cho phép gán cho đối tượng này một giá trị dựa trên một đối tượng khác ̈ Copy constructor cũng thực hiện việc tương tự, cho nên, định nghĩa toán tử gán gần như giống hệt định nghĩa của copy constructor

####### n Ta có thể khai báo phép gán cho lớp MyNumber như sau:

####### const MyNumber& operator=(const MyNumber& num);

̈ Phép gán nên luôn luôn trả về một tham chiếu tới đối tượng đích (đối tượng được gán trị cho) ̈ Tham chiếu được trả về phải là const để tránh trường hợp a bị thay đổi bằng lệnh "(a = b) = c;" (lệnh đó không tương thích với định nghĩa gốc của phép gán)

Phép gán "="

####### n Định nghĩa trên có thể dùng cho phép gán

̈ Lệnh if dùng để ngăn chặn các vấn để có thể nảy sinh khi một đối tượng được gán cho chính nó (thí dụ khi sử dụng bộ nhớ động để lưu trữ các thành viên) ̈ Ngay cả khi gán một đối tượng cho chính nó là an toàn, lệnh if trên đảm bảo không thực hiện các công việc thừa khi gán const MyNumber& MyNumber::operator=(const MyNumber& num) { if (this != &num) { this->value = num; } return *this; }

Phép gán "="

n Khi nói về copy constructor, ta đã biết rằng C++luôn cung cấp một copy constructor mặc định,nhưng nó chỉ thực hiện sao chép đơn giản (saochép nông)n Đối với phép gán cũng vậy → chỉ cần định nghĩalại phép gán nếu:

####### ̈ Ta cần thực hiện phép gán giữa các đối tượng

####### ̈ Phép gán nông (memberwise assignment) không đủ

####### dùng vì

n Cần sao chép sâu - chẳng hạn sử dụng bộ nhớ động n Khi sao chép đòi hỏi cả tính toán - chẳng hạn gán một số hiệu có giá trị duy nhất hoặc tăng số đếm

Đa năng hoá toán tử ++ & --

n Toán tử ++ (hoặc toán tử --) có 2 loại:

####### ̈ Tiền tố: ++n

####### ̈ Hậu tố: n++

####### (Hàm toán tử ở dạng hậu tố có thêm đối số giả kiểu int)

Đa năng hoá toán tử ++ & --

n Phép tăng ++

####### ̈ giá trị trả về

n tăng trước num ̈ trả về tham chiếu (MyNumber &) ̈ giá trị trái - lvalue (có thể được gán trị) n tăng sau num ̈ trả về giá trị (giá trị cũ trước khi tăng) ̈ trả về đối tượng tạm thời chứa giá trị cũ. ̈ giá trị phải - rvalue (không thể làm đích của phép gán)

####### ̈ prototype

n tăng trước: MyNumber& MyNumber::operator++() n tăng sau: const MyNumber MyNumber::operator++(int)

Đa năng hoá toán tử ++ & --

n Nhớ lại rằng phép tăng trước tăng giá trị trước khi trả kết quả, trong khi phép tăng sau trả lại giá trị trước khi tăng n Ta định nghĩa từng phiên bản của phép tăng như sau: MyNumber& MyNumber::operator++() { // Prefix this->value++; // Increment value return *this; // Return current MyNumber } const MyNumber MyNumber::operator++(int) { // Postfix MyNumber before(this->value); // Create temporary MyNumber // with current value this->value++; // Increment value return before; // Return MyNumber before increment } before là một đối tượng địa phương của phương thức và sẽ chấm dứt tồn tại khi lời gọi hàm kết thúc Khi đó, tham chiếu tới nó trở thành bất hợp lệ Không thể trả về tham chiếu

Tham số và kiểu trả về

n Cũng như khi overload các hàm khác, khi

overload một toán tử, ta cũng có nhiều lựa

chọn về việc truyền tham số và kiểu trả về

̈chỉ có hạn chế rằng ít nhất một trong cáctham số phải thuộc kiểu người dùng tự địnhnghĩa

n Ở đây, ta có một số lời khuyên về các lựa

chọn

Tham số và kiểu trả về

n Các toán hạng:

####### ̈ Nên sử dụng tham chiếu mỗi khi có thể (đặc biệt là khi

####### làm việc với các đối tượng lớn)

####### ̈ Luôn luôn sử dụng tham số là hằng tham chiếu khi đối

####### số sẽ không bị sửa đổi

bool String::operator==(const String &right) const n Đối với các toán tử là phương thức, điều đó có nghĩa ta nên khai báo toán tử là hằng thành viên nếu toán hạng đầu tiên sẽ không bị sửa đổi n Phần lớn các toán tử (tính toán và so sánh) không sửa đổi các toán hạng của nó, do đó ta sẽ rất hay dùng đến hằng tham chiếu

Tham số và kiểu trả về

n Giá trị trả về

####### ̈ không có hạn chế về kiểu trả về đối với toán tử được

####### overload, nhưng nên cố gắng tuân theo tinh thần của

####### các cài đặt có sẵn của toán tử

n Ví dụ, các phép so sánh (==, !=...) thường trả về giá trị kiểu bool, nên các phiên bản overload cũng nên trả về bool

####### ̈ là tham chiếu (tới đối tượng kết quả hoặc một trong

####### các toán hạng) hay một vùng lưu trữ mới

####### ̈ Hằng hay không phải hằng

Tham số và kiểu trả về

n Giá trị trả về ...

####### ̈ Các toán tử sinh một giá trị mới cần có kết quả trả về là

####### một giá trị (thay vì tham chiếu), và là const (để đảm bảo

####### kết quả đó không thể bị sửa đổi như một l-value)

n Hầu hết các phép toán số học đều sinh giá trị mới n ta đã thấy, các phép tăng sau, giảm sau tuân theo hướng dẫn trên

####### ̈ Các toán tử trả về một tham chiếu tới đối tượng ban đầu

####### (đã bị sửa đổi), chẳng hạn phép gán và phép tăng trước,

####### nên trả về tham chiếu không phải là hằng

n để kết quả có thể được tiếp tục sửa đổi tại các thao tác tiếp theo const MyNumber MyNumber::operator+(const MyNumber& right) const MyNumber& MyNumber::operator+=(const MyNumber& right)

Tham số và kiểu trả về

n Xem lại cách ta đã dùng để trả về kết quả của toántử:

const MyNumber MyNumber::operator+(const MyNumber& num) { MyNumber result(this->value + num); return result; }

n Cách trên không sai, nhưng C++ cung cấp mộtcách hiệu quả hơn

const MyNumber MyNumber::operator+(const MyNumber& num) { return MyNumber(this->value + num); } 1. Gọi constructor để tạo đối tượng result 2. Gọi copy-constructor để tạo bản sao dành cho giá trị trả về khi hàm thoát 3. Gọi destructor để huỷ đối tượng result

Tham số và kiểu trả về

####### n Cú pháp của ví dụ trước tạo một đối tượng tạm thời

####### (temporary object)

####### n Khi trình biên dịch gặp đoạn mã này, nó hiểu đối tượng được

####### tạo chỉ nhằm mục đích làm giá trị trả về, nên nó tạo thẳng

####### một đối tượng bên ngoài (để trả về) - bỏ qua việc tạo và huỷ

####### đối tượng bên trong lời gọi hàm

####### n Chỉ có một lời gọi duy nhất đến constructor của MyNumber

####### (không phải copy-constructor) thay vì dãy lời gọi trước

####### n Quá trình này được gọi là tối ưu hoá giá trị trả về

####### n Ghi nhớ: quá trình này không chỉ áp dụng được đối với các

####### toán tử → sử dụng mỗi khi tạo một đối tượng chỉ để trả về

return MyNumber(this->value + num);

Đa năng hoá new & delete

####### n Hàm new và delete mặc định của ngôn ngữ:

̈ Nếu đối tượng kích thước nhỏ, có thể sẽ gây ra quá nhiều khối nhỏ => chậm. ̈ Không đáng kể khi đối tượng có kích thước lớn.

####### => Toán tử new và delete ít được tái định nghĩa.

####### n Có 2 cách đa năng hóa toán tử new và delete

̈ có thể đa năng hóa một cách toàn cục nghĩa là thay thế hẳn các toán tử new và delete mặc định. ̈ Đa năng hóa các toán tử new và delete với tư cách là hàm thành viên của lớp nếu muốn các toán tử new và delete áp dụng đối với lớp đó. n Khi chúng ta dùng new và delete đối với lớp nào đó, trình biên dịch sẽ kiểm tra xem new và delete có được định nghĩa riêng cho lớp đó hay không; nếu không thì dùng new và delete toàn cục (có thể đã được đa năng hóa).

Đa năng hoá new & delete

n Hàm toán tử của toán tử new và delete cóprototype như sau:

####### void * operator new(size_t size);

####### void operator delete(void * ptr);

####### ̈ Trong đó tham số kiểu size_t được trình biên dịch

####### hiểu là kích thước của kiểu dữ liệu được trao cho

####### toán tử new.

n Ví dụ:

####### ̈ Đa năng hóa toán tử new và delete toàn cục

####### ̈ Đa năng hóa toán tử new và delete cho một lớp

Bài tập

n Bài tập 4:

Bổ sung vào lớp phân số những phương thức sau: (Nhóm tạo hủy) n Khởi tạo mặc định phân số = 0. n Khởi tạo với tử và mẫu cho trước. n Khởi tạo từ giá trị nguyên cho trước. n Khởi tạo từ một phân số khác. (Nhóm toán tử) n Toán tử số học: +, -, *, /, =, +=, -=. n Toán tử so sánh: >, <, ==, >=, <=, !=. n Toán tử một ngôi: ++, -- (tăng, giảm 1). n Toán tử ép kiểu: (float), (int). n Toán tử nhập, xuất: >>, <<.

Bài tập

n Bài tập 4:

Bổ sung vào lớp số phức những phương thức sau: (Nhóm tạo hủy) n Khởi tạo mặc định số phức = 0. n Khởi tạo với phần thực và phần ảo cho trước. n Khởi tạo từ giá trị thực cho trước. n Khởi tạo từ một số phức khác. (Nhóm toán tử) n Toán tử số học: +, -, *, /, =, +=, -=. n Toán tử so sánh: >, <, ==, >=, <=, !=. n Toán tử một ngôi: ++, -- (tăng, giảm 1). n Toán tử ép kiểu: (float), (int). n Toán tử nhập, xuất: >>, <<.

Bài tập

n Bài tập 4:

Bổ sung vào lớp đơn thức những phương thức sau: (Nhóm tạo hủy) n Khởi tạo mặc định đơn thức = 0. n Khởi tạo với hệ số và số mũ cho trước. n Khởi tạo từ một đơn thức khác. (Nhóm toán tử) n Toán tử số học: +, -, *, /, =, +=, -=. n Toán tử so sánh: >, <, ==, >=, <=, !=. n Toán tử một ngôi: ̈ ++, -- (tăng, giảm bậc). ̈! (đạo hàm), ~ (nguyên hàm). n Toán tử nhập, xuất: >>, <<.

Bài tập

n Bài tập 4:

Bổ sung vào lớp học sinh những phương thức sau: (Nhóm tạo hủy) n Khởi tạo với họ tên và điểm văn, toán cho trước. n Khởi tạo với họ tên cho trước, điểm văn, toán = 0. n Khởi tạo từ một học sinh khác. n Hủy đối tượng học sinh, thu hồi bộ nhớ. (Nhóm toán tử) n Toán tử so sánh (ĐTB): >, <, ==, >=, <=, !=. n Toán tử gán: =. n Toán tử nhập, xuất: >>, <<.

Bài tập

n Bài tập 4:

Bổ sung vào lớp mảng những phương thức sau: (Nhóm tạo hủy) n Khởi tạo mặc định mảng kích thước = 0. n Khởi tạo với kích thước cho trước, các phần tử = 0. n Khởi tạo từ một mảng int [ ] với kích thước cho trước. n Khởi tạo từ một đối tượng IntArray khác. n Hủy đối tượng mảng, thu hồi bộ nhớ. (Nhóm toán tử) n Toán tử gán: =. n Toán tử lấy phần tử: [ ]. n Toán tử ép kiểu: (int *). n Toán tử nhập, xuất: >>, <<.