const括号前括号后

const成员

将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数

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

代码

class Date

{

public:
 Date(int year, int month, int day)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 void Print()
 {
 cout << "Print()" << endl;
 cout << "year:" << _year << endl;
 cout << "month:" << _month << endl;
 cout << "day:" << _day << endl << endl;
 }
 void Print() const

 {
 cout << "Print()const" << endl;
 cout << "year:" << _year << endl;
 cout << "month:" << _month << endl;
 cout << "day:" << _day << endl << endl;
 }

private:
 int _year; // 年

 int _month; // 月

 int _day; // 日

};

void Test()
{
 Date d1(2022,1,13);
 d1.Print();
 const Date d2(2022,1,13);
 d2.Print();
}

 取地址及const取地址操作符重载

这两个默认成员函数一般不用重新定义 ，编译器默认会生成。

class Date

{ 

public :
 Date* operator&()
 {
 return this ;
 }
 
 const Date* operator&()const

 {
 return this ;
 }

private :
 int _year ; // 年

 int _month ; // 月

 int _day ; // 日

}；

在C++中，const关键字在括号前后的位置决定了它的作用域和含义。下面是一些常见的用法和它们之间的区别：

1. const 在类型之前（括号之前）

当const出现在类型之前时，它表示该变量是一个常量，其值在初始化后不能被修改。

const int x = 10; // x 是一个整型常量，其值不能被修改

2. const 在指针类型声明中

const在指针类型声明中的位置决定了它是修饰指针本身还是指针所指向的数据。

const在*之前：表示指针所指向的数据是常量，不能通过这个指针来修改它所指向的数据。
 

int y = 20;
const int* ptr1 = &y; // ptr1 是一个指向整型常量的指针，不能通过 ptr1 修改 y 的值
//*ptr1 = 30; // 编译错误，不能修改通过 ptr1 指向的常量值

const在*之后（等价于在指针和*之间不加空格）：表示指针本身是常量，即指针的值（即它所指向的地址）不能被修改，但可以通过这个指针来修改它所指向的数据（如果该数据不是常量）。
 

int z = 30;
int* const ptr2 = &z; // ptr2 是一个常量指针，指向一个整型变量，不能改变 ptr2 的值（即它指向的地址），但可以修改 z 的值
//ptr2 = &y; // 编译错误，不能修改常量指针 ptr2 的值
*ptr2 = 40; // 可以通过 ptr2 修改 z 的值

const在指针类型和变量名之间（通常使用空格分隔）：这是为了明确性，虽然从语法上讲，const仍然修饰的是指针所指向的数据，但这样的写法可以使代码更易于阅读。
 

const int* ptr3 = &y; // 和 const int *ptr3 = &y; 是等价的

3. const 在函数参数中

当const用于函数参数时，它表示该参数在函数内部不会被修改。

void foo(const int& param) {
    // 不能修改 param 的值
}

4. const 在函数返回类型中

当const用于函数返回类型时，它表示返回的对象是一个常量。这通常用于返回指向内部数据的指针或引用，以确保这些数据不会被调用者修改。

const int* getPointer() {
    // ...
}

5. const 在成员函数之后

当const出现在类成员函数的参数列表之后时，它表示该函数是一个常量成员函数，即该函数不会修改它所属对象的任何非静态成员变量（除非这些变量被声明为mutable）。

class MyClass {
public:
    int value;

    int getValue() const {
        // 不能修改 value 的值
        return value;
    }
};

总结来说，const在括号前后的位置决定了它是修饰指针本身、指针所指向的数据、函数参数、函数返回类型，还是类成员函数。正确地使用const可以提高代码的可读性和安全性。

在C++中，const 关键字用于声明一个变量为常量，这意味着该变量的值在初始化后不能被修改。当 const 出现在括号后面时，它通常与函数参数、函数返回类型或类成员函数的修饰符一起使用。

1. 函数参数

当 const 用于函数参数时，它表示这个参数在函数内部不会被修改。这可以作为一种向调用者承诺的方式，让他们知道他们的数据不会被意外地更改。

void printValue(const int x) {
    // 不能修改 x 的值
    std::cout << x << std::endl;
}

2. 函数返回类型

当 const 用于函数返回类型时，它表示返回的对象是一个常量。这通常用于返回指向内部数据的指针或引用，以确保这些数据不会被调用者修改。

const int* getPointer() {
    static int value = 42;
    return &value;
}

const int& getReference() {
    static int value = 42;
    return value;
}

3. 类成员函数

在类成员函数中，const 可以有两种不同的用途：常量成员函数：这表示该函数不会修改类的任何成员变量（除非它们是 mutable 的）。
 

class MyClass {
public:
    int value;

    int getValue() const {
        // 不能修改 value 的值
        return value;
    }
};

常量成员函数参数：这表示传递给函数的对象是一个常量对象，因此成员函数不能修改它。
 

class MyClass {
public:
    void printValue(const MyClass& other) const {
        // 不能修改 this->value 或 other.value（如果它是可访问的）
        std::cout << other.value << std::endl;
    }
};

注意，在上面的例子中，printValue 函数有两个 const 修饰符：一个用于指定函数不会修改调用它的对象（即 *this），另一个用于指定传递给函数的参数是一个常量对象。

4. 指针和引用

const 也可以与指针和引用一起使用，以指定指针或引用所指向的对象是常量。

const int* ptr = &someInt; // ptr 是一个指向常量的指针
int* const constPtr = &someInt; // constPtr 是一个常量指针，指向一个整数
const int& ref = someInt; // ref 是一个对常量的引用

在这些例子中，const 的位置决定了它是应用于指针本身还是指针所指向的对象。