Câu 1:

a.

- Khái niệm: quá trình mà một lớp (class) có được các thuộc tính của một lớp
khác. Các thuộc tính đó có thể là một phương thức (method) hoặc một trường
(field) nào đó.
- Ưu điểm:
+ Tính kế thừa giúp tăng khả năng tái sử dụng.
+ Khả năng tái sử dụng nâng cao độ tin cậy.
+ Khi mã được tái sử dụng, sẽ giúp giảm chi phí phát triển và bảo trì.
+ Các lớp con sẽ tuân thủ theo một giao diện (interface) chuẩn
+ Tính kế thừa giúp hạn chế sự dư thừa mã và hỗ trợ khả năng mở rộng
mã.
+ Lập trình viên có điều kiện thuận lợi để tạo các thư viện lớp (class
libraries).
- Ví dụ:
class PhuongTien {
public:
string ThuongHieu = "Ford";
void TiengCoi() {
cout << "Tuut, tuut! \n" ;
}
};

class Oto: public PhuongTien {

public:
string Hieu = "Mustang";
};

b.

- thêm constructor (+A(){}), và sửa (A(int i)) thành (+A(int i){})

Câu 2:

- PhanSo.h

#pragma once

#include<iostream>
using namespace std;

class PhanSo

private:

int TuSo;

int MauSo;

public:

PhanSo();

PhanSo(int n);

PhanSo(int t, int m);

~PhanSo();

PhanSo operator + (const PhanSo& a);

friend PhanSo RutGon(PhanSo& a);

void Xuat()

};

- PhanSo.cpp

#include "PhanSo.h"

PhanSo::PhanSo()

TuSo = 0;

MauSo = 1;

PhanSo::PhanSo(int n)

TuSo = n;
 MauSo = 1;

PhanSo::PhanSo(int t, int m)

TuSo = t;

MauSo = m;

PhanSo::~PhanSo() {}

PhanSo PhanSo::operator+(const PhanSo& a)

PhanSo r{};

r.TuSo = TuSo * a.MauSo + MauSo * a.TuSo;

r.MauSo = MauSo * a.MauSo;

return RutGon(r);

int UCLN(int a, int b) {

if (b == 0) {

return fabs(a);

return UCLN(b, a % b);

PhanSo RutGon(PhanSo& a)

{
 int n = 1;

n = UCLN(a.TuSo, a.MauSo);

a.TuSo /= n;

a.MauSo /= n;

return a;

- Main

#include<iostream>

#include "PhanSo.h"

using namespace std;

void main()

PhanSo a;

PhanSo b(1, 2);

PhanSo c(3);

a = b + c;

a.Xuat();