Java中的final 和 C++中的final、const（C++中const关键字功能总结）

目录

• Java中final有三种主要用法：
• C++中final只有两种：
• C++中const：
  • 修饰变量(基本类型变量、成员变量)：
  • const与引用：
  • const与指针："const在*前，数据不能改，const在*后，指针不能改"
  • const在函数中的应用：
  • const修饰对象：

Java中final有三种主要用法：

1. 修饰变量：final变量是不可改变的，但它的值可以在运行时刻初始化，也可以在编译时刻初始化，甚至可以放在构造函数中初始化，而不必在声明的时候初始化，所以下面的语句均合法：

   final int i = 1; // 编译时刻
   final int i2 = (int)(Math.Random() * 10); //运行时刻
   final int i3; //构造函数里再初始化
   

   final经常和static一起用，这种用法类似C++的常量，在Java中很常见，比如 static final i = 10; 但这里同样也是允许运行时刻初始化的。

2. 修饰类对象：而如果修饰类对象，并不表示这个对象不可更改，而是表示这个这个变量不可再赋成其它对象，这就比较像 C++的 Class const * p了(这样表明这个指向该Class的指针p不能再指向其他对象，指针常量，但是该对象中的值是可以修改的(const Class *p 是常量指针，任何成员变量都不能修改))。

   final Value v = new Value(); 
   v = new Value(); //不允许！ 
   v.some_method(); //允许
   

3. 修饰方法：final修饰的方法是不能被重载的，类似于类中的private方法，所以private方法默认是final的；大致说就是变量不可修改（基本数据类型值不能修改，类类型引用不能修改），方法不可重载，类不可继承，

C++中final只有两种：

1. 修饰类

2. 修饰虚函数

C++中const：

C++中的const用处很多，包括常量声明、变量修饰、常量引用、指针与const的组合、以及常量对象、成员函数。

修饰变量(基本类型变量、成员变量)：

• 修饰基本类型变量

  修饰变量也可以叫作常量的声明，使用const关键字可以修饰变量，一旦初始化后就不能再修改其值。

  const int MAX = 123;
  const double PI = 3.14;
  const int x = 334;
  

  以上的MAX、PI、x将都不能再修改其值；

  const定义的常量和#define宏定义的常量的区别

  const常量有数据类型，define宏定义常量没有，编译器会对const常量可以进行数据类型的安全检查，但是对于define宏定义，编译器只是将其进行字符替换，这样的字符替换很容易出错。

  比如以下代码，如果使用不加括号的宏定义，将不能正确计算(a+b)/5.0，而是变成计算a+(b/5.0)了。

  //define宏定义的做法
  #define a 2.0
  #define b 9.0
  #define c1 a+b   //不好的定义方法
  #define c2 ((a)+(b))  //推荐的定义方法
  void func1(void)
  {
      float d1 = c1/5.0;  //本意是想计算(a+b)/5.0，但字符替换使计算变成了a+b/5.0
      float d2 = c2/5.0;  //正确计算了((a)+(b))/5.0 = (a+b)/5.0
  }
  
  
  //推荐的const常量的做法
  const float a = 2.0;
  const float b = 9.0;
  const float c = a + b;
  void func2(void)
  {
      float d = c/5.0;  //正确计算了(a+b)/5.0
  }
  

• 修饰成员变量：在类中，使用const修饰的成员变量只能在初始化列表中进行初始化，并且不能在构造函数中修改其值。

  class MyClass {
  public:
      const int x;
      MyClass(int value) : x(value) {} // 初始化const修饰的成员变量
  };
  

  这段代码定义了一个类MyClass，其中有一个const修饰的整型成员变量x。在构造函数的初始化列表中对x进行初始化，且只能在初始化列表中初始化，不能在构造函数内部修改其值。

const与引用：

const引用可以绑定到临时对象或字面量，延长其生命周期。

用这种方式声明的引用，不能通过引用对目标变量的值进行修改,从而使引用的目标成为const，达到了引用的安全性。

const int& ref = 10; // 合法
// int& ref2 = 10;   // 非法：非常量引用不能绑定字面量
int x = 10;
const int& a = x;
x = 5;

const与指针："const在*前，数据不能改，const在*后，指针不能改"

• 常量指针：

  形式：const type* ptr(推荐) 或 type const* ptr

  这里可以理解为 const修饰的是type类型的数据：(const type)* ptr 或 (type const)* ptr，也就是说不能通过ptr修改值，但ptr可以指向其他地址。

  int a = 10, b = 20;
  const int* ptr = &a;
  *ptr = 30; // 错误：不能修改指向的数据
  ptr = &b;  // 正确：可以改变指针指向
  

  "const在*前，数据不能改"

• 指针常量：

  形式：type* const ptr

  这里可以理解为const修饰的是ptr：也就是说ptr一旦初始化指向之后就不能指向其他地址，但可以通过指针修改所指向的数据。

  int a = 10, b = 20;
  int* const ptr = &a;
  *ptr = 30; // 正确：可以修改a的值
  ptr = &b;  // 错误：不能改变指针指向
  

  "const在*后，指针不能改"

• 指向常量 的 常量指针：

  形式：const type* const ptr 或type const* const ptr

  既不能修改指针指向，也不能通过指针修改数据。

  int a = 10, b = 20;
  const int* const ptr = &a;
  *ptr = 30; // 错误
  ptr = &b;  // 错误
  

const在函数中的应用：

• const形参：避免函数内意外修改参数，常用于指针或引用传参。

  void print(const int* arr, int size) {
      for (int i = 0; i < size; ++i)
          std::cout << arr[i] << " "; // 只读访问
  }
  

• const成员函数：const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

  class MyClass {
      int value;
  public:
      int getValue() const { return value; } // 不会修改对象状态
  };
  

• const返回值：也是用const来修饰返回的指针或引用，保护指针指向的内容或引用的内容不被修改，也常用于运算符重载。

  函数三种返回类型：返回值、返回引用(&)、返回指针(*)；

  • 返回值：

    现在返回值使用const几乎没有意义，例如：

    const int ten(){
        return 10; //返回值是一个临时对象
    }
    
    //在后续的赋值中
    const int x = ten();
    

    在c++11之后，临时对象本来就不能被修改，所以 const int ten()和int ten()本质上效果一样。

  • 返回引用或者指针（这里用引用举例，指针一样的道理）：

    引用返回值不是重新创建一个对象，而是直接把函数内部（或外部某处）的对象引用返回给调用者；

    这样将不会产生对象拷贝（性能高），调用者直接访问的就是原对象。

    给引用加const可以保护原对象不被调用者修改，例如：

    class A {
    public:
    	int& getValue2(){
    		return m_value;
    	}
    	const int& getValue(){
    		return m_value;
    	}
    private:
    	int m_value = 10;
    };
    
    int main() {
    	A a;
    	a.getValue() = 100;   //不允许修改
    	a.getValue2() = 111;  //直接修改成员
    }
    

    getValue()将不允许修改成员变量m_value，而getValue2()将会直接修改成员变量m_value;

    一般get函数会被const修饰const int& getValue const(){return m_value}这样函数内的成员变量也会被const修饰，不允许修改。

    在返回const引用要注意：返回对象的生命周期必须比函数长，例如：

    const int& backNum() {
    	int num = 1;
    	return num;    //错误：num会在函数结束后消失，这块内存的位置也会给其他变量用
    }
    void otherFunc() {
    	int a = 100;
    	int b = 200;
    }
    int main() {
    
    	const int& c = backNum();
    	otherFunc();
    	cout << c << endl;
    }
    

    这样的引用指向在程序复杂的时候会造成悬空引用，未定义行为等危险。

const修饰对象：

const修饰的对象，其成员变量都不能被修改。

class MyClass {
public:
    int x;
};

const MyClass obj; // 常量对象
// obj.x = 10; // 错误，常量对象的成员变量不能被修改