volatile 和 explicit 的作用

volatile和explicit这两个C++关键字一般初学者不太有机会使用，因此不明白它们的作用。

1. volatile

volatile是修饰变量类型的，建立语言级别的memory barrier, BS(c++之父)的解释是

A volatile specifier is a hint to a compiler that an object may change its value in ways not specified by the language so thataggressive optimizations must be avoided.

直观上来说，volatile 是让编译器不对变量取值进行 优化的，很多时候当编译时，编译器认为变量值没有发生变化时就会简化掉取值的过程，但是有的时候存在其他编译器探测不到的情况会改变变量的值，例如汇编调用或者是多线程环境，多线程中的共享变量经常会发生改变，这个时候就需要每次从内存中读取数值。

使用方法：

int volatile value;

//vptr1的指针是volatile, vptr2指向的值是volatile
int* volatile vptr1;
volatile int* vptr2;

可以看到 volatile 和 const 的用法很像，非 volatile 变量可以转化成 volatile 类型，逆向转换则不行。

 

 

2. explicit

explicit 关键字用来修饰类的构造函数，被修饰的构造函数的类，不能发生相应的隐式类型转换，只能显式进行类型转换。有两点需要注意：

1. explicit 只用于类内部构造函数的声明上。

2. 修饰的构造函数只能有一个参数。

#include<iostream>

class foo{
    public:
        explicit foo(double r): R(r){
            std::cout << "foo(double r)" << std::endl;
        }
        explicit foo(int r): R(r){
            std::cout << "foo(int r)" << std::endl;
        }
        foo(const foo& obj): R(obj.R){
            std::cout << "foo(const foo& obj)" << std::endl;
        }
        foo& operator=(const foo& obj){
            std::cout << "operator=" << std::endl;
            R = obj.R;
            return *this;
        }
        ~foo(){
            std::cout << "~foo()" << std::endl;
        }
    private:
        double R;
};

int
main(void){
        //下面的语句都没有报错,但是如果给拷贝构造函数加上 explicit 的话，就都会报错
    foo A = foo(1.23);
    foo B = A;
    foo C = foo(123);

        //下面的语句报错了
        foo A = 1.23;
        
    return 1;
}        

 参考别人的博文：

http://www.cnblogs.com/this-543273659/archive/2011/08/02/2124596.html#3359435

http://www.cnblogs.com/yc_sunniwell/archive/2010/07/14/1777432.html