Arsitektur Modular untuk Memproses Pipa

Saya mencoba mendesain arsitektur sistem yang akan saya implementasikan dalam C ++, dan saya bertanya-tanya apakah orang bisa memikirkan pendekatan yang baik, atau mengkritik pendekatan yang telah saya rancang sejauh ini.

Pertama-tama, masalah umum adalah pipa pemrosesan gambar. Ini berisi beberapa tahap, dan tujuannya adalah untuk merancang solusi yang sangat modular, sehingga setiap tahap dapat dengan mudah diganti dan diganti dengan sepotong kode khusus (sehingga pengguna dapat memiliki peningkatan kecepatan jika dia tahu bahwa tahap tertentu dibatasi dengan cara tertentu dalam masalahnya).

Pemikiran saat ini adalah sesuatu seperti ini:

struct output; /*Contains the output values from the pipeline.*/

class input_routines{
    public:
    virtual foo stage1(...){...}
    virtual bar stage2(...){...}
    virtual qux stage3(...){...}
    ...
}

output pipeline(input_routines stages);

Ini akan memungkinkan orang untuk subkelas input_routines dan menimpa tahap apa pun yang mereka inginkan. Yang mengatakan, saya telah bekerja dalam sistem seperti ini sebelumnya, dan saya menemukan subclass dan hal-hal standar cenderung menjadi berantakan, dan bisa sulit untuk digunakan, jadi saya tidak pusing tentang menulis satu sendiri. Saya juga memikirkan pendekatan yang lebih STLish, di mana tahapan yang berbeda (ada 6 atau 7) akan menjadi parameter template default.

Adakah yang bisa menawarkan kritik terhadap pola di atas, pemikiran tentang pendekatan templat, atau arsitektur lain yang muncul di pikiran?

Desainnya sangat tergantung pada apa yang sebenarnya dilakukan oleh berbagai tahap. Saya lebih suka fungsi virtual murni daripada fungsi virtual non-murni (kelas abstrak).

Tahapan umum dapat dikelompokkan bersama dalam subkelas abstrak. Dengan berasal dari kelas abstrak utama Anda masih dapat menyesuaikan setiap tahap, tetapi dengan berasal dari subkelas Anda dapat menggunakan kembali perilaku yang sudah ada yang sudah ditulis. Itu cenderung kurang berantakan, seperti yang Anda sebutkan untuk metode virtual.

Jika tahapan yang berbeda juga bisa ada sendiri (di luar seluruh pipa), pertimbangkan juga menulis kelas untuk memisahkan perilaku ini.

Mungkin membuat daftar functors di pabrik, yang mengimplementasikan tahapan. Kode semu:

functorFactory() {
  return [ foo(), bar(), baz() ]
}

Pengguna dapat menerapkan kembali pabrik atau hanya memanipulasi daftar fungsi. Kode semu

myFactory() {
  return [ foo(), myBar() ]
}

atau

myFactory() {
  return functorFactory()[2] = myBar()
}

Ketika pengaturan selesai, Anda dapat memanggil masing-masing functor menggunakan hasil yang terakhir.

Lihatlah Monads seperti yang diterapkan di Haskell, yang mungkin memberi Anda ide bagus tentang cara mengatur berbagai hal. Haskell membuat hal semacam ini benar.

Saya akan mendefinisikan tipe Intermediate. Semua gambar akan dikonversi ke format ini; setiap tahap akan mengambil Intermediate dan mengembalikan Intermediate - tidak yang sama, yang baru.

Sebuah panggung akan seperti ini:

Intermediate DoSomething(const Intermediate &i);

Saya biasanya menghindari solusi berbasis warisan pada umumnya kecuali mereka adalah peta yang cukup jelas ke masalah, misalnya, objek di dunia 3D.