一. 字面值常量

字面值常量是直接写在代码中的固定值。

类型 描述 示例
整型 整数值，可以使用不同的后缀来指定类型。 100 (int), 100L (long), 0xFF (十六进制)
浮点型 带有小数点的数值。 3.14 (double), 3.14F (float)
字符型 单个字符，用单引号 ' ' 括起来。 'A', '\n' (换行符)
字符串型 零个或多个字符的序列，用双引号 "" 括起来。 "Hello World", "" (空字符串)
布尔型 只有两个值：true 和 false。 true, false

1.字符常量

在 C++ 中，有一些特定的字符，当它们前面有反斜杠时，它们就具有特殊的含义，被用来表示如换行符（\n）或制表符（\t）等。下表列出了一些这样的转义序列码：

转义序列 含义
\ 字符
\’ ‘ 字符
\” “ 字符
\? ? 字符
\a 警报铃声
\b 退格键
\f 换页符
\n 换行符
\r 回车
\t 水平制表符
\v 垂直制表符
\ooo 一到三位的八进制数
\xhh . . . 一个或多个数字的十六进制数

下面的实例显示了一些转义序列字符：

#include <iostream>
using namespace std;
 
int main()
{
   cout << "Hello\tWorld\n\n";
   return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

Hello   World

2.字符串常量

字符串字面值或常量是括在双引号 “” 中的。一个字符串包含类似于字符常量的字符：普通的字符、转义序列和通用的字符。

您可以使用 做分隔符，把一个很长的字符串常量进行分行。

下面的实例显示了一些字符串常量：

#include <iostream>
#include <string>
using namespace std;

int main() {
    string greeting = "hello, runoob";
    cout << greeting;
    cout << "\n";     // 换行符
    string greeting2 = "hello, \
                        runoob";
    cout << greeting2;
    return 0;
}

hello, runoob
hello, runoob

二.定义常量

在 C++ 中，有两种简单的定义常量的方式：

  • 使用 #define 预处理器。
  • 使用 const 关键字。

1.#define 预处理器

下面是使用 #define 预处理器定义常量的形式：

#define identifier value

具体请看下面的实例：

#include <iostream>
using namespace std;
 
#define LENGTH 10   
#define WIDTH  5
#define NEWLINE '\n'
 
int main()
{
 
   int area;  
   
   area = LENGTH * WIDTH;
   cout << area;
   cout << NEWLINE;
   return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

50

2.const 关键字

一、const 修饰变量：定义常量

最基础的用法是将变量声明为 “只读”，一旦初始化后就不能被修改。

1. 普通变量
const int num = 10;  // num 是常量，初始化后不可修改
num = 20;  // 错误！不能给 const 变量赋值
  • 必须初始化：const 变量定义时必须赋值（或在构造函数初始化列表中初始化，针对类成员），否则编译报错。
  • 作用域：同普通变量（局部 const 变量仅在块内有效，全局 const 变量默认仅当前文件可见，类似 static）。
2. 指针与 const：两种场景

const 与指针结合时，需区分 “指针指向的内容不可改” 和 “指针本身不可改”，核心看 const 位置：

  • const 修饰指针指向的内容（常量指针）：
    const int* p; 或 int const* p;（两种写法等价）
    指针 p 可以指向其他地址，但不能通过 p 修改它所指向的内容。
    int a = 10, b = 20;
    const int* p = &a;
    *p = 30;  // 错误！不能修改指向的内容
    p = &b;   // 正确！指针本身可以改
  • const 修饰指针本身（指针常量）：
    int* const p;
    指针 p 一旦指向某个地址，就不能再指向其他地址，但可以通过 p 修改指向的内容。
    int a = 10, b = 20;
    int* const p = &a;  // 必须初始化（指针本身不可改）
    *p = 30;  // 正确！可以修改指向的内容
    p = &b;   // 错误！指针本身不能改
3. 引用与 const（常量引用）

const 修饰引用时，表示该引用是 “只读引用”，不能通过引用修改被引用的变量，但变量本身可以被修改（如果它不是 const 的）。

int a = 10;
const int& ref = a;  // 常量引用
ref = 20;  // 错误！不能通过引用修改 a
a = 20;    // 正确！变量 a 本身可以改

二、const 修饰函数：限制函数行为

1. 修饰函数参数

表示函数内部不会修改该参数（类似常量引用，增强安全性）。

void print(const std::string& str) {  // str 不可被修改
    // str = "hello";  // 错误！
    std::cout << str;
}
2. 修饰函数返回值

表示返回值是只读的，不能被修改（常用于返回指针或引用时，防止外部篡改内部数据）。

const int* getArray() {  // 返回常量指针
    static int arr[3] = {1,2,3};
    return arr;
}

int main() {
    const int* p = getArray();
    // *p = 10;  // 错误！返回值是 const 的
    return 0;
}

3. 修饰类的成员函数（const 成员函数）

在类中，const 放在成员函数参数列表后，表示该函数不会修改类的任何非静态成员变量，也不能调用非 const 成员函数（防止间接修改数据）。

class MyClass {
private:
    int num;
public:
    void setNum(int n) { num = n; }  // 非 const 函数，可修改成员
    int getNum() const {  // const 成员函数，不可修改成员
        // num = 10;  // 错误！不能修改成员变量
        return num;
    }
};

  • 调用规则：const 对象只能调用 const 成员函数，非 const 对象可以调用任意成员函数。

三、const 修饰类的成员变量

==类的 const 成员变量必须在构造函数的初始化列表中初始化==，不能在函数体内赋值。

常成员变量一旦初始化，就不能再被赋值或修改，任何试图修改它的操作（如在成员函数中赋值）都会导致编译错误。

每个对象的常成员变量是独立的，仅当前对象内不可变。

class MyClass {
private:
    const int MAX_SIZE;  // const 成员变量
public:
    // 必须在初始化列表中初始化
    MyClass(int size) : MAX_SIZE(size) {}
};