Java中的final 和 C++中 _

2026/6/30 22:06:15

饰变量：final变量是不可改变的，但它的值可以在运行时刻初始化，也可以在编译时刻初始化，甚至可以放在构造函数中初始化，而不必在声明的时候初始化，所以下面的语句均合法：
```
final int i = 1; // 编译时刻 final int i2 = (int)(Math.Random() * 10); //运行时刻 final int i3; //构造函数里再初始化
```
final经常和static一起用，这种用法类似C++的常量，在Java中很常见，比如static final i = 10;但这里同样也是允许运行时刻初始化的。
修饰类对象：而如果修饰类对象，并不表示这个对象不可更改，而是表示这个这个变量不可再赋成其它对象，这就比较像 C++的Class const * p了(这样表明这个指向该Class的指针p不能再指向其他对象，指针常量，但是该对象中的值是可以修改的(const Class *p是常量指针，任何成员变量都不能修改))。
```
final Value v = new Value(); v = new Value(); //不允许！ v.some_method(); //允许
```
修饰方法：final修饰的方法是不能被重载的，类似于类中的private方法，所以private方法默认是final的；大致说就是变量不可修改（基本数据类型值不能修改，类类型引用不能修改），方法不可重载，类不可继承，

C++中final只有两种：

修饰类
修饰虚函数

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; } // 不会修改对象状态 };
```