c++的一些不常见关键字

explicit关键字

explicit的作用是用来声明类构造函数是显示调用的，而非隐式调用，所以只用于修饰单参构造函数。因为无参构造函数和多参构造函数本身就是显示调用的。再加上explicit关键字也没有什么意义。

举例说明：

//没有加explicit
#include<cstring>
#include<string>
#include<iostream>

using namespace std;


class Explicit
{
    private:

    public:
        Explicit(int size) //单构造函数
        {
            cout << " the size is " << size << endl;
        }
        Explicit(const char* str)
        {
            string _str = str;
            cout << " the str is " << _str << endl;
        }

        Explicit(const Explicit& ins) //拷贝构造函数
        {
            cout << " copy constructor " << endl;
        }

        Explicit(int a,int b)
        {
            cout << " the a is " << a  << " the b is " << b << endl;
        }
};


int main(int argc, char const *argv[])

{
    Explicit test0(15);
    Explicit test1 = 50;// 隐式调用Explicit(int size)

    Explicit test2("STRING");
    Explicit test3 = "Explicit";// 隐式调用Explicit(const char* str)

    return 0;
}

输出结果：

上面的程序虽然没有错误，但是对于Explicit test1 = 50;和Explicit test3 = “Explicit”;这样的句子，把一个int类型或者const char*类型的变量赋值给Explicit类型的变量看起来总归不是很好，并且当程序很大的时候出错之后也不容易排查。

解决：

为了禁止上面那种隐式转换可能带来的风险，一般都把类的单参构造函数声明的显示调用的，就是在构造函数加关键字``explicit`。如下：

#include<cstring>
#include<string>
#include<iostream>

using namespace std;


class Explicit
{
    private:

    public:
        explicit Explicit(int size) //单构造函数
        {
            cout << " the size is " << size << endl;
        }
        explicit Explicit(const char* str)
        {
            string _str = str;
            cout << " the str is " << _str << endl;
        }

        Explicit(const Explicit& ins) //拷贝构造函数
        {
            cout << " copy constructor " << endl;
        }

        Explicit(int a,int b)
        {
            cout << " the a is " << a  << " the b is " << b << endl;
        }
};


int main(int argc, char const *argv[])

{
    Explicit test0(15);
    Explicit test1 = 50;// 隐式调用Explicit(int size)

    Explicit test2("STRING");
    Explicit test3 = "Explicit";// 隐式调用Explicit(const char* str)

    return 0;
}

输出结果：

上面再写Explicit test1=50; Explicit test3 = “Explicit”;这样的句子的时候程序就会报。被声明为explicit的构造函数通常比非explicit的构造函数更受欢迎，因为它们禁止编译器执行非预期的类型转换。

volatile关键字

在谈及 C/C++ 中的 volatile 关键字时，总有人会拿 volatile 这个英文单词的中文解释说事。volatile意思是“易变的”，但这种解释简直有点误导人，应该解释为“直接存取原始内存地址”比较合适。

volatile变量是随时可能发生变化的，它告诉编译器，与volatile变量有关的运算，不要进行任何优化，每次读取volatile变量时都重新从内存读取，不会有临时寄存器来存放变量的值。

也适用于C的结构和C++的类。当对结构或者类对象使用volatile修饰的时候，结构或者类的所有成员都会被视为volatile.

一般说来，volatile用在如下的几个地方：

1、中断服务程序中修改的供其它程序检测的变量需要加volatile；
2、多任务环境下各任务间共享的标志应该加volatile；
3、存储器映射的硬件寄存器通常也要加volatile说明，因为每次对它的读写都可能有不同意义；

mutable关键字

C++ 中，不可变的变量，称之为常量，使用 const 来修饰。mutable用于类的非静态和非常量数据成员，一般类的成员函数被声明为const，就表示不会修改类的数据成员，但如果要在常成员函数中修改类的非静态和非常量数据成员，则可以使用mutable修饰该数据成员，如下：

#include<iostream>

using namespace std;


class Mutable 
{
public:
    int getCnt() const
    {
        m_nCount++;
        return m_nCount;
    }

private:
    int m_nCount;
};


int main(int argc, char const *argv[])
{

    return 0;
}

输出结果：

很明显，编译时报错误：increment of member ‘demo::m_nCount’ in read-only object

解决：

改为如下代码：

#include<iostream>

using namespace std;


class Mutable 
{
public:
    int getCnt() const
    {
        m_nCount++;
        return m_nCount;
    }

private:
    mutable int m_nCount;
};

int main(int argc, char const *argv[])
{

    return 0;
}

编译结果：

在int m_nCount前面加上mutable ，则编译通过。