What is C++ implicit type conversion?

Implicit type conversion in C refers to a compiler's automatic conversion from "constructor parameter type" to "class type". Implicit class type conversion brings risks. Implicit conversion results in temporary variables of the class, which disappear after the operation is completed. We constructed an object that was discarded after completing the test.

C implicit class type conversion

In "C Primer" Mentioned:

"A constructor that can be called with a single parameter defines an implicit conversion from the parameter type to the class type."

It should be noted here that "can be called with a single formal parameter" does not mean that the constructor can only have one formal parameter, but that it can have multiple formal parameters, but those formal parameters have default actual parameters. .

So, what is "implicit conversion"? As the above sentence also says, is a compiler's automatic conversion from the constructor parameter type to the class type.

Let’s take a look through the code:

#include "stdafx.h"
#include <string>
#include <iostream>
using namespace std ;
class BOOK  //定义了一个书类
{
    private:
        string _bookISBN ;  //书的ISBN号
        float _price ;    //书的价格

    public:
        //定义了一个成员函数，这个函数即是那个“期待一个实参为类类型的函数”
        //这个函数用于比较两本书的ISBN号是否相同
        bool isSameISBN(const BOOK & other ){
            return other._bookISBN==_bookISBN;
                }

        //类的构造函数，即那个“能够用一个参数进行调用的构造函数”（虽然它有两个形参，但其中一个有默认实参，只用一个参数也能进行调用）
        BOOK(string ISBN,float price=0.0f):_bookISBN(ISBN),_price(price){}
};

int main()
{
    BOOK A("A-A-A");
    BOOK B("B-B-B");

    cout<<A.isSameISBN(B)<<endl;   //正经地进行比较，无需发生转换

    cout<<A.isSameISBN(string("A-A-A"))<<endl; //此处即发生一个隐式转换：string类型-->BOOK类型，借助BOOK的构造函数进行转换，以满足isSameISBN函数的参数期待。
    cout<<A.isSameISBN(BOOK("A-A-A"))<<endl;    //显式创建临时对象，也即是编译器干的事情。
    
    system("pause");
}

As you can see in the code, the isSameISBN function is expecting a BOOK class type parameter, but we passed a string type Give it to it, this is not what it wants! Fortunately, there is a constructor in the BOOK class, which is called with a string type actual parameter. The compiler calls this constructor, implicitly converts the string type to the BOOK type (constructs a BOOK temporary object), and then passes it Give the isSameISBN function.

Implicit class type conversion still brings risks. As marked above, implicit conversion obtains temporary variables of the class and disappears after completing the operation. We construct an object that is discarded after completing the test.

We can suppress this conversion through explicit declaration:

explicit BOOK(string ISBN,float price=0.0f):_bookISBN(ISBN),_price(price){}

The explicit keyword can only be used for constructor declarations inside the class. In this way, the BOOK class constructor cannot be used Since the object is created implicitly, when compiling the above code, the following prompt will appear:

Now the user can only perform display type conversion and explicitly create temporary objects.

To summarize:

• can be called with one actual parameter, which does not mean that the constructor can only have one formal parameter.

• Implicit class type conversion is easy to cause errors. Unless you have a clear reason to use implicit class type conversion, otherwise, declare all constructors that can be called with one argument as explicit. .

• explicit can only be used for declaration of constructors inside a class. Although it can avoid the problems caused by implicit type conversion, it requires the user to explicitly create temporary objects (which imposes requirements on the user).

Recommended: "C Tutorial"

The above is the detailed content of What is C++ implicit type conversion?. For more information, please follow other related articles on the PHP Chinese website!