C++ syntax error: A constructor with only a single parameter must be declared explicit. How to solve it?

In C programming, you may encounter the following error message: A constructor with only a single parameter must be declared explicit. This error message may confuse beginners. Next, let’s take a look at what explicit is in C, the reasons why this error message appears, and how to solve this problem.

The role of explicit

In C, if we define a constructor that only receives one parameter, then we need to explicitly declare the constructor using the keyword explicit. Using explicit can avoid implicit conversion problems and prevent objects of one type from being implicitly converted to objects of another type.

For example, if we have a constructor that receives a string parameter, if it is not declared using the explicit keyword, then in some cases, the constructor will be called implicitly, which may leading to some potential problems. The following is an example that demonstrates this problem:

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

The above code will report an error: a constructor with only a single parameter must be declared explicit. This is because in the DisplayPerson function, we use a string constant as a parameter to pass to the Person type, resulting in implicit conversion.

In order to solve this problem, we can add the explicit keyword before the constructor, as follows:

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

In this way, in the DisplayPerson function, we cannot directly pass in a string constant Yes, you must explicitly create a Person object and then pass it into the function.

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

    return 0;
}

Causes and solutions

Only single-parameter constructors must be declared explicit. This error message usually occurs when a single-parameter constructor is used in a program. We should not rely on implicit type conversions when using these constructors. Implicit type conversions introduce type mismatches and erratic behavior, and can lead to hard-to-find bugs.

If this error message appears in your program, you can use the following two methods to solve it:

Method 1: Use the explicit keyword

If you define a receive-only For a one-parameter constructor, you need to explicitly declare the constructor using the explicit keyword. This will prevent implicit type conversions and make the code safer and easier to understand.

explicit ClassName(Type parameter) {};

Where explicit specifies that the single-parameter constructor cannot be called implicitly. ClassName is the name of the class you want to instantiate, Type is the type of the parameter, and parameter is the name of the parameter.

The following is a sample 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;
}

Method 2: Use type conversion function

The second method is to use type conversion function. If you don't want to use explicit, you can define a conversion function that instantiates the class to the desired type. This is the method commonly used when converting one class to another.

The following is a sample 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;
}

In this example, we use the operator int function to convert the Student class to an integer type. Using this approach, the Student object can be implicitly converted to an integer type and passed to the display() function.

Summary

C’s explicit keyword enables constructors to be created explicitly, thereby avoiding problems caused by potential implicit conversions. During programming, if you encounter the error message "Constructors with only a single parameter must be declared explicit", you can use the above two methods to solve this problem. Remember, explicit code is safer, simpler, and easier to understand and maintain.

The above is the detailed content of C++ syntax error: A constructor with only a single parameter must be declared explicit. How to solve it?. For more information, please follow other related articles on the PHP Chinese website!