Adakah Argumen Templat (Tandatangan) `std::function` Sebahagian daripada Jenisnya?

Kekaburan Tandatangan dan Jenis dalam std::Fungsi

Gambaran Keseluruhan

Dalam C , std::function ialah kelas templat yang mewakili objek boleh panggil . Ia menyediakan cara yang fleksibel untuk menghantar fungsi sebagai hujah dan menyimpannya dalam struktur data. Walau bagaimanapun, punca kekeliruan biasa timbul sama ada hujah templat (tandatangan) fungsi std::adalah sebahagian daripada jenisnya. Artikel ini menyelidiki butiran kekaburan ini dan meneroka kemungkinan penyelesaian.

Masalahnya

Kekaburan timbul apabila lebihan beban fungsi menerima parameter tandatangan yang berbeza tetapi kedua-duanya boleh dibina daripada jenis yang sama , seperti penunjuk fungsi atau lambdas. Pertimbangkan coretan kod berikut:

<code class="cpp">#include <functional>

using namespace std;

int a(const function<int ()>& amp;f)
{
    return f();
}

int a(const function<int (int)>& amp;f)
{
    return f(0);
}

int x() { return 22; }

int y(int) { return 44; }

int main()
{
    a(x);  // Call is ambiguous.
    a(y);  // Call is ambiguous.

    a((function<int ()>&)x);    // Works.
    a((function<int (int)>&)y); // Works.

    return 0;
}</code>

Dalam contoh ini, fungsi a terlebih beban untuk menerima sama ada penunjuk fungsi jenis fungsi atau fungsi. Apabila memanggil a dengan x atau y, yang kedua-duanya merupakan penunjuk fungsi dengan tandatangan yang berbeza, pengkompil tidak boleh menentukan beban berlebihan yang hendak dipilih, mengakibatkan kekaburan.

Punca Kekaburan

Kekaburan ini berpunca daripada fakta bahawa std::function menggunakan pemadaman jenis, yang membolehkannya menyimpan dan memanggil fungsi pelbagai jenis. Argumen templat (tandatangan) fungsi std:: berfungsi sebagai pemegang tempat untuk menentukan jenis boleh panggil, tetapi ia tidak dikuatkuasakan dengan ketat semasa pembinaan.

Sebagai contoh, pembina std::function boleh menerima sebarang jenis yang boleh ditukar kepada objek boleh dipanggil, walaupun tandatangan tidak sepadan dengan hujah templat. Fleksibiliti dalam pembinaan ini membawa kepada kekaburan apabila berbilang beban berlebihan menerima jenis yang boleh dibina secara longgar.

Mengelakkan Kekaburan

Untuk menyelesaikan kekaburan, tuangan eksplisit boleh digunakan untuk menentukan tandatangan yang diingini pada titik fungsi seruan. Ini memastikan bahawa pengkompil boleh mengenal pasti lebihan beban yang betul berdasarkan jenis hantaran. Dalam contoh di atas, hantaran berikut boleh ditambah untuk menyahkekaburan panggilan:

<code class="cpp">a((function<int ()>&)x);  // Disambiguate as function<int ()>
a((function<int (int)>&)y); // Disambiguate as function<int (int)></code>

Sebagai alternatif, objek fungsi jenis yang sesuai boleh dibuat dan dihantar ke fungsi a secara langsung:

<code class="cpp">function<int ()> fx = x;
function<int (int)> fy = y;
a(fx);  // No ambiguity
a(fy);  // No ambiguity</code>

Akhir sekali, teknik pengaturcaraan meta templat boleh digunakan untuk menjana fungsi khusus untuk tandatangan yang berbeza, menghapuskan keperluan untuk penghantaran eksplisit. Pendekatan ini menyediakan penyelesaian yang lebih elegan dan selamat jenis.

Kesimpulan

Tandatangan std::function berfungsi sebagai pemegang tempat untuk menentukan jenis boleh panggil, tetapi ia tidak menguatkuasakan pemadanan jenis secara ketat semasa pembinaan. Fleksibiliti ini boleh membawa kepada kekaburan apabila pelbagai bebanan menerima jenis yang longgar boleh dibina. Dengan menggunakan pemutus eksplisit atau pendekatan alternatif seperti objek fungsi atau pengaturcaraan meta templat, pembangun boleh menyahkekaburan panggilan fungsi dan memastikan beban berlebihan yang betul dipilih.

Atas ialah kandungan terperinci Adakah Argumen Templat (Tandatangan) `std::function` Sebahagian daripada Jenisnya?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!