在 C++ 中， 如果一个类有只有一个参数的构造函数，C++ 允许一种特殊的声明类变量的方式。在这种情况下，可以直接将一个对应于构造函数参数类型的数据直接赋值给类变量，编译器在编译时会自动进行类型转换，将对应于构造函数参数类型的数据转换为类的对象。 如果在构造函数前加上 explicit 修饰词，
则会禁止这种自动转换，在这种情况下， 即使将对应于构造函数参数类型的数据直接赋值给类变量，编译器也会报错。
下面以具体实例来说明。
建立people.cpp 文件，然后输入下列内容：
/*人类，是人的类，不是人类 -:) */
class People
{
public:
int age;
explicit People (int a)
{
age=a;
}
};
/*三种方式来 “造人” */
void foo ( void )
{
People p1(10); //方式一
People* p_p2=new People(10); //方式二
People p3=10; //方式三
}
这段 C++ 程序定义了一个类 people ，包含一个构造函数， 这个构造函数只包含一个整形参数 a ，可用于在构造类时初始化 age 变量。
然后定义了一个函数foo，在这个函数中我们用三种方式分别创建了三个10岁的“人”。 第一种是最一般的类变量声明方式。第二种方式其实是声明了一个people类的指针变量，然后在堆中动态创建了一个people实例，并把这个实例的地址赋值给了p_p2。第三种方式就是我们所说的特殊方式，为什么说特殊呢？ 我们都知道，C/C++是一种强类型语言，不同的数据类型是不能随意转换的，如果要进行类型转换，必须进行显式强制类型转换，而这里，没有进行任何显式的转换，直接将一个整型数据赋值给了类变量p3。
因此，可以说，这里进行了一次隐式类型转换，编译器自动将对应于构造函数参数类型的数据转换为了该类的对象，因此方式三经编译器自动转换后和方式一最终的实现方式是一样的。
不相信？ 耳听为虚，眼见为实，让我们看看底层的实现方式。
为了更容易比较方式一和方式三的实现方式，我们对上面的代码作一点修改，去除方式二：
void foo ( void )
{
People p1(10); //方式一
People p3=10; //方式三
}
去除方式二的原因是方式二是在堆上动态创建类实例，因此会有一些额外代码影响分析。修改完成后，用下列命令编译 people.cpp
$ gcc -S people.cpp
"-S"选项是GCC输出汇编代码。命令执行后，默认生成people.s。 关键部分内容如下：
.globl _Z3foov
.type _Z3foov, @function
_Z3foov:
.LFB5:
pushl %ebp
.LCFI2:
movl %esp, %ebp
.LCFI3:
subl $24, %esp
.LCFI4:
movl $10, 4(%esp)
leal -4(%ebp), %eax
movl %eax, (%esp)
call _ZN6PeopleC1Ei
movl $10, 4(%esp)
leal -8(%ebp), %eax
movl %eax, (%esp)
call _ZN6PeopleC1Ei
leave
ret
看“.LCFI4” 行后面的东西，1-4行和5-8行几乎一模一样，1-4行即为方式一的汇编代码，5-8即为方式三的汇编代码。 细心的你可能发现2和6行有所不同，一个是 -4(%ebp) 而另一个一个是 -8(%ebp) ，这分别为类变量P1和P3的地址。
对于不可随意进行类型转换的强类型语言C/C++来说, 这可以说是C++的一个特性。哦，今天好像不是要说C++的特性，而是要知道explicit关键字的作用？
explicit关键字到底是什么作用呢？ 它的作用就是禁止这个特性。如文章一开始而言，凡是用explicit关键字修饰的构造函数，编译时就不会进行自动转换，而会报错。
让我们看看吧！ 修改代码：
class People
{
public:
int age;
explicit People (int a)
{
age=a;
}
};
然后再编译：
$ gcc -S people.cpp
编译器立马报错：
people.cpp: In function ‘void foo()’:
people.cpp:23: 错误：请求从 ‘int’ 转换到非标量类型 ‘People’
下面以具体实例来说明。
建立people.cpp 文件，然后输入下列内容：
/*人类，是人的类，不是人类 -:) */
class People
{
public:
int age;
explicit People (int a)
{
age=a;
}
};
/*三种方式来 “造人” */
void foo ( void )
{
People p1(10); //方式一
People* p_p2=new People(10); //方式二
People p3=10; //方式三
}
这段 C++ 程序定义了一个类 people ，包含一个构造函数， 这个构造函数只包含一个整形参数 a ，可用于在构造类时初始化 age 变量。
然后定义了一个函数foo，在这个函数中我们用三种方式分别创建了三个10岁的“人”。 第一种是最一般的类变量声明方式。第二种方式其实是声明了一个people类的指针变量，然后在堆中动态创建了一个people实例，并把这个实例的地址赋值给了p_p2。第三种方式就是我们所说的特殊方式，为什么说特殊呢？ 我们都知道，C/C++是一种强类型语言，不同的数据类型是不能随意转换的，如果要进行类型转换，必须进行显式强制类型转换，而这里，没有进行任何显式的转换，直接将一个整型数据赋值给了类变量p3。
因此，可以说，这里进行了一次隐式类型转换，编译器自动将对应于构造函数参数类型的数据转换为了该类的对象，因此方式三经编译器自动转换后和方式一最终的实现方式是一样的。
不相信？ 耳听为虚，眼见为实，让我们看看底层的实现方式。
为了更容易比较方式一和方式三的实现方式，我们对上面的代码作一点修改，去除方式二：
void foo ( void )
{
People p1(10); //方式一
People p3=10; //方式三
}
去除方式二的原因是方式二是在堆上动态创建类实例，因此会有一些额外代码影响分析。修改完成后，用下列命令编译 people.cpp
$ gcc -S people.cpp
"-S"选项是GCC输出汇编代码。命令执行后，默认生成people.s。 关键部分内容如下：
.globl _Z3foov
.type _Z3foov, @function
_Z3foov:
.LFB5:
pushl %ebp
.LCFI2:
movl %esp, %ebp
.LCFI3:
subl $24, %esp
.LCFI4:
movl $10, 4(%esp)
leal -4(%ebp), %eax
movl %eax, (%esp)
call _ZN6PeopleC1Ei
movl $10, 4(%esp)
leal -8(%ebp), %eax
movl %eax, (%esp)
call _ZN6PeopleC1Ei
leave
ret
看“.LCFI4” 行后面的东西，1-4行和5-8行几乎一模一样，1-4行即为方式一的汇编代码，5-8即为方式三的汇编代码。 细心的你可能发现2和6行有所不同，一个是 -4(%ebp) 而另一个一个是 -8(%ebp) ，这分别为类变量P1和P3的地址。
对于不可随意进行类型转换的强类型语言C/C++来说, 这可以说是C++的一个特性。哦，今天好像不是要说C++的特性，而是要知道explicit关键字的作用？
explicit关键字到底是什么作用呢？ 它的作用就是禁止这个特性。如文章一开始而言，凡是用explicit关键字修饰的构造函数，编译时就不会进行自动转换，而会报错。
让我们看看吧！ 修改代码：
class People
{
public:
int age;
explicit People (int a)
{
age=a;
}
};
然后再编译：
$ gcc -S people.cpp
编译器立马报错：
people.cpp: In function ‘void foo()’:
people.cpp:23: 错误：请求从 ‘int’ 转换到非标量类型 ‘People’