Penjelasan terperinci tentang pengaturcaraan coroutine dalam C++

Dengan perkembangan teknologi komputer yang berterusan, kaedah pengaturcaraan juga sentiasa berinovasi dan bertambah baik. Antaranya, Pengaturcaraan coroutines dianggap sebagai kaedah pengaturcaraan yang agak baru. Pengaturcaraan Coroutine pertama kali dicadangkan pada tahun 1958 oleh Melvin Conway dalam kertas kerjanya. Tetapi bahasa C++ yang benar-benar mempromosikan dan menggunakan pengaturcaraan coroutine. Oleh itu, artikel ini akan menganalisis dan menerangkan pengaturcaraan coroutine secara terperinci dari perspektif bahasa C++.

Apakah itu coroutine?

Sebelum menerangkan pengaturcaraan coroutine, kita perlu memahami dahulu apa itu coroutine. Coroutines boleh difahami secara ringkas sebagai sub-fungsi khas yang boleh digantung apabila pelaksanaan mencapai titik tertentu dan menunggu untuk kebangkitan semula sebelum meneruskan pelaksanaan. Berbanding dengan panggilan fungsi tradisional, kaedah pelaksanaan coroutine adalah lebih fleksibel.

Penggantungan dan bangun coroutine boleh dikawal dengan sendirinya, bukan oleh pemanggil. Kelebihan ini ialah apabila coroutine melakukan beberapa operasi jangka panjang, ia boleh melepaskan sumber CPU dan membiarkan tugas lain dilakukan, dengan itu menggunakan sumber komputer dengan lebih baik.

Dalam C++, coroutine boleh dilaksanakan dengan menggunakan kata kunci co_await, yang membolehkan coroutine digantung apabila pelaksanaan mencapai titik tertentu dan dibangkitkan semula selepas mencapai syarat yang telah ditetapkan.

Bagaimana untuk menggunakan coroutine?

Dalam C++, menggunakan coroutine memerlukan bantuan perpustakaan coroutine Pada masa ini, perpustakaan coroutine yang paling biasa digunakan ialah Boost.Coroutine dan perpustakaan coroutine yang disertakan dengan C++20. Mari kita ambil coroutine dalam C++20 sebagai contoh untuk menerangkan cara menggunakan coroutine.

1. Tentukan fungsi coroutine

Dalam C++20, kita boleh menggunakan kata kunci co_await dan kata kunci co_yield untuk menentukan fungsi coroutine. co_await bermaksud menggantung coroutine semasa dan menunggu untuk dibangkitkan, manakala co_yield bermaksud menggantung coroutine semasa dan mengembalikan beberapa nilai atau status apabila fungsi coroutine mencapai titik tertentu. Berikut ialah contoh fungsi coroutine mudah:

#include <iostream>
#include <coroutine>
using namespace std;
 
struct HelloWorld {
    struct promise_type {
        HelloWorld get_return_object() {
            return {};
        }
        std::suspend_never initial_suspend() {
            return {};
        }
        std::suspend_never final_suspend() noexcept {
            return {};
        }
        void unhandled_exception() {}
    };
    
    HelloWorld() {};
    void print() {
        cout << "Hello, world!" << endl;
    }
 
    void operator()() {}
};
 
int main() {
    HelloWorld hello_world;
    hello_world();
    hello_world.print();
    return 0;
}

Dalam contoh di atas, kami mentakrifkan struktur bernama HelloWorld, iaitu fungsi coroutine. Dalam struktur ini, kami melaksanakan struktur bersarang yang dipanggil promise_type, yang mengawal gelagat fungsi coroutine. Kami juga mentakrifkan fungsi ahli yang dipanggil cetakan, yang mencetak rentetan "Hello, dunia!"

2. Panggil fungsi coroutine

Dalam C++20, kita boleh menggunakan kelas coroutine_handle untuk mengawal status pelaksanaan coroutine. Sebelum memanggil fungsi coroutine, kita perlu mendapatkan objek coroutine_handle. Selepas fungsi coroutine dilaksanakan, kita perlu melepaskan objek secara manual. Contohnya adalah seperti berikut:

int main() {
    HelloWorld hello_world;
    auto handle = hello_world();
    handle.resume();
    hello_world.print();
    handle.destroy();
    return 0;
}

Dalam contoh di atas, kami mula-mula mendapatkan objek coroutine_handle, dan kemudian memanggil fungsi resume()nya, yang akan melaksanakan kod dalam fungsi coroutine sehingga kata kunci co_await atau co_yield ditemui coroutine semasa. Akhir sekali, kami secara manual memanggil fungsi destroy() untuk melepaskan coroutine.

3. Gunakan co_await dan co_yield dalam fungsi coroutine

Dalam fungsi coroutine, kita boleh menggantung coroutine melalui kata kunci co_await dan co_yield. Berikut ialah contoh:

#include <iostream>
#include <coroutine>
using namespace std;
 
struct Generator {
    struct promise_type {
        int current_value;
        std::suspend_always yield_value(int value) {
            current_value = value;
            return {};
        }
        std::suspend_never initial_suspend() {
            return {};
        }
        std::suspend_never final_suspend() noexcept {
            return {};
        }
        Generator get_return_object() {
            return Generator(coroutine_handle<promise_type>::from_promise(*this));
        }
        void unhandled_exception() {}
    };
    
    Generator(coroutine_handle<promise_type> h) : coro(h) {}
    coroutine_handle<promise_type> coro;
    
    bool next() {
        coro.resume();
        return not coro.done();
    }
 
    int value() {
        return coro.promise().current_value;
    }
 
    ~Generator() {
        coro.destroy();
    }
};
 
Generator fibonacci(int to) {
    int a = 0, b = 1;
    while (a <= to) {
        co_yield a;
        auto tmp = a + b;
        a = b;
        b = tmp;
    }
}
 
int main() {
    Generator gen = fibonacci(10);
    while (gen.next()) {
        cout << gen.value() << " ";
    }
    return 0;
}

Dalam contoh di atas, kami mentakrifkan struktur yang dipanggil Penjana, yang juga merupakan fungsi coroutine. Kami mentakrifkan gelung sementara dalam fungsi coroutine Setiap kali kata kunci co_yield dilaksanakan, nilai semasa dikembalikan kepada pemanggil dan nilai a dan b dikemas kini. Dalam fungsi utama, kita mendapat objek Generator dengan memanggil fungsi Generator, dan kemudian terus memanggil fungsi next() untuk mendapatkan hasil yang dikembalikan oleh fungsi coroutine.

Ringkasan

Melalui contoh di atas, kita dapat melihat bahawa pengaturcaraan coroutine boleh menjadikan program lebih cekap dan fleksibel. Dalam kehidupan sebenar, pengaturcaraan coroutine digunakan secara meluas dalam pelbagai senario pengaturcaraan serentak, seperti pengaturcaraan rangkaian, pengaturcaraan berbilang benang, dsb.

Dalam C++, dengan bantuan perpustakaan coroutine, kami boleh melaksanakan pengaturcaraan coroutine dengan lebih mudah dan cekap. Pada masa hadapan, dengan pembangunan teknologi komputer dan peningkatan berterusan piawaian C++, pengaturcaraan coroutine akan digunakan dan dipromosikan dalam lebih banyak situasi.

Atas ialah kandungan terperinci Penjelasan terperinci tentang pengaturcaraan coroutine dalam C++. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!