Share abstract class in c++,

[trandiepobjects]

#C ++, #abstract Class, #oop, #InerItance, #polymorphism ## Lớp trừu tượng trong C ++

Một lớp trừu tượng là một lớp được tuyên bố nhưng không được xác định.Nó chỉ chứa tuyên bố của các thành viên, nhưng không phải là triển khai của họ.Việc thực hiện các thành viên được cung cấp bởi các lớp dẫn xuất.Các lớp trừu tượng được sử dụng để xác định một giao diện chung cho một tập hợp các lớp liên quan.

## Tại sao sử dụng các lớp trừu tượng?

Có một số lý do tại sao bạn có thể muốn sử dụng một lớp trừu tượng:

* Để xác định một giao diện chung cho một tập hợp các lớp liên quan.Điều này có thể giúp viết mã dễ dàng hơn hoạt động với các đối tượng thuộc các loại khác nhau.
* Để thực thi các ràng buộc nhất định đối với các lớp dẫn xuất.Ví dụ: bạn có thể yêu cầu tất cả các lớp dẫn xuất thực hiện một phương pháp nhất định.
* Để cung cấp các triển khai mặc định của các phương thức có thể được ghi đè bởi các lớp dẫn xuất.

## Cách sử dụng các lớp trừu tượng trong C ++

Để tạo một lớp trừu tượng, bạn sử dụng từ khóa 'trừu tượng` trong khai báo lớp.Ví dụ:

`` `C ++
lớp động vật {
công cộng:
khoảng trống ảo speak () = 0;// chức năng ảo thuần túy
};
`` `

Phương thức `speak ()` là một hàm ảo thuần túy, có nghĩa là nó phải được thực hiện trong các lớp dẫn xuất.

Để tạo một lớp dẫn xuất từ một lớp trừu tượng, bạn sử dụng từ khóa `extends`.Ví dụ:

`` `C ++
Lớp học mở rộng động vật {
công cộng:
void speak () {
cout << "Woof!"<< Endl;
}
};
`` `

Lớp `Dog` kế thừa phương thức` speak () `từ lớp` động vật`.

## Ví dụ

Ví dụ sau đây cho thấy cách sử dụng một lớp trừu tượng để xác định giao diện chung cho một tập hợp các lớp liên quan.

`` `C ++
#include <Istream>

sử dụng không gian tên STD;

// Lớp trừu tượng
Hình dạng lớp {
công cộng:
Double getArea () = 0;// chức năng ảo thuần túy
};

// Lớp cụ thể có nguồn gốc từ hình dạng
Vòng tròn lớp: hình dạng công khai {
riêng tư:
Bán kính gấp đôi;

công cộng:
Vòng tròn (bán kính đôi) {
this-> bán kính = bán kính;
}

kép getarea () {
Trả về 3.14 * Bán kính * Bán kính;
}
};

// Lớp cụ thể có nguồn gốc từ hình dạng
lớp hình chữ nhật: hình dạng công khai {
riêng tư:
chiều rộng gấp đôi;
chiều cao gấp đôi;

công cộng:
Hình chữ nhật (chiều rộng gấp đôi, chiều cao gấp đôi) {
this-> chiều rộng = chiều rộng;
this-> chiều cao = chiều cao;
}

kép getarea () {
Trả về chiều rộng * chiều cao;
}
};

int main () {
// Tạo một đối tượng vòng tròn
Vòng tròn (10.0);

// Nhận diện tích của vòng tròn
diện tích kép = circle.getArea ();

// In khu vực của vòng tròn
cout << "Khu vực của vòng tròn là" << khu vực << endl;

// Tạo một đối tượng hình chữ nhật
Hình chữ nhật hình chữ nhật (10.0, 20.0);

// Nhận diện tích hình chữ nhật
khu vực = hình chữ nhật.getarea ();

// In diện tích hình chữ nhật
cout << "Diện tích của hình chữ nhật là" << khu vực << endl;

trả lại 0;
}
`` `

## hashtags

* #C ++
* Lớp #abstract
* #oop
* #Di sản
* #polymorphism
=======================================
#C++, #abstract Class, #oop, #Inheritance, #polymorphism ## Abstract Class in C++

An abstract class is a class that is declared but not defined. It contains only the declaration of the members, but not their implementations. The implementation of the members is provided by the derived classes. Abstract classes are used to define a common interface for a set of related classes.

## Why use abstract classes?

There are several reasons why you might want to use an abstract class:

* To define a common interface for a set of related classes. This can make it easier to write code that works with objects of different types.
* To enforce certain constraints on the derived classes. For example, you can require that all derived classes implement a certain method.
* To provide default implementations of methods that can be overridden by the derived classes.

## How to use abstract classes in C++

To create an abstract class, you use the `abstract` keyword in the class declaration. For example:

```c++
class Animal {
public:
virtual void speak() = 0; // pure virtual function
};
```

The `speak()` method is a pure virtual function, which means that it must be implemented in the derived classes.

To create a derived class from an abstract class, you use the `extends` keyword. For example:

```c++
class Dog extends Animal {
public:
void speak() {
cout << "Woof!" << endl;
}
};
```

The `Dog` class inherits the `speak()` method from the `Animal` class.

## Example

The following example shows how to use an abstract class to define a common interface for a set of related classes.

```c++
#include <iostream>

using namespace std;

// Abstract class
class Shape {
public:
virtual double getArea() = 0; // pure virtual function
};

// Concrete class derived from Shape
class Circle : public Shape {
private:
double radius;

public:
Circle(double radius) {
this->radius = radius;
}

double getArea() {
return 3.14 * radius * radius;
}
};

// Concrete class derived from Shape
class Rectangle : public Shape {
private:
double width;
double height;

public:
Rectangle(double width, double height) {
this->width = width;
this->height = height;
}

double getArea() {
return width * height;
}
};

int main() {
// Create a Circle object
Circle circle(10.0);

// Get the area of the circle
double area = circle.getArea();

// Print the area of the circle
cout << "The area of the circle is " << area << endl;

// Create a Rectangle object
Rectangle rectangle(10.0, 20.0);

// Get the area of the rectangle
area = rectangle.getArea();

// Print the area of the rectangle
cout << "The area of the rectangle is " << area << endl;

return 0;
}
```

## Hashtags

* #C++
* #abstract Class
* #oop
* #Inheritance
* #polymorphism