本文转自http://www.programlife.net/cpp-explicit-keyword.html。

其实explicit主要用于防止隐式转换，用于修饰构造函数、复制构造函数[注意：一般推荐对构造函数使用explicit修饰，而对赋值构造函数不推荐使用explicit修饰]。比如，下面的代码编译不会出错：

#include <iostream>

using namespace std;

class Demo

{

private:

	int value;

public:

	Demo():value(0){}

	Demo(int val):value(val){}

	Demo(const Demo& d):value(d.value){}

};

int main()

{

	Demo d = 1;

	Demo dd = d;

	return 0;

}

Demo d = 1会这样运行：通过将1传递给单个形参构造函数，用这个构造函数来初始化对象d。对于下一行代码，通过将d传递给复制构造函数，来初始化dd。这些隐式调用都是自动完成的。有时候运行的很好，但是也有的时候会造成出乎意外的结果。能不能防止隐式调用呢？可以的。explicit就是用作这个用途的。当在构造函数和复制构造函数前面都加上explicit时，编译就会出错，下面的写法才是正确的：

#include <iostream>

using namespace std;

class Demo

{

private:

	int value;

public:

	Demo():value(0){}

	//explicit能防止以赋值语法带有转型操作的初始化

	explicit Demo(int val):value(val){}

	explicit Demo(const Demo& d):value(d.value){}

};

int main()

{

	//Demo d = 1;	//构造函数加上explicit时错误

	//Demo dd = d;	//复制构造函数加上explicit时错误
          Demo d(1);    //构造函数加不加explicit都没有问题

	  Demo dd(d);   //复制构造函数加不加explicit都没有问题

	  return 0;

}

还有一篇帖子说的比较详细：

先说说用构造函数作为隐式转换函数。在C++中，凡是一个类有只带一个参数的构造函数，都定义了一组隐式转换，把构造函数的参数类型转换为该class的类型。比如Integer(int)就定义了一个从int到Integer类型的隐式转换。比如，对于以下代码：

extern void calc( Integer );
int i;

calc( i );

如果Integer类没有声明一个Integer(int)的构造函数，编译器将在calc(i)处报错。相反如果Integer类声明了一个Integer(int)型的构造函数，那么int值可以被用在任何需要Integer类型的地方。

如果我们不期望编译器自动的进行这种隐式转换，该怎么办呢？有一种解决办法，就是把它声明为显式的（explicit）：

class Integer {
public:
   explicit Integer( int );
   // ...
};

这样当编译到隐式的类型转换时，编译器将报错，说明不能执行隐式转换。我们可以使用强制转换的形式显式的执行转换操作，如：

extern void func( Integer );

int main() {
   func(99); //错误，从int到Integer没有隐式转换
   func(Integer(99)); //OK,显式转换
   func(static_cast<Integer>(99)); //OK,强制转换
};