怎么把网站做成软件,网页设计教程零基础,做网站用什么颜色好,邢台网站制作费用C中的const是一种常量修饰符。在变量、函数参数和成员函数中使用const可以限制其对数据的修改。
const修饰的数据在定义时必须进行初始化#xff0c;且不能被修改#xff0c;因此使用const可以提高代码的安全性和可读性。在C中#xff0c;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修饰的成员变量和成员函数、以及常量对象的初始化等细节。
// const修饰变量
#include iostreamint main()
{// 定义并初始化Nconst 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 iostreamclass 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 iostreamclass 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对象指定类型为CircleShape 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 iostreamclass 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 iostreamclass 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 iostreamclass 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_castint(p) std::endl;return 0;
}
// const在函数前面修饰
// 在C中const可以用在函数的前面和后面
// 用在函数后面是用来修饰成员函数用在函数前面则是用来修饰函数返回值。它们的区别在于const的含义不同。
// const修饰成员函数和修饰函数返回值都能达到保护数据不被修改的目的但用法和意义不同。必须根据实际情况选择适当的修饰。
// const在函数前面为常量函数const在函数后面为常量成员函数
// 常量成员函数用于定义不能修改任何非静态成员数据的函数或称“只读”函数而常量函数用于定义不能修改其返回值的函数使返回值更安全。
#include iostreamclass 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 iostreamclass 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 iostreamclass 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;
}
