const那些事

1.const含义

const是类型修饰符，可以用const来说明某个类型为常类型，常类型变量或对象的值是不能被更新的。

2.const作用

(1) 可以定义常量

const int a = 100;

(2) 类型检查
const常量是有类型的，编译器可以进行安全检查，与#define相比，#define只能进行简单的字符串替换，不能进行安全检查。const定义的变量类型，只有整数或者枚举，且以常量表达式初始化时，才能作为常量表达式，其他情况下被const修饰，只是用来限定，不能与常量混淆。

常量表达式（const experssion）：值不会改变，并且在编译过程就能得到计算结果的表达式。字面量属于常量表达式，用常量表达式初始化的const对象也是常量表达式。一个对象（或表达式）是不是常量表达式由它的数据类型和初始值共同决定。

const int a =1;		//常量表达式
cosnt int b=a+1;	//常量表达式
int c=2;		//初始值是字面值常量，当c数据类型是普通int。
const int d=fun();	//fun()值要在运行时得到，d不是字面值常量。

(3) const可以防止修改，起保护作用，增加程序健壮性。

void func(const int i)
{
	i++;//error!
}

(4) 可以节省空间，避免不必要的内存分配
const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是像#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝。

3.const对象默认为文件局部变量

注意：非const变量默认为extern。要使const变量能在其他文件中访问，必须在文件中显是式地指定它为extern。

extern是关于声明的关键字，变量的声明有两种情况：
1、一种是需要建立存储空间的。例如：int a 在声明的时候就已经建立了存储空间。
2、另一种是不需要建立存储空间的，通过使用extern关键字声明变量名而不定义它。 例如：extern int a 其中变量 a 可以在别的文件中定义的。
简单总结：除非有extern关键字，否则都是变量的定义。

未被const修饰的变量在不同文件中的访问

//file1.cpp
int ext
//fine2.cpp
#include<iostream>
extern int ext;
int main()
{
    std::cout<<(ext+10)<<std::endl;
}

const常量在不同文件中的访问

//extern_file1.cpp
extern const int ext=12;
//extern_file2.cpp
#include<iostream>
extern const int ext;
int main()
{
    std::cout<<ext<<std::endl;
}

小结：未被const修饰的变量，在不同文件中访问，不需要在之前的定义前面加extern，而const常量需要显式声明extern，并且需要做初始化，也就是extern const int ext=12，因为常量定义后就不能被修改了，所以定义时必须初始化。

4.定义常量

(1) 常量不能被修改

const int num = 10;
num = 11;//error! 表达式必须是可修改的左值

(2) 常量在定义的时候必须初始化，因为常量在定义后不能被修改

const int i;//error! 未初始化本地变量

5.指针与const

先说结论：如果const位于的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于的右侧，const就是修饰指针本身，即指针本身是常量。

与指针相关的const有三种：
(1) 指向常量的指针：指针所指的内容不能被修改

const int * a;
int const * a;

下面代码，ptr是一个指向int类型const对象的指针，const定义的是int类型，也就是ptr所指向的对象类型，而不是ptr本身，所以ptr可以不用赋初值。但不能通过ptr去修改指向对象的值。

const int * ptr;
*ptr = 11;//error! 表达式必须是可修改的左值

重点1：不能使用void* 指针保存const对象的地址，必须使用const void* 类型的指针保存const对象的地址。

const int p = 10;
void *vp = &p;//error! const int*类型的值不能用于初始化void*类型的实体
const void *vpr = &p;//ok!

重点2：我们允许把非const对象的地址赋值给const对象的指针，但是不能用const指针ptr来修改num的值。

const int *ptr;
int num = 3;
ptr = #//ok
//要修改num的值可以这样
int *ptr2 = #
*ptr2 = 4;
cout << *ptr << endl;

我们不能使用指向const对象的指针修改基础对象，然而如果该指针指向了非const对象，可用其他方式修改其所指的对象。可以修改const指针所指向的值的，但是不能通过const对象指针来进行而已！

小结：对于指向常量的指针，不能通过指针来修改对象的值。
也不能使用void* 指针保存const对象的地址，必须使用const void* 类型的指针保存const对象的地址。
允许把非const对象的地址赋值给const对象的指针，如果要修改指针指向的对象值，必须通过其他方式修改，不能通过当前的const指针直接修改。

(2) 常指针：指针的指向不可以修改，指针指向的内存的值可以修改

int num = 10;
int* const ptr = #//指向类型对象的const指针。或者说常指针、const指针。
*ptr = 11;
cout << num;

const指针必须初始化：

int* const ptr;//error! 未初始化本地变量

const指针的值不能被修改：

int num = 10;
int num2 = 20;
int* const ptr = #
ptr = &num2;//error! 表达式必须是可修改的左值

当把一个const常量的地址赋值给ptr时，会报错，因为只有ptr前面有const，说明指向不能改，但指向的内容可以修改，即ptr指向的是一个变量，而不是const常量，所以会报错：

const int num=0;
int * const ptr=# //error! const int* 类型的值不能用于初始化 int* const的实体
cout<<*ptr<<endl;

上述改为 const int * ptr或者const int *const ptr，都可以正常

(3) 指向常量的常指针：指针指向和指向的内容都不能被修改

const int p = 3;
const int * const ptr = &p; 
*ptr = 4;//error! 指针指向的内存的值不能被修改
int num = 5;
ptr = #//error! 指针指向不能被修改

6.函数中使用const

(1) const修饰函数返回值
这个和const修饰普通变量以及指针的含义基本相同：

① const int：本身无意义，因为参数返回本身就是赋值给其他的变量

const int func1();

② const int*：指针指向的内容不变

const int* func2();

③ int * const：指针本身不变，即指向不变

int* const func3();

(2) const修饰函数参数

① 传递过来的参数及指针本身在函数内部不可变。

void func(const int var);//传递过来的参数不可变
void func(int *const ptr);//指针本身不可变

表明参数在函数体内不能被修改，但基本没有意义，因为var本身就是形参，在函数内不会改变。包括传入的形参是指针也是一样。输入参数采用“值传递”，由于函数将自动产生临时变量用于复制该参数，该输入参数本来就无需保护，所以不要加const 修饰。

int func(const int var)
{
    var *= var;//error! 因为参数中限定了const，所以不能对var进行任何更新操作
    return var;
}

② 参数指针所指的内容为常量，不可变
其中src为输入参数，dst为输出参数，给src加上const后，如果函数里面试图更新src，那么编译器会指出错误，这是参数加const的作用之一。

void StringCopy(char *dst, const char *src);

③ 参数为引用，为了增加效率，同时防止修改
对于一个复杂的类对象参数而言，像void func(A a)这样声明的函数注定效率低，因为函数体内将产生A类型的临时对象用于复制参数a,而临时对象的构造、复制、析构过程都将消耗时间，为了提高效率，可以将函数写为void func(A &a)，因为引用传递仅借用一下参数的别名而已，不需要产生临时对象。

但void func(A &a)还存在一个缺点，就是传入的a可能会被改变，所以我们可以加上const修饰，即void func(const A &a)。

void func(const A &a);

小结：对于非内部数据类型的输入参数，应该将“值传递”的方式改为“const 引用传递”，目的是提高效率。例如将void func(A a) 改为void func(const A &a)。
对于内部数据类型的输入参数，不要将“值传递”的方式改为“const 引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如void func(int x) 不应该改为void func(const int &x)。

7.类中使用const

在任何一个类中，任何不会修改数据成员的函数都应该声明为const类型。

如果在编写const成员函数时，不慎修改了数据成员，或者调用了其他非const成员函数，编译器将指出错误，这无疑会提高程序的健壮性。

使用const关键字说明的成员函数，称为常成员函数，只有常成员函数才有资格操作常量或常对象。

没有使用const关键字说明的成员函数不能操作常对象。

对于类中的const成员变量，即常量成员，必须通过初始化列表进行初始化，因为常量成员只能初始化不能赋值，所以必须放在初始化列表里面，如下：

class Apple
{
private:
    int people[100];
public:
    Apple(int i); 
    const int apple_number;
};

Apple::Apple(int i):apple_number(i)
{

}

const对象只能访问const成员函数，而非const对象可以访问任意的成员函数，包括const成员函数：

//apple.cpp
class Apple
{
private:
    int people[100];
public:
    Apple(int i); 
    const int apple_number;
    void take(int num) const;
    int add(int num);
    int add(int num) const;
    int getCount() const;

};
//main.cpp
#include<iostream>
#include"apple.cpp"
using namespace std;

Apple::Apple(int i):apple_number(i)
{

}

int Apple::add(int num)
{
    take(num);
}

int Apple::add(int num) const
{
    take(num);
}

void Apple::take(int num) const
{
    cout<<"take func "<<num<<endl;
}

int Apple::getCount() const
{
    take(1);
    //add(); //error
    return apple_number;
}

int main()
{
    Apple a(2);
    cout<<a.getCount()<<endl;
    a.add(10);
    
    const Apple b(3);
    b.add(100);
    return 0;
}
//结果
take func 1
2
take func 10
take func 100

上面getCount()方法中调用了一个add方法，而add方法并非const修饰，所以运行报错。也就是说const对象只能访问const成员函数。

而add方法又调用了const修饰的take方法，证明了非const对象可以访问任意的成员函数,包括const成员函数。

除此之外，我们也看到add的一个重载函数，也输出了两个结果，说明const对象默认调用const成员函数。

我们除了上述的初始化const常量用初始化列表方式外，也可以通过下面方法：

static const int apple_number

第二：在外面初始化：

const int Apple::apple_number=10;

当然，如果你使用c++11进行编译，直接可以在定义出初始化，可以直接写成：

static const int apple_number=10;
或者
const int apple_number=10;

这两种都在c++11中支持！

编译的时候加上-std=c++11即可！

这里提到了static，下面简单的说一下：

在C++中，static静态成员变量不能在类的内部初始化。在类的内部只是声明，定义必须在类定义体的外部，通常在类的实现文件中初始化。

在类中声明：

static int ap;

在类实现文件中使用：

int Apple::ap=666

对于此项，c++11不能进行声明并初始化，也就是上述使用方法。

8. const修饰虚函数

在C++中，对于两个函数，一个有const修饰，一个没有const修饰，认为这两个函数是不同的函数。

虚函数的要求是，函数原型相同，函数原型包括：函数返回值、函数名、参数列表、const修饰符。这里const修饰符包括函数返回值的修饰，函数形参的修饰，函数本身的修饰。只要有一处没有对上 ，那么就不是虚函数的override，而是调用基类的同名函数。

所以对于基类的cosnt虚函数，如果子类重写忘记加上const，编译器会认为是基类的函数。

#include <iostream>
using namespace std;

class Father
{
public:
    virtual void show()const
    {
        cout << "this is Father." << endl;
    }
};

class Son: public Father
{
public:
    virtual void show()　　// 没有const 该函数为Son的虚函数，只有Son以及其子类才拥有，和Father没关系
    {
        cout << "this is Son." << endl;
    }
};

void main()
{
    Father*p = new Father;
    p->show();　　//  输出  "this is Father"
    p = new Son;
    p->show();　　//  输出  "this is Father"
}

那如果基类虚函数结尾是const = 0，而子类没有添加const会怎么样？那么使用该子类的时候编译器将报错，不让你编译通过。

扩展一下，假如在子类实现了父类的const虚函数，并且声明一个同名未加const的函数，那么子类该如何调用两个同名函数？代码如下：

#include <iostream>
using namespace std;

class Father
{
public:
    virtual void show()const
    {
        cout << "this is Father." << endl;
    }
};

class Son: public Father
{
public:
    virtual void show()　　// 没有const
    {
        cout << "this is Son." << endl;
    }

    virtual void show() const
    {
        cout<<"this is no const Son."<<endl;
    }
};

void main()
{
    p1 = new Son;
    p1->show();　　//  输出  "this is Son"

    const p2 = new Son;    //  加了const，也就是常对象，只能调用常函数
    p2->show();    //  输出  "this is no const Son"

}

9. 常函数、常对象

常函数是一种成员函数，它保证不会修改其所属对象的状态。这意味着常函数内部不能修改对象的任何非静态成员变量，也不能调用任何非常成员函数。（但可以修改静态成员变量，因为其不属于任何单个对象）

通过在适当的地方使用常函数，你可以创建更健壮、更易于理解和维护的C++程序。

基本语法：

class Example {
public:
    int value;

    // 常函数声明
    void display() const 
    {
        std::cout << "Value: " << value << std::endl;
        // 不允许修改成员变量
        // 不允许调用非常成员函数
    }
};

实例代码：

假设我们有一个 BankAccount 类，它包含了账户的余额，并提供了查询余额的功能。在这个场景中，查询余额的操作不应该修改账户的状态，因此这个函数应该被声明为常函数。

class BankAccount {
private:
    double balance;  // 账户余额

public:
    // 构造函数
    BankAccount(double initialBalance) : balance(initialBalance) {}

    // 常函数，用于获取账户余额
    double getBalance() const 
    {
        return balance;
    }

    // 一个非常函数，用于存款
    void deposit(double amount) 
    {
        if (amount > 0) 
        {
            balance += amount;
        }
    }

    // 另一个非常函数，用于取款
    void withdraw(double amount) 
    {
        if (amount > 0 && balance >= amount) 
        {
            balance -= amount;
        }
    }
};

int main() 
{
    BankAccount account(1000.0);

    // 存款
    account.deposit(500.0);

    // 查询余额
    std::cout << "Current balance: $" << account.getBalance() << std::endl;

    // 取款
    account.withdraw(200.0);

    // 再次查询余额
    std::cout << "Current balance: $" << account.getBalance() << std::endl;

    return 0;
}

常对象
常对象是指其状态不可更改的对象。一旦创建，常对象的任何成员变量都不能被修改（除非它们被声明为 mutable）。对于常对象来说，我们只能调用该对象的常函数，不能调用会修改对象状态的非常函数。

基本语法：

const Example ex;

在这个例子中，ex 是一个常对象，它的任何成员变量都不能被修改。

举一个错误的例子：

#include <iostream>
#include <string>

class Person 
{
private:
    std::string name;
    int age;

public:
    // 构造函数
    Person(std::string name, int age) : name(name), age(age) {}

    // 常函数，用于获取姓名
    std::string getName() const 
    {
        return name;
    }

    // 常函数，用于获取年龄
    int getAge() const 
    {
        return age;
    }

    // 非常函数，用于设置年龄
    void setAge(int newAge) 
    {
        age = newAge;
    }
};

int main() {
    const Person person("Alice", 30);

    // 调用常函数
    std::cout << "Name: " << person.getName() << ", Age: " << person.getAge() << std::endl;

    // 尝试用常对象调用非常函数（将会引起编译错误）
    person.setAge(31); // 错误：不能在常对象上调用非常函数

    return 0;
}

在这个例子中，person 是一个常对象。我们可以在其上调用 getName 和 getAge 这两个常函数，因为它们不会修改对象的状态。然而，尝试在 person 上调用 setAge 这个非常函数会导致编译错误，因为常对象不允许修改其状态。