Ralat sintaks C++: Pembina dengan hanya satu parameter mesti diisytiharkan secara eksplisit Bagaimana untuk menyelesaikannya?

Dalam pengaturcaraan C++, anda mungkin menghadapi mesej ralat berikut: Pembina dengan hanya satu parameter mesti diisytiharkan secara eksplisit. Mesej ralat ini mungkin mengelirukan pemula Seterusnya, mari kita lihat perkara yang jelas dalam C++, sebab mengapa mesej ralat ini muncul dan cara menyelesaikan masalah ini.

Peranan eksplisit

Dalam C++, jika kita mentakrifkan pembina yang hanya menerima satu parameter, maka kita perlu mengisytiharkan pembina secara eksplisit menggunakan kata kunci eksplisit. Menggunakan eksplisit boleh mengelakkan masalah penukaran tersirat dan menghalang objek daripada satu jenis daripada ditukar secara tersirat kepada objek jenis lain.

Sebagai contoh, jika kita mempunyai pembina yang menerima parameter rentetan, jika ia tidak diisytiharkan menggunakan kata kunci eksplisit, maka dalam beberapa kes, pembina akan dipanggil secara tersirat, yang mungkin membawa kepada beberapa soalan yang berpotensi. Berikut ialah contoh yang menunjukkan masalah ini:

#include <iostream>
#include <string>

class Person {
public:
    Person(const std::string& name) : name_(name) { }
    
    std::string GetName() const {
        return name_;
    }

private:
    std::string name_;
};

void DisplayPerson(const Person& p) {
    std::cout << "Person's name is " << p.GetName() << std::endl;
}

int main() {
    // 隐式调用 Person 的构造函数
    DisplayPerson("Tom");

    return 0;
}

Kod di atas akan melaporkan ralat: pembina dengan hanya satu parameter mesti diisytiharkan secara eksplisit. Ini kerana dalam fungsi DisplayPerson, kami menggunakan pemalar rentetan sebagai parameter untuk dihantar kepada jenis Orang, mengakibatkan penukaran tersirat.

Untuk menyelesaikan masalah ini, kita boleh menambah kata kunci eksplisit sebelum pembina, seperti berikut:

explicit Person(const std::string& name) : name_(name) { }

Dengan cara ini, dalam fungsi DisplayPerson, pemalar rentetan tidak boleh dihantar secara langsung, dan objek Orang mesti dicipta secara eksplisit Kemudian lulus dalam fungsi.

int main() {
    // 显式调用 Person 的构造函数
    Person p("Tom");
    DisplayPerson(p);

    return 0;
}

Punca dan penyelesaian

Pembina dengan hanya satu parameter mesti diisytiharkan secara eksplisit Mesej ralat ini biasanya berlaku apabila pembina parameter tunggal digunakan dalam atur cara. Kita tidak seharusnya bergantung pada penukaran jenis tersirat apabila menggunakan pembina ini. Penukaran jenis tersirat memperkenalkan ketidakpadanan jenis dan gelagat tidak menentu, dan boleh membawa kepada pepijat yang sukar ditemui.

Jika mesej ralat ini muncul dalam program anda, anda boleh menggunakan dua kaedah berikut untuk menyelesaikannya:

Kaedah 1: Gunakan kata kunci eksplisit

Jika anda mentakrifkan pembina yang hanya menerima satu parameter, anda perlu menggunakan eksplisit kata kunci Isytiharkan pembina secara eksplisit. Ini akan menghalang penukaran jenis tersirat dan menjadikan kod lebih selamat dan lebih mudah difahami.

explicit ClassName(Type parameter) {};

di mana eksplisit menyatakan bahawa pembina parameter tunggal tidak boleh dipanggil secara tersirat. ClassName ialah nama kelas yang anda ingin nyatakan, Jenis ialah jenis parameter dan parameter ialah nama parameter.

Berikut ialah contoh program:

#include <iostream>
using namespace std;

class Student
{
public:
    explicit Student(int id) { m_id = id; }
    int getId()
    {
        return m_id;
    }

private:
    int m_id;
};

int main(int argc, char** argv)
{
    Student std1(1); // 正确

    Student std2 = 2; // 错误，必须显式声明，不能进行隐式转换

    return 0;
}

Kaedah 2: Gunakan fungsi penukaran jenis

Kaedah kedua ialah menggunakan fungsi penukaran jenis. Jika anda tidak mahu menggunakan eksplisit, anda boleh mentakrifkan fungsi penukaran yang menjadikan kelas kepada jenis yang dikehendaki. Ini adalah kaedah yang biasa digunakan apabila menukar satu kelas kepada kelas yang lain.

Berikut ialah contoh program:

#include <iostream>
using namespace std;

class Student
{
public:
    Student(int id) { m_id = id; }
    int getId()
    {
        return m_id;
    }
    operator int()
    {
        return m_id;
    }

private:
    int m_id;
};

void display(int id)
{
    cout << "ID: " << id << endl;
}

int main(int argc, char** argv)
{
    Student std(1);

    display(std); // 您可以将 Student 对象转换为所需的类型（int）

    return 0;
}

Dalam contoh ini, kami menggunakan fungsi operator int untuk menukar kelas Pelajar kepada jenis integer. Menggunakan pendekatan ini, objek Pelajar boleh ditukar secara tersirat kepada jenis integer dan dihantar ke fungsi paparan().

Ringkasan

Kata kunci eksplisit C++ membolehkan pembina dicipta secara eksplisit, sekali gus mengelakkan masalah yang disebabkan oleh potensi penukaran tersirat. Semasa pengaturcaraan, jika anda menemui mesej ralat "Pembina dengan hanya satu parameter mesti diisytiharkan secara eksplisit", anda boleh menggunakan dua kaedah di atas untuk menyelesaikan masalah. Ingat, kod eksplisit adalah lebih selamat, ringkas dan lebih mudah untuk difahami dan diselenggara.

Atas ialah kandungan terperinci Ralat sintaks C++: Pembina dengan hanya satu parameter mesti diisytiharkan secara eksplisit Bagaimana untuk menyelesaikannya?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!