Fungsi C++ terlebih beban dan menulis semula dan prinsip reka bentuk hierarki kelas

Pengenalan kepada Fungsi Lebih Muatan dan Penulisan Semula Fungsi terlebih muatan dan menulis semula dalam C++ membenarkan fungsi dengan nama yang sama mempunyai senarai parameter yang berbeza atau mengatasi fungsi dengan nama yang sama dalam kelas asas untuk mencapai kod yang lebih fleksibel dan boleh diperluas, mengikut prinsip penting seperti SRP, LSP, DIP).

C++ Overloading Fungsi, Penulisan Semula dan Prinsip Reka Bentuk Hierarki Kelas

Pengenalan

Fungsi lebihan beban dan penulisan semula Crushing adalah dua konsep asas dan program berasaskan C++ yang penting untuk pemahaman dan program berasaskan kelas Lebihan beban fungsi membenarkan fungsi dengan nama yang sama mempunyai senarai parameter yang berbeza, manakala menimpa fungsi membenarkan fungsi dalam kelas terbitan untuk mengatasi fungsi dengan nama yang sama dalam kelas asas. Konsep ini penting untuk mencipta asas kod yang fleksibel dan berskala.

Function Overloading

Function overloading membolehkan penciptaan fungsi dengan nama yang sama tetapi menerima senarai parameter yang berbeza. Ini berguna untuk mengendalikan jenis dan jumlah input yang berbeza. Sebagai contoh, fungsi berikut boleh dibuat untuk menambah dua int atau dua double: int 或两个 double：

int add(int a, int b) { return a + b; }
double add(double a, double b) { return a + b; }

当编译器看到 add 函数调用时，它将匹配最合适的重载版本。

函数重写

函数重写允许派生类中的函数覆盖基类中的同名函数。这用于在子类中修改或扩展基类行为。例如，以下基类和派生类重新定义了 print 函数：

class Base {
public:
    void print() { cout << "Base" << endl; }
};

class Derived : public Base {
public:
    void print() { cout << "Derived" << endl; }
};

当调用派生类中的 print 函数时，它将覆盖基类中的同名函数，从而打印 "Derived"。

类层次结构设计原则

在设计类层次结构时，以下原则非常重要：

• Liskov 替换原则（LSP）：子类应该随时可以替换其基类而不改变程序行为。
• 依赖倒置原则（DIP）：高层模块不应该依赖低层模块，它们应该依赖抽象。
• 单一职责原则（SRP）：每个类应该负责一个单一的职责。

函数重载和重写对于遵循这些原则至关重要。

实战案例

考虑一个图形应用程序，它需要处理不同形状的对象。可以使用基类 Shape 来表示所有形状，并使用派生类（如 Rectangle 和 Circle

class Shape {
public:
    virtual double area() = 0;
};

class Rectangle : public Shape {
public:
    Rectangle(double width, double height) : width(width), height(height) {}
    virtual double area() override { return width * height; }
private:
    double width, height;
};

class Circle : public Shape {
public:
    Circle(double radius) : radius(radius) {}
    virtual double area() override { return 3.14 * radius * radius; }
private:
    double radius;
};

Apabila pengkompil melihat panggilan fungsi add, Ia akan sepadan dengan versi terlebih muatan yang paling sesuai.

Fungsi mengatasi

Fungsi mengatasi membenarkan fungsi dalam kelas terbitan untuk mengatasi fungsi dengan nama yang sama dalam kelas asas. Ini digunakan untuk mengubah suai atau melanjutkan tingkah laku kelas asas dalam subkelas. Sebagai contoh, kelas asas dan terbitan berikut mentakrifkan semula fungsi print:

rrreee

Apabila fungsi print dalam kelas terbitan dipanggil, ia akan mengatasi fungsi yang sama nama dalam kelas asas , dengan itu mencetak "Derived". 🎜🎜🎜Prinsip Reka Bentuk Hierarki Kelas🎜🎜🎜Apabila mereka bentuk hierarki kelas, prinsip berikut adalah sangat penting: 🎜

• 🎜 Prinsip Penggantian Liskov (LSP): 🎜Sesuatu kelas harus sentiasa dapat menggantikan kelas asasnya tanpa Ubah tingkah laku program.
• 🎜Prinsip Penyongsangan Kebergantungan (DIP): 🎜Modul peringkat tinggi tidak boleh bergantung pada modul peringkat rendah, ia harus bergantung pada abstraksi.
• 🎜Prinsip Tanggungjawab Tunggal (SRP): 🎜Setiap kelas harus bertanggungjawab untuk satu tanggungjawab.

🎜Fungsi lebihan beban dan penulisan semula adalah penting untuk mengikuti prinsip ini. 🎜🎜🎜Kes Praktikal🎜🎜🎜Pertimbangkan aplikasi grafik yang perlu mengendalikan objek pelbagai bentuk. Anda boleh menggunakan kelas asas Shape untuk mewakili semua bentuk dan kelas terbitan seperti Rectangle dan Bulatan untuk mewakili bentuk tertentu. 🎜rrreee🎜 Kira luas bentuk yang berbeza dengan mudah dengan menggunakan penulisan semula fungsi. Dengan mengikuti prinsip SRP, setiap kelas mentakrifkan tanggungjawab khusus mereka. 🎜🎜🎜Kesimpulan🎜🎜🎜Fungsi berlebihan dan penulisan semula ialah konsep yang berkuasa dalam C++, dan ia penting untuk mereka bentuk kod yang fleksibel dan boleh skala. Mengikuti prinsip reka bentuk hierarki kelas memastikan penciptaan perisian yang teguh dan boleh diselenggara. 🎜

Atas ialah kandungan terperinci Fungsi C++ terlebih beban dan menulis semula dan prinsip reka bentuk hierarki kelas. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!