C++中volatile和mutable关键字用法详解分享！

C/C++中的volatile关键字和const对应，用来修饰变量，用于告诉编译器该变量值是不稳定的，可能被更改。使用volatile注意事项：

(1). 编译器会对带有volatile关键字的变量禁用优化(A volatile specifier is a hint to a compiler that an object may change its value in ways not specified by the language so that aggressive optimizations must be avoided)。

(2). 当多个线程都要用到某一个变量且该变量的值会被改变时应该用volatile声明，该关键字的作用是防止编译器优化把变量从内存装入CPU寄存器中。如果变量被装入寄存器，那么多个线程有可能有的使用内存中的变量，有的使用寄存器中的变量，这会造成程序的错误执行。volatile的意思是让编译器每次操作该变量时一定要从内存中取出，而不是使用已经存在寄存器中的值(It cannot cache the variables in register)。

(3). 中断服务程序中访问到的变量最好带上volatile。

(4). 并行设备的硬件寄存器的变量最好带上volatile。

(5). 声明的变量可以同时带有const和volatile关键字。

(6). 多个volatile变量间的操作，是不会被编译器交换顺序的，能够保证volatile变量间的顺序性，编译器不会进行乱序优化(The value cannot change in order of assignment)。但volatile变量和非volatile变量之间的顺序，编译器不保证顺序，可能会进行乱序优化。

C++中的mutable关键字使用场景：

(1). 允许即使包含它的对象被声明为const时仍可修改声明为mutable的类成员(sometimes there is requirement to modify one or more data members of class/struct through const function even though you don’t want the function to update other members of class/struct. This task can be easily performed by using mutable keyword)。

(2). 应用在C++11 lambda表达式来表示按值捕获的值是可修改的，默认情况下是不可修改的，但修改仅在lambda式内有效(since c++11 mutable can be used on a lambda to denote that things captured by value are modifiable (they aren’t by default))。

详细用法见下面的测试代码，下面是从其他文章中copy的测试代码，详细内容介绍可以参考对应的reference：

  #include "volatile_mutable.hpp"  #include <iostream>  #include <stdio.h>  #include <time.h>  #include <mutex>  #include <string.h>     namespace volatile_mutable_ {     ///////////////////////////////////////////////////////////  int test_volatile_1()  {   volatile int i1 = 0; // correct   int volatile i2 = 0; // correct      return 0;  }     ///////////////////////////////////////////////////////////  // reference: https://en.cppreference.com/w/c/language/volatile  int test_volatile_2()  {  { // Any attempt to read or write to an object whose type is volatile-qualified through a non-volatile lvalue results in undefined behavior   volatile int n = 1; // object of volatile-qualified type   int* p = (int*)&n;   int val = *p; // undefined behavior in C, Note: link does not report an error under C++   fprintf(stdout, "val: %dn", val);  }     { // A member of a volatile-qualified structure or union type acquires the qualification of the type it belongs to   typedef struct ss { int i; const int ci; } s;   // the type of s.i is int, the type of s.ci is const int   volatile s vs = { 1, 2 };   // the types of vs.i and vs.ci are volatile int and const volatile int  }     { // If an array type is declared with the volatile type qualifier (through the use of typedef), the array type is not volatile-qualified, but its element type is   typedef int A[2][3];   volatile A a = { {4, 5, 6}, {7, 8, 9} }; // array of array of volatile int   //int* pi = a[0]; // Error: a[0] has type volatile int*   volatile int* pi = a[0];  }     { // A pointer to a non-volatile type can be implicitly converted to a pointer to the volatile-qualified version of the same or compatible type. The reverse conversion can be performed with a cast expression   int* p = nullptr;   volatile int* vp = p; // OK: adds qualifiers (int to volatile int)   //p = vp; // Error: discards qualifiers (volatile int to int)   p = (int*)vp; // OK: cast  }     { // volatile disable optimizations   clock_t t = clock();   double d = 0.0;   for (int n = 0; n < 10000; ++n)   for (int m = 0; m < 10000; ++m)    d += d * n*m; // reads and writes to a non-volatile    fprintf(stdout, "Modified a non-volatile variable 100m times. Time used: %.2f secondsn", (double)(clock() - t) / CLOCKS_PER_SEC);      t = clock();   volatile double vd = 0.0;   for (int n = 0; n < 10000; ++n)   for (int m = 0; m < 10000; ++m)    vd += vd * n*m; // reads and writes to a volatile    fprintf(stdout, "Modified a volatile variable 100m times. Time used: %.2f secondsn", (double)(clock() - t) / CLOCKS_PER_SEC);  }      return 0;  }     ///////////////////////////////////////////////////////////  // reference: https://en.cppreference.com/w/cpp/language/cv  int test_volatile_3()  {   int n1 = 0;      // non-const object   const int n2 = 0;   // const object   int const n3 = 0;   // const object (same as n2)   volatile int n4 = 0; // volatile object   const struct {   int n1;   mutable int n2;   } x = { 0, 0 };   // const object with mutable member      n1 = 1; // ok, modifiable object   //n2 = 2; // error: non-modifiable object   n4 = 3; // ok, treated as a side-effect   //x.n1 = 4; // error: member of a const object is const   x.n2 = 4; // ok, mutable member of a const object isn't const      const int& r1 = n1; // reference to const bound to non-const object   //r1 = 2; // error: attempt to modify through reference to const   const_cast<int&>(r1) = 2; // ok, modifies non-const object n1   fprintf(stdout, "n1: %dn", n1); // 2      const int& r2 = n2; // reference to const bound to const object   //r2 = 2; // error: attempt to modify through reference to const   const_cast<int&>(r2) = 2; // undefined behavior: attempt to modify const object n2, Note: link does not report an error under C++   fprintf(stdout, "n2: %dn", n2); // 0      return 0;  }     ///////////////////////////////////////////////////////////  // reference: https://www.geeksforgeeks.org/understanding-volatile-qualifier-in-c/  int test_volatile_4()  {  {   const int local = 10;   int *ptr = (int*)&local;   fprintf(stdout, "Initial value of local : %d n", local); // 10      *ptr = 100;   fprintf(stdout, "Modified value of local: %d n", local); // 10  }     {   const volatile int local = 10;   int *ptr = (int*)&local;   fprintf(stdout, "Initial value of local : %d n", local); // 10      *ptr = 100;   fprintf(stdout, "Modified value of local: %d n", local); // 100  }      return 0;  }     ///////////////////////////////////////////////////////////  // reference: https://en.cppreference.com/w/cpp/language/cv  int test_mutable_1()  {   // Mutable is used to specify that the member does not affect the externally visible state of the class (as often used for mutexes,   // memo caches, lazy evaluation, and access instrumentation)   class ThreadsafeCounter {   public:   int get() const {    std::lock_guard<std::mutex> lk(m);    return data;   }   void inc() {    std::lock_guard<std::mutex> lk(m);    ++data;   }      private:   mutable std::mutex m; // The "M&M rule": mutable and mutex go together   int data = 0;   };      return 0;  }     ///////////////////////////////////////////////////////////  // reference: https://www.tutorialspoint.com/cplusplus-mutable-keyword  int test_mutable_2()  {   class Test {   public:   Test(int x = 0, int y = 0) : a(x), b(y) {}      void seta(int x = 0) { a = x; }   void setb(int y = 0) { b = y; }   void disp() { fprintf(stdout, "a: %d, b: %dn", a, b); }      public:   int a;   mutable int b;   };      const Test t(10, 20);   fprintf(stdout, "t.a: %d, t.b: %d n", t.a, t.b); // 10, 20      //t.a=30; // Error occurs because a can not be changed, because object is constant.   t.b = 100; // b still can be changed, because b is mutable.   fprintf(stdout, "t.a: %d, t.b: %d n", t.a, t.b); // 10, 100      return 0;  }     ///////////////////////////////////////////////////////////  // reference: https://www.geeksforgeeks.org/c-mutable-keyword/  int test_mutable_3()  {   using std::cout;   using std::endl;      class Customer {   public:   Customer(char* s, char* m, int a, int p)   {    strcpy(name, s);    strcpy(placedorder, m);    tableno = a;    bill = p;   }      void changePlacedOrder(char* p) const { strcpy(placedorder, p); }   void changeBill(int s) const { bill = s; }      void display() const   {    cout << "Customer name is: " << name << endl;    cout << "Food ordered by customer is: " << placedorder << endl;    cout << "table no is: " << tableno << endl;    cout << "Total payable amount: " << bill << endl;   }      private:   char name[25];   mutable char placedorder[50];   int tableno;   mutable int bill;   };      const Customer c1("Pravasi Meet", "Ice Cream", 3, 100);   c1.display();   c1.changePlacedOrder("GulabJammuns");   c1.changeBill(150);   c1.display();      return 0;  }     ///////////////////////////////////////////////////////////  // reference: https://stackoverflow.com/questions/105014/does-the-mutable-keyword-have-any-purpose-other-than-allowing-the-variable-to  int test_mutable_4()  {   int x = 0;   auto f1 = [=]() mutable { x = 42; }; // OK   //auto f2 = [=]() { x = 42; }; // Error: a by-value capture cannot be modified in a non-mutable lambda   fprintf(stdout, "x: %dn", x); // 0      return 0;  }     } // namespace volatile_mutable_

GitHub：https://github.com/fengbingchun/Messy_Test

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持<计算机技术网(www.ctvol.com)!!>。

—-想了解C++中volatile和mutable关键字用法详解分享！全部内容且更多的C语言教程关注<计算机技术网(www.ctvol.com)!!>