Erreur de syntaxe C++ : Un constructeur avec un seul paramètre doit être déclaré explicite. Comment la résoudre ?

En programmation C++, vous pouvez rencontrer le message d'erreur suivant : Les constructeurs avec un seul paramètre doivent être déclarés explicites. Ce message d'erreur peut dérouter les débutants. Voyons ensuite ce qu'est explicite en C++, les raisons pour lesquelles ce message d'erreur apparaît et comment résoudre ce problème.

Le rôle de l'explicit

En C++, si nous définissons un constructeur qui ne reçoit qu'un seul paramètre, alors nous devons déclarer explicitement le constructeur à l'aide du mot-clé explicit. L'utilisation d'explicit peut éviter les problèmes de conversion implicite et empêcher les objets d'un type d'être implicitement convertis en objets d'un autre type.

Par exemple, si nous avons un constructeur qui reçoit un paramètre de chaîne, s'il n'est pas déclaré à l'aide du mot-clé explicite, alors dans certains cas, le constructeur sera appelé implicitement, ce qui peut conduire à des questions potentielles. Voici un exemple qui illustre ce problème :

#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;
}

Le code ci-dessus signalera une erreur : un constructeur avec un seul paramètre doit être déclaré explicite. En effet, dans la fonction DisplayPerson, nous utilisons une constante chaîne comme paramètre à transmettre au type Person, ce qui entraîne une conversion implicite.

Afin de résoudre ce problème, nous pouvons ajouter le mot-clé explicite avant le constructeur, comme suit :

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

De cette façon, dans la fonction DisplayPerson, une constante chaîne ne peut pas être passée directement, et un objet Person doit être créé explicitement Ensuite, transmettez la fonction.

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

    return 0;
}

Causes et solutions

Les constructeurs avec un seul paramètre doivent être déclarés explicites. Ce message d'erreur se produit généralement lorsqu'un constructeur à paramètre unique est utilisé dans un programme. Nous ne devons pas nous fier aux conversions de types implicites lors de l’utilisation de ces constructeurs. Les conversions de types implicites introduisent des incompatibilités de types et un comportement erratique, et peuvent conduire à des bogues difficiles à trouver.

Si ce message d'erreur apparaît dans votre programme, vous pouvez utiliser les deux méthodes suivantes pour le résoudre :

Méthode 1 : Utilisez le mot-clé explicite

Si vous définissez un constructeur qui ne reçoit qu'un seul paramètre, vous devez utiliser le mot-clé explicite mot-clé Déclarez explicitement le constructeur. Cela empêchera les conversions de type implicites et rendra le code plus sûr et plus facile à comprendre.

explicit ClassName(Type parameter) {};

where explicit spécifie que le constructeur à paramètre unique ne peut pas être appelé implicitement. ClassName est le nom de la classe que vous souhaitez instancier, Type est le type du paramètre et paramètre est le nom du paramètre.

Ce qui suit est un exemple de programme :

#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;
}

Méthode 2 : Utiliser la fonction de conversion de type

La deuxième méthode consiste à utiliser la fonction de conversion de type. Si vous ne souhaitez pas utiliser d'explicite, vous pouvez définir une fonction de conversion qui instancie la classe vers le type souhaité. C'est la méthode couramment utilisée lors de la conversion d'une classe en une autre.

Voici un exemple de programme :

#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;
}

Dans cet exemple, nous utilisons la fonction Operator Int pour convertir la classe Student en type entier. En utilisant cette approche, l'objet Student peut être implicitement converti en un type entier et transmis à la fonction display().

Résumé

Le mot-clé explicite du C++ permet de créer explicitement des constructeurs, évitant ainsi les problèmes causés par d'éventuelles conversions implicites. Lors de la programmation, si vous rencontrez le message d'erreur « Les constructeurs avec un seul paramètre doivent être déclarés explicites », vous pouvez utiliser les deux méthodes ci-dessus pour résoudre le problème. N'oubliez pas que le code explicite est plus sûr, plus simple et plus facile à comprendre et à maintenir.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!