Corak Reka Bentuk C Moden: Membina perisian berskala dan boleh dipelihara

Model reka bentuk C moden menggunakan ciri -ciri baru C 11 dan seterusnya untuk membantu membina perisian yang lebih fleksibel dan cekap. 1) Gunakan Ekspresi Lambda dan STD :: Fungsi untuk memudahkan corak pemerhati. 2) Mengoptimumkan prestasi melalui semantik mudah alih dan pemajuan sempurna. 3) Penunjuk pintar memastikan jenis keselamatan dan pengurusan sumber.

Pengenalan

Dalam dunia pembangunan perisian hari ini, C tetap menjadi bahasa pilihan dalam banyak bidang, terutama dalam senario di mana prestasi tinggi dan kawalan peringkat rendah diperlukan. Walau bagaimanapun, kerana kerumitan sistem perisian terus meningkat, bagaimana untuk merekabentuk perisian berskala dan mudah untuk menjadi cabaran utama. Artikel ini akan menyelam ke dalam corak reka bentuk C moden untuk membantu anda membina perisian yang lebih berskala dan boleh dipelihara. Dengan membaca artikel ini, anda akan belajar bagaimana untuk memanfaatkan sifat moden C untuk melaksanakan corak reka bentuk klasik dan muncul dan mendapatkan pengalaman praktikal dan pandangan daripadanya.

Semak pengetahuan asas

Sebelum kita menyelam ke dalam corak reka bentuk, mari kita semak beberapa ciri utama C yang penting apabila melaksanakan corak reka bentuk. C menyediakan ciri bahasa yang kaya, seperti kelas dan objek, templat, metaprogramming, penunjuk pintar, dan lain -lain, yang merupakan asas untuk corak reka bentuk bangunan. Sebagai contoh, templat dapat membantu kami melaksanakan pengaturcaraan generik, sementara penunjuk pintar dapat memudahkan pengurusan memori dan mengurangkan risiko kebocoran memori.

Konsep teras atau analisis fungsi

Definisi dan fungsi corak reka bentuk C moden

Corak reka bentuk C moden merujuk kepada corak reka bentuk yang dilaksanakan menggunakan ciri -ciri baru yang diperkenalkan dalam versi C 11 dan kemudian. Corak ini bukan sahaja mewarisi kelebihan corak reka bentuk klasik, tetapi juga mengambil kesempatan daripada ciri -ciri moden C, seperti ekspresi lambda, kata kunci auto, semantik mudah alih, dan lain -lain, menjadikan kod lebih ringkas dan ekspresif. Peranan mereka adalah untuk membantu pemaju membina sistem perisian yang lebih fleksibel dan cekap.

Sebagai contoh, pertimbangkan pelaksanaan corak pemerhati yang mudah:

 #include <iostream>
#include <vector>
#Enclude <Fticeal>

subjek kelas {
awam:
    void melampirkan (std :: function <void ()> pemerhati) {
        pemerhati.push_back (pemerhati);
    }

    tidak sah memberitahu () {
        untuk (Auto & Observer: Observers) {
            pemerhati ();
        }
    }

Swasta:
    std :: vektor <std :: function <void () >> pemerhati;
};

int main () {
    Subjek subjek;
    subjek.attach ([] () {std :: cout << "Observer 1 diberitahu \ n";});
    subjek.attach ([] () {std :: cout << "Observer 2 diberitahu \ n";});

    subjek.notify ();
    kembali 0;
}

Dalam contoh ini, kami menggunakan Ekspresi Lambda dan std::function untuk melaksanakan corak pemerhati, menjadikan kod lebih ringkas dan fleksibel.

Bagaimana ia berfungsi

Prinsip kerja corak reka bentuk C moden bergantung kepada ciri -ciri baru C. Sebagai contoh, menggunakan semantik yang bergerak dapat mengurangkan operasi salinan yang tidak perlu dan meningkatkan prestasi; Menggunakan ekspresi Lambda dapat memudahkan definisi dan penggunaan fungsi panggil balik; Menggunakan kata kunci auto dapat mengurangkan pengisytiharan jenis dan meningkatkan kebolehbacaan kod.

Apabila melaksanakan corak reka bentuk, kita perlu mempertimbangkan aspek berikut:

• Jenis Keselamatan : Gunakan sistem jenis kuat C untuk memastikan keselamatan jenis kod.
• Pengoptimuman Prestasi : Gunakan semantik mudah alih, pemajuan sempurna dan ciri -ciri lain untuk mengoptimumkan prestasi kod.
• Kesederhanaan kod : Gunakan ekspresi lambda, kata kunci auto dan ciri -ciri lain untuk memudahkan kod dan meningkatkan kebolehbacaan.

Contoh penggunaan

Penggunaan asas

Mari kita lihat pelaksanaan model kilang yang mudah:

 #include <sory>
#include <string>

produk kelas {
awam:
    Virtual ~ Product () = lalai;
    maya std :: string getName () const = 0;
};

Kelas ConcreteProducta: Produk Awam {
awam:
    std :: string getName () const override {
        kembali "Produk A";
    }
};

Kelas ConcreteProductB: Produk Awam {
awam:
    std :: string getName () const override {
        kembali "Produk B";
    }
};

kilang kelas {
awam:
    static std :: unik_ptr <produk> createProduct (const std :: string & type) {
        jika (type == "a") {
            kembali std :: make_unique <concreteproducta> ();
        } else if (type == "b") {
            kembali std :: make_unique <concreteproductb> ();
        }
        kembali nullptr;
    }
};

int main () {
    Auto Producta = Kilang :: CreateProduct ("A");
    Auto ProductB = Kilang :: CreateProduct ("B");

    jika (producta) std :: cout << producta-> getName () << std :: endl;
    jika (Productb) std :: cout << productb-> getName () << std :: endl;

    kembali 0;
}

Dalam contoh ini, kami menggunakan std::unique_ptr untuk menguruskan kitaran hayat objek, memastikan pembebasan sumber yang selamat.

Penggunaan lanjutan

Sekarang mari kita lihat contoh yang lebih kompleks menggunakan corak dasar untuk melaksanakan algoritma penyortiran yang berbeza:

 #include <vector>
#include <algorithm>
#Enclude <Fticeal>

templat <typename t>
kelas sortstrategy {
awam:
    Sort Void Virtual (std :: vektor <t> & data) = 0;
    Virtual ~ SortStrategy () = lalai;
};

templat <typename t>
Kelas Bubblesort: Public SortStrategy <T> {
awam:
    void sort (std :: vector <t> & data) override {
        untuk (size_t i = 0; i <data.size (); i) {
            untuk (size_t j = 0; j <data.size () - 1 - i; j) {
                jika (data [j]> data [j 1]) {
                    std :: swap (data [j], data [j 1]);
                }
            }
        }
    }
};

templat <typename t>
Kelas QuickSort: Public SortStrategy <T> {
awam:
    void sort (std :: vector <t> & data) override {
        std :: sort (data.begin (), data.end ());
    }
};

templat <typename t>
kelas sorter {
awam:
    void setstrategy (std :: unik_ptr <sortstrategy <t >> strategi) {
        this-> strategi = std :: bergerak (strategi);
    }

    void sort (std :: vector <t> & data) {
        jika (strategi) {
            strategi-> sort (data);
        }
    }

Swasta:
    std :: unik_ptr <sortstrategy <t >> strategi;
};

int main () {
    std :: vektor <int> data = {5, 2, 8, 1, 9};
    Sorter <int> Sorter;

    sorter.setStrategy (std :: make_unique <bubblesort <int >> ());
    sorter.sort (data);
    untuk (auto & num: data) std :: cout << num << "";
    std :: cout << std :: endl;

    data = {5, 2, 8, 1, 9};
    sorter.setStrategy (std :: make_unique <QuickSort <int >> ());
    sorter.sort (data);
    untuk (auto & num: data) std :: cout << num << "";
    std :: cout << std :: endl;

    kembali 0;
}

Dalam contoh ini, kami menggunakan templat dan penunjuk pintar untuk melaksanakan corak dasar, menjadikan kod lebih fleksibel dan selamat jenis.

Kesilapan biasa dan tip debugging

Kesalahan biasa apabila menggunakan corak reka bentuk C moden termasuk:

• Kebocoran memori : Walaupun penunjuk pintar dapat membantu kami menguruskan memori, jika digunakan secara tidak wajar, ia masih boleh menyebabkan kebocoran memori. Sebagai contoh, dalam mod kilang, lupa menggunakan std::unique_ptr , boleh menyebabkan kebocoran memori.
• Jenis ketidakpadanan : Apabila menggunakan templat, jika jenis ketidakcocokan, ia boleh mengakibatkan ralat kompilasi atau ralat runtime. Sebagai contoh, dalam mod dasar, jika jenis yang diluluskan tidak sepadan dengan parameter templat, ia mungkin mengakibatkan ralat penyusunan.

Kaedah untuk menyahpepijat masalah ini termasuk:

• Menggunakan alat pemeriksaan memori seperti Valgrind atau AlamatSanitizer dapat membantu kami mengesan kebocoran memori dan kesilapan akses memori.
• Analisis kod statik : Menggunakan alat analisis kod statik seperti penganalisis statik Clang dapat membantu kami mengesan kesilapan jenis dan masalah kod yang berpotensi.

Pengoptimuman prestasi dan amalan terbaik

Apabila menggunakan corak reka bentuk C moden, kita perlu mempertimbangkan pengoptimuman prestasi dan amalan terbaik. Sebagai contoh, apabila melaksanakan mod pemerhati, kita boleh menggunakan std::vector bukannya std::list kerana std::vector melakukan lebih baik dalam kebanyakan kes. Pada masa yang sama, kita boleh menggunakan std::move untuk mengoptimumkan operasi objek bergerak dan mengurangkan salinan yang tidak perlu.

Semasa menulis kod, kita harus mengikuti amalan terbaik berikut:

• Kebolehbacaan Kod : Gunakan penamaan dan komen yang jelas untuk memastikan bahawa kod itu mudah difahami dan dikekalkan.
• Kod semula jadi : Cuba gunakan semula kod sedia ada untuk mengurangkan penulisan kod pendua.
• Pembangunan yang didorong oleh ujian : Gunakan ujian unit untuk mengesahkan ketepatan kod dan pastikan kebolehpercayaan kod.

Ringkasnya, corak reka bentuk C moden memberikan kami alat yang berkuasa untuk membantu kami membina perisian yang lebih berskala dan boleh dipelihara. Dengan rasional memanfaatkan ciri -ciri moden C, kita boleh menulis lebih cekap dan mudah untuk mengekalkan kod. Saya harap artikel ini dapat memberi anda gambaran yang berharga dan pengalaman praktikal untuk membantu anda pergi lebih jauh di jalan pengaturcaraan C.

Atas ialah kandungan terperinci Corak Reka Bentuk C Moden: Membina perisian berskala dan boleh dipelihara. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!