关于C++的 explicit关键字

int ns = 0;
s = 1; // 1 oops, programmer intended to write ns = 1,
}
In the expression s= 1;, the programmer simply mistyped the name of the
int f(string s);
int main()
{
f(1); // without a an explicit constructor,
//this call is expanded into: f ( string(1) );
On the other hand, if you declare this constructor explicit, you have to
use explicit type conversion:
class string
{
//...
关于C++的 explicit关键字
Posted on 2006-02-05 05:16 Tommy Liang 阅读(6316) 评论(6) 编辑 收藏 引用 所属分类:
C++语言与规范
简而言之：explicit修饰的构造函数不能担任转换函数
implicit conversion was retained. However, a
new keyword, explicit, was introduced to the languageto enable the
programmer to block the implicit conversion
public:
explicit string(const char *);
};
int main()
{
string s;
s = string("Hello"); //explicit conversion now required
searches for a user-defined conversion that allows this expression;
indeed, it finds the constructor that takes int.
Consequently, the compiler interprets the expression s= 1; as if the
string(const char *); // constructor and implicit conversion operator
~string();
};
Class string has three constructors: a default constructor, a constructor
这个 《ANSI/ISO C++ Professional Programmer's Handbook 》是这样说的
explicit Constructors
A constructor that takes a single argument is, by default, an implicit
argument needs to be declared explicit:
class string
{
//...
public:
explicit string(int size); // block implicit conversion
can either be a cryptic coding style or simply a programmer's
typographical error. However, due to the implicit
conversion constructor of class string, it will pass unnoticed:
typographical error this time:
int main()
{
string s = "hello"; //OK, convert a C-string into a string object
int ns = 0;
s = 1; // compile time error ; this time the compiler catches the typo
}
Why aren't all constructors automatically declared explicit? Under some
variable ns, typing s instead. Normally,
the compiler detects the incompatible types and issues an error message.
However, before ruling it out, the compiler first
initial preallocated buffer at the specified size. However, in the case of
class string, the automatic conversion is
dubious. Converting an int into a string object doesn't make sense,
conditions, the automatic type conversion is
useful and well behaved. A good example of this is the third constructor
of string:
string(const char *);
//was that intentional or merely a programmer's typo?
}
'In order to avoid such implicit conversions, a constructor that takes one
behaved, the constructor can be used as an
implicit conversion operator.
class string
{
private:
int size;
int capacity;
char *buff;
public:
string();
string(int size); // constructor and implicit conversion operator
when it is undesirable. As a rule, a constructor that can be invoked with
a single argument needs to be declared
explicit. When the implicit type conversion is intentional and well
关于C++的 explicit关键字 - tommy - C++博客
tommy
It's hard to tell the world we live in is either a reality or a
dream
conversion operator, which converts its argument to
an object of its class (see also Chapter 3, "Operator Overloading").
Examine the following concrete example:
return 0;
}
Extensive amounts of legacy C++ code rely on the implicit conversion of
constructors. The C++ Standardization
committee was aware of that. In order to not make existing code break, the
programmer had written
s = string(1);
You might encounter a similar problem when calling a function that takes a
string argument. The following example
although this is exactly what this constructor does.
Consider the following:
int main()
{
string s = "hello"; //OK, convert a C-string into a string object
that takes int, and a constructor that
constructs a string from const char *. The second constructor is used to
create an empty string object with an
string(const char *); //implicit conversion