Bagaimanakah Mixin Boleh Memanjangkan Fungsi Kelas Tanpa Menggunakan Warisan?

Mixins: Memperluas Keupayaan Kelas Tanpa Warisan

Mixins ialah konsep dalam pengaturcaraan berorientasikan objek yang membolehkan pembangun memperluaskan keupayaan kelas tanpa menggunakan warisan tradisional. Mereka sering dirujuk sebagai "subkelas abstrak" kerana ia menyerupai kelas abstrak tetapi menawarkan pendekatan yang berbeza kepada gubahan.

Untuk memahami campuran, pertimbangkan situasi berikut: Anda mempunyai berbilang konsep ortogon yang anda mahu modelkan sebagai kelas . Walaupun setiap konsep adalah berbeza, ia mungkin mempunyai fungsi yang boleh digabungkan untuk mencipta kelas yang lebih kompleks.

Secara tradisinya, anda mungkin mencapai ini menggunakan warisan, di mana setiap konsep menjadi subkelas kelas antara muka biasa. Walau bagaimanapun, pendekatan ini mengehadkan keupayaan anda untuk menggabungkan kelas konkrit ini kepada jenis baharu dengan mudah.

Mixins menyelesaikan masalah ini dengan memperkenalkan satu set kelas primitif yang mewakili konsep ortogon asas. Primitif ini berfungsi sebagai blok binaan yang boleh dipasang untuk mencipta kelas kompleks dengan fungsi tertentu. Kebolehlanjutan ini membolehkan anda menambah primitif baharu tanpa menjejaskan yang sedia ada.

Dalam C , campuran boleh dilaksanakan menggunakan templat dan warisan. Dengan melepasi blok binaan sebagai parameter templat, anda boleh menyambungkannya dan merantainya bersama-sama melalui typedefs untuk membentuk jenis baharu dengan kefungsian yang diingini.

Contoh: Buat asal dan Buat Semula Fungsi

Mari kita pertimbangkan contoh menambah kefungsian buat asal dan buat semula pada kelas Nombor. Begini rupa pelaksanaan campuran:

<code class="cpp">#include <iostream>
using namespace std;

struct Number {
  typedef int value_type;
  int n;
  void set(int v) { n = v; }
  int get() const { return n; }
};

template <typename BASE, typename T = typename BASE::value_type>
struct Undoable : public BASE {
  typedef T value_type;
  T before;
  void set(T v) { before = BASE::get(); BASE::set(v); }
  void undo() { BASE::set(before); }
};

template <typename BASE, typename T = typename BASE::value_type>
struct Redoable : public BASE {
  typedef T value_type;
  T after;
  void set(T v) { after = v; BASE::set(v); }
  void redo() { BASE::set(after); }
};

typedef Redoable<Undoable<Number>> ReUndoableNumber;

int main() {
  ReUndoableNumber mynum;
  mynum.set(42);
  mynum.set(84);
  cout << mynum.get() << '\n'; // 84
  mynum.undo();
  cout << mynum.get() << '\n'; // 42
  mynum.redo();
  cout << mynum.get() << '\n'; // back to 84
}</code>

Dengan menggabungkan campuran Boleh Buat dan Boleh Buat Semula dengan kelas Nombor, kami mencipta kelas baharu, ReUndoableNumber, yang mempunyai fungsi untuk membuat asal dan membuat semula perubahan. Ini menunjukkan cara mixin boleh memanjangkan keupayaan kelas tanpa warisan tradisional.

Atas ialah kandungan terperinci Bagaimanakah Mixin Boleh Memanjangkan Fungsi Kelas Tanpa Menggunakan Warisan?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!