C++const正确性实践

C++const正确性实践

const正确性是C++编程的重要原则，通过const关键字明确表达不可变性，提高代码的安全性和可读性。

const成员函数承诺不修改对象状态，可以被const对象调用。

#include
#include
#include

class Point {
int x_, y_;

public:
Point(int x, int y) : x_(x), y_(y) {}

int x() const { return x_; }
int y() const { return y_; }

void set_x(int x) { x_ = x; }
void set_y(int y) { y_ = y; }

double distance_from_origin() const {
return std::sqrt(x_ * x_ + y_ * y_);
}

void display() const {
std::cout << "(" << x_ << ", " << y_ << ")\n";
}
};

void const_member_function() {
const Point p1(3, 4);
std::cout << "x: " << p1.x() << ", y: " << p1.y() << "\n";
std::cout << "Distance: " << p1.distance_from_origin() << "\n";
p1.display();
}

const引用参数避免拷贝并保证不修改参数。

void print_vector(const std::vector& vec) {
for (int val : vec) {
std::cout << val << " ";
}
std::cout << "\n";
}

int sum_vector(const std::vector& vec) {
int total = 0;
for (int val : vec) {
total += val;
}
return total;
}

void const_reference_params() {
std::vector numbers = {1, 2, 3, 4, 5};
print_vector(numbers);
std::cout << "Sum: " << sum_vector(numbers) << "\n";
}

const返回值防止对临时对象的修改。

class String {
char* data_;

public:
explicit String(const char* str) {
data_ = new char[strlen(str) + 1];
strcpy(data_, str);
}

~String() {
delete[] data_;
}

const char* c_str() const {
return data_;
}

String(const String&) = delete;
String& operator=(const String&) = delete;
};

void const_return_value() {
String s("Hello");
const char* str = s.c_str();
std::cout << "String: " << str << "\n";
}

mutable关键字允许const成员函数修改特定成员。

class Cache {
mutable int access_count_;
mutable bool cached_;
mutable int cached_value_;
int expensive_computation() const {
std::cout << "Computing...\n";
return 42;
}

public:
Cache() : access_count_(0), cached_(false), cached_value_(0) {}

int get_value() const {
++access_count_;
if (!cached_) {
cached_value_ = expensive_computation();
cached_ = true;
}
return cached_value_;
}

int access_count() const {
return access_count_;
}
};

void mutable_example() {
const Cache cache;
std::cout << "Value: " << cache.get_value() << "\n";
std::cout << "Value: " << cache.get_value() << "\n";
std::cout << "Access count: " << cache.access_count() << "\n";
}

const迭代器和const_iterator有不同的含义。

void const_iterators() {
std::vector vec = {1, 2, 3, 4, 5};

for (std::vector::const_iterator it = vec.begin(); it != vec.end(); ++it) {
std::cout << *it << " ";
}
std::cout << "\n";

const std::vector const_vec = {10, 20, 30};
for (auto it = const_vec.begin(); it != const_vec.end(); ++it) {
std::cout << *it << " ";
}
std::cout << "\n";
}

const指针和指向const的指针是不同的概念。

void const_pointers() {
int x = 10;
int y = 20;

const int* ptr1 = &x;
std::cout << "ptr1: " << *ptr1 << "\n";
ptr1 = &y;

int* const ptr2 = &x;
*ptr2 = 30;
std::cout << "x after ptr2: " << x << "\n";

const int* const ptr3 = &x;
std::cout << "ptr3: " << *ptr3 << "\n";
}

const正确性在类设计中确保接口的清晰性。

class Rectangle {
int width_, height_;

public:
Rectangle(int w, int h) : width_(w), height_(h) {}

int width() const { return width_; }
int height() const { return height_; }

int area() const {
return width_ * height_;
}

void set_width(int w) {
width_ = w;
}

void set_height(int h) {
height_ = h;
}

void scale(double factor) {
width_ = static_cast(width_ * factor);
height_ = static_cast(height_ * factor);
}
};

void const_interface_design() {
const Rectangle rect(10, 20);
std::cout << "Area: " << rect.area() << "\n";

Rectangle mutable_rect(5, 10);
mutable_rect.scale(2.0);
std::cout << "Scaled area: " << mutable_rect.area() << "\n";
}

const正确性是编写高质量C++代码的重要实践，它使代码的意图更加明确，减少错误。