c++关键字const

这篇具有很好参考价值的文章主要介绍了c++关键字const。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

C++中的const是一种常量修饰符。在变量、函数参数和成员函数中使用const可以限制其对数据的修改。

const修饰的数据在定义时必须进行初始化，且不能被修改，因此使用const可以提高代码的安全性和可读性。在C++中，const修饰的成员函数表示该函数保证不会修改类的成员变量，从而保证对象的状态不会被改变。使用const修饰的成员函数可以帮助程序员更好地实现不变类（不修改内部状态的类）和避免不必要的拷贝构造函数的调用。

C++中使用`const`的主要目的是为了告诉编译器某些变量或函数参数、类成员函数、关键字等不会被修改，从而提高代码的可读性、可维护性和安全性。使用`const`的主要注意事项如下：

1. 使用const修饰变量

使用const修饰变量时，需要注意以下几点：

- 定义时必须进行初始化，一旦初始化后，就不能再修改变量的值。

- const定义的常量存放在静态存储区，而不是栈中。

- 通常采用const全大写的命名方式来表示常量，提高可读性。

- 在函数参数列表中，const修饰的参数表明函数不能修改该参数的值。

2. 在类中使用const修饰成员变量

在类中使用const修饰成员变量时，需要注意以下几点：

- const成员变量必须在定义时进行初始化，在构造函数中无法进行初始化。

- const成员变量只能通过成员初始化列表进行初始化。

- 可以在构造函数中通过调用其他函数或者使用默认参数对const成员变量进行初始化。

- const成员变量的值不能在构造函数中被修改。

3. 在类中使用const修饰成员函数

在类中使用const修饰成员函数时，需要注意以下几点：

- const成员函数不能修改类的非静态成员变量。

- 如果类中有一个const成员函数，那么该成员函数是类的常量成员函数，只能被const对象调用，不能被非const对象调用。

- 具有相同名称和参数的另外一个非const成员函数可以修改类的成员变量。

使用const可以使你的代码更加安全、可读性更高，并且有助于防止一些不必要的错误。

为了避免const使用时出现的错误，需要在使用时注意以上细节，如常量的定义和初始化、使用const修饰的指针、const修饰的成员变量和成员函数、以及常量对象的初始化等细节。文章来源地址https://www.toymoban.com/news/detail-805035.html

// const修饰变量
#include <iostream>

int main()
{
    // 定义并初始化N
    const int N = 10;
    // 使用const修饰变量N，使其成为一个常量。因为N是常量，所以可以用它定义数组并使用，但是在后面试图修改N的值是会编译错误。
    int arr[N];
    for (int i = 0; i < N; i++)
    {
        arr[i] = i;
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
    //const修饰的N不能修改, 编译报错，error: assignment of read-only variable ‘N’
    // N = 20;
    return 0;
}

// const修饰函数参数
#include <iostream>

// const修饰函数参数
void arrPrint(const int arr[], const int size)
{
    for (int i = 0; i < size; i++)
    {
        std::cout << arr[i]  << " ";
    }
    std::cout << std::endl;
    // const修饰的参数不能修改，编译报错试图对只读的数组元素进行赋值。error: assignment of read-only location ‘* arr’
    // arr[0] = 10;
    // size = 6;
}

int main()
{
    int arr[5] = {1, 2, 3, 4, 5};
    int size = sizeof(arr) / sizeof(arr[0]);
    arrPrint(arr, size);
    return 0;
}

// const修饰成员函数
#include <iostream>

class Circle {
public:
    // 常量数据成员通常不直接在声明时初始化赋值，不合适，一般使用成员初始化列表进行赋值
    Circle(double r) : radius(r) {}
    // const修饰成员函数
    double getArea() const {
        return 3.1415926 * radius * radius;
    }
    // const修饰成员函数
    double getRadius() const {
        // const修饰的radius不能修改,编译报错，error: assignment of member ‘Circle::radius’ in read-only object
        // radius = 3;
        return radius;
    }

    // const修饰数据成员
    const double radius;
    // 常量数据成员通常不直接在声明时初始化赋值，不合适，一般使用成员初始化列表进行赋值
    // const double radius = 5.0;
};

int main()
{
    Circle c(5.0);
    std::cout << "radius : " << c.getRadius() << std::endl;
    std::cout << "area   : " << c.getArea() << std::endl;
    // const修饰的radius不能修改,编译报错，error: assignment of read-only member ‘Circle::radius’
    // c.radius = 3;

    return 0;
}

// const修饰的类枚举
#include <iostream>

class Shape {
public:
    enum class Type : int {
        Circle = 0,
        Square = 1,
    };
    Shape(Type t) : type(t) {}
    
    void getType() const {
        switch (type)
        {
        case Type::Circle:
            std::cout << "circle" << std::endl;
            break;
        case Type::Square :
            std::cout << "square" << std::endl;
        default:
            break;
        }
    }


    // const修饰的类枚举
    const Type type;
};


int main()
{
    // 创建Shape对象，指定类型为Circle
    Shape c(Shape::Type::Circle);
    c.getType();
    Shape s(Shape::Type::Square);
    s.getType();
    // const修饰的类枚举不能修改,编译错误，error: assignment of read-only member ‘Shape::type’
    // c.type = Shape::Type::Square;

    return 0;
}

// const修饰的静态类变量
#include <iostream>

class Counter {
public:
    Counter() {
        count++;
    }
    Counter(const Counter & c) {
        count++;
    }
    static int getCount() {
        return count;
    }
private:
    // const修饰的静态成员变量
    static const int LIMIT = 10;
    // 类静态变量
    static int count;
};
// 定义静态成员变量
int Counter::count = 0;

int main()
{
    Counter c1, c2, c3;
    std::cout << "count : " << Counter::getCount() << std::endl;
    // const修饰的类静态变量不能修改,编译错误,error: assignment of read-only variable ‘Counter::LIMIT’
    // Counter::LIMIT = 20;
    return 0;
}

// const修饰的非静态成员函数
#include <iostream>

class Circle{
public:
    Circle(double r) : radius(r) {}
    double getArea() const {
        return PI * radius * radius;
    }
    double getRadius() const {
        return radius;
    }

private:
    // 定义静态常量
    static const double PI;
    double radius;
};

const double Circle::PI = 3.1415926;

int main()
{
    const Circle c(5.0);
    std::cout << "area : " << c.getArea() << std::endl;
    return 0;
}

// const修饰的类转换函数
#include <iostream>

class Point {
public:
    Point(int x, int y) : _x(x), _y(y) {}
    int getX() const {
        return _x;
    }
    int getY() const {
        return _y;
    }
    // 类中定义了一个使用const修饰的类转换函数：`operator int()`。
    // 该函数将一个Point对象转换为一个整数，这里我们将`_x`和`_y`简单地相加。
    // 在`main()`函数中，我们创建了一个`Point`对象，并将其转换为整数输出。
    // 由于在类转换函数中使用了const修饰，保证了不会修改对象
    operator int() const {
        return _x + _y;
    }
private:
    int _x;
    int _y;
};

int main()
{
    Point p(3, 4);
    std::cout << static_cast<int>(p) << std::endl;
    return 0;
}

// const在函数前面修饰
// 在C++中，const可以用在函数的前面和后面，
// 用在函数后面是用来修饰成员函数，用在函数前面则是用来修饰函数返回值。它们的区别在于const的含义不同。
// const修饰成员函数和修饰函数返回值都能达到保护数据不被修改的目的，但用法和意义不同。必须根据实际情况选择适当的修饰。
// const在函数前面为常量函数，const在函数后面为常量成员函数
// 常量成员函数用于定义不能修改任何非静态成员数据的函数（或称“只读”函数），而常量函数用于定义不能修改其返回值的函数，使返回值更安全。
#include <iostream>

class Rectangle {
public:
    Rectangle(int w, int h) : width(w), height(h) {}
    // const在函数后面用来修饰成员函数，表示该成员函数是一个常量成员函数，不能修改类的非静态成员变量。
    // 常量成员函数也不能被非const对象调用。
    int getArea() const;
    // 返回值类型为`const int &`，表示返回的是一个常量引用，不能修改它所引用的变量。
    // const在函数前面用来修饰函数返回值，表示该函数返回的值是一个常量。
    // 通常用于返回一个常量指针或常量引用，以避免返回值被修改。
    const int &max(const int &a, const int &b) {
        return (a > b) ? a : b;
    }

    // C++中`const`关键字可以用在函数返回值的前面或后面，
    // 用在函数返回类型前面就表示返回值是一个`const`常量，用在类型后面表示该函数是一个常量函数。
    // 所以`int const func()`和`const int func()`是等同的，它们都表示一个返回值是`const int`类型的函数。
    // 这种用法通常用于返回一个常量对象，或常量指针、常量引用等等，以避免返回值被修改。
    const int get100() {
        return 100;
    }
    int const get200() {
        // const修饰的是返回值，函数可以修改成员变量的值
        this->width = 200;
        return 200;
    }
    int getWidth() const {
        // 函数被声明为常量成员函数，因此不能修改成员变量的值
        // 不能修改成员变量，编译错误，error: assignment of member ‘Rectangle::m_val’ in read-only object
        // this->m_val = 100;
        return this->width;
    }
    void setValue(int value) {
        this->width = value;
    }

    // 当`const`关键字放在成员函数的前面时，它修饰的是函数的返回值，表示这个函数的返回值是一个常量。
    // 这种函数返回类型前加`const`关键字的写法，通常用于返回一个常量整数、常量指针或常量引用等，以避免返回值被修改。
    // 常量函数的常量限制作用于函数的返回值上，而非函数的实现代码中。
    // 函数的返回值类型被定义成`const int`，表明函数返回了一个常量整数
    const int getHeight() const {
        return this->height;
    }
private:
    int width, height;
};

// 常成员函数，在函数尾部加const，常成员函数在类外实现的时候const不能丢掉，因为const时函数的一部分
// 在常成员函数中不能修改任何数据成员的值，常成员函数内不能对类的任何数据成员进行修改，
// 即当前类中凡是能用this指出来的成员都改不了，但是可以访问，就是只能看不能改，但是静态成员变量可以修改。
int Rectangle::getArea() const {
    // error: assignment of member ‘Rectangle::width’ in read-only object
    // width = 10;
    return width * height;
}



int main()
{
    const Rectangle r(5, 10);
    std::cout << "area : " << r.getArea() << std::endl;

    // const放函数前面
    Rectangle r1(5, 10);
    // 常量引用`maxVal`来引用`max()`函数返回的值，因此不能修改`maxVal`的值。
    // 报错，error: passing ‘const Rectangle’ as ‘this’ argument discards qualifiers [-fpermissive]
    // const int & max = r.max(5, 10);
    const int & maxVal = r1.max(5, 10);
    // error: assignment of read-only reference ‘maxVal’
    // maxVal = 20;
    std::cout << "max val : " << maxVal << std::endl;
    // 报错，error: passing ‘const Rectangle’ as ‘this’ argument discards qualifiers [-fpermissive]
    // r.get100();
    const int a1 = r1.get100();
    // 报错，error: expected initializer before ‘a2’
    // 这个错误是因为`r1`对象是一个`const`对象，在`const`对象上调用非常量成员函数是不允许的，
    // 因为非常量成员函数可以修改对象的状态，会破坏对象的不可变性。
    // int cosnt a2 = r1.get100();
    std::cout << "get100  : " << r1.get100() << std::endl;
    std::cout << "get200  : " << r1.get200() << std::endl;

    // 创建了一个常量对象`obj`，也不能修改其中的成员变量。
    const Rectangle obj0(10, 20);
    std::cout << obj0.getWidth() << std::endl;
    // 不能修改常量对象的成员变量,编译错误，error: passing ‘const Rectangle’ as ‘this’ argument discards qualifiers [-fpermissive]
    // obj0.setValue(10);

    Rectangle obj1(10, 30);
    std::cout << obj1.getHeight() << std::endl;
    // 通过调用常量函数`obj.getValue()`来获取常量整数值，并将结果保存到一个常量值`value`中，这样可以防止常量值被修改。
    int a3 = obj1.getHeight();
    const int a4 = obj1.getHeight();
    std::cout << "a3 = " << a3 << ", a4 = " << a4 << std::endl;

    return 0;
}

// 常量成员函数和常量函数的区别
// - 常量成员函数在函数声明的结尾处加上`const`修饰符，用于定义不会修改任何非静态成员数据的函数。
// 也就是说，常量成员函数将其所操作的对象指定为常量，从而导致它不能在函数调用中修改类中的任何非静态成员变量。
// - 常量函数在函数返回类型前加上`const`修饰符，用于定义不能修改其返回值的函数。
// 也就是说，常量函数指定了函数返回的值是一个常量，无法被修改。
#include <iostream>

class Rectangle {
public:
    Rectangle(int width, int height) : m_width(width), m_height(height) {}
    // 常量成员函数
    int getArea() const;
    int getValue() const;
    void setValue(int value);
    // 常量函数
    int const getWidth() const {
        return m_width;
    }
    const int getHeight() const {
        return m_height;
    }
    const int get100() {
        return m_height;
    }
    const int get200() {
        return m_height;
    }
    
private:
    int m_width;
    int m_height;
    int m_value;
};

// 常成员函数，在函数尾部加const，常成员函数在类外实现的时候const不能丢掉，因为const时函数的一部分
// 在常成员函数中不能修改任何数据成员的值，常成员函数内不能对类的任何数据成员进行修改，
// 即当前类中凡是能用this指出来的成员都改不了，但是可以访问，就是只能看不能改，但是静态成员变量可以修改。
int Rectangle::getArea() const {
    return m_width * m_height;
}

int Rectangle::getValue() const {
    return m_value;
}

void Rectangle::setValue(int value) {
    m_value = value;
}

int main()
{
    // c++非常量对象可以调用类的常量成员函数,常量对象不能调用非常量成员函数
    const Rectangle r(3, 4);
    // 调用常量成员函数
    std::cout << "Area: " << r.getArea() << std::endl;
    // 调用常量函数
    const int value = r.getValue();
    std::cout << "Value: " << value << std::endl;
    // 不能在常量对象上调用非常量成员函数
    // r.setValue(5);  // 编译错误
    const Rectangle r1(10, 20);
    std::cout << "width : " << r1.getWidth() << ", height : " << r1.getHeight() << std::endl;
    // 常量对象不能调用非常量成员函数，报错，error: no matching function for call to ‘Rectangle::setValue() const’
    // r1.setValue();
    // r1.get100();
    // r1.get200();

    return 0;
}

// const常量对象
// C++中，如果对象被声明为常量对象，那么就意味着该对象的值不能被修改。
// 常量对象是指对象在创建后，其值被确定不变，不允许被修改。

// 非常量对象可以调用常量成员函数，因为常量成员函数不会修改对象的状态，所以没有任何风险和限制。
// 而常量对象不能调用非常量成员函数，因为非常量成员函数有可能会修改对象的状态，这会与常量对象的定义相矛盾，所以编译器会拒绝这样的调用并报错。
#include <iostream>

class Rectangle {
public:
    Rectangle(int width, int height) : m_width(width), m_height(height) {}
    int getArea() const;
    void setValue(int value);
private:
    int m_width;
    int m_height;
};

// 常成员函数，在函数尾部加const，常成员函数在类外实现的时候const不能丢掉，因为const时函数的一部分
// 在常成员函数中不能修改任何数据成员的值，常成员函数内不能对类的任何数据成员进行修改，
// 即当前类中凡是能用this指出来的成员都改不了，但是可以访问，就是只能看不能改，但是静态成员变量可以修改。
int Rectangle::getArea() const {
    return m_width * m_height;
}

void Rectangle::setValue(int value) {
    m_width = value;
    m_height = value;
}


int main() {
    Rectangle r1(2, 3);  // 非常量对象
    // 在C++中，`const`关键字可以用在类型的右侧或左侧。
    // 当`const`关键字出现在类型名称的左侧时，它会作用于变量名之前的类型部分；
    // 当`const`关键字出现在类型名称的右侧时，它会作用于变量名之后的类型部分。
    // int const b = 20;  // 常量整数，等价于const int b = 20;
    // Rectangle const r3(5, 6);  // 常量对象，值不可修改，等价于const Rectangle r3(5, 6);
    const Rectangle r2(3, 4);  // 常量对象
    Rectangle const r3(5, 6);  // 常量对象

    r1.getArea();  // 非常量对象调用常量成员函数
    r2.getArea();  // 常量对象调用常量成员函数

    // r2.setValue(5);  // 编译错误，常量对象不能调用非常量成员函数
    r1.setValue(5);  // 非常量对象可以调用非常量成员函数

    return 0;
}

到了这里，关于c++关键字const的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！