重载成员运算符

Question

#include <iostream>
#include <vector>
struct Matrix;
struct literal_assignment_helper
{
mutable int r;
mutable int c;
Matrix& matrix;
explicit literal_assignment_helper(Matrix& matrix)
: matrix(matrix), r(0), c(1) {}
const literal_assignment_helper& operator,(int number) const;
};
struct Matrix
{
int rows;
int columns;
std::vector<int> numbers;
Matrix(int rows, int columns)
: rows(rows), columns(columns), numbers(rows * columns) {}
literal_assignment_helper operator=(int number)
{
numbers[0] = number;
return literal_assignment_helper(*this);
}
int* operator[](int row) { return &numbers[row * columns]; }
};
const literal_assignment_helper& literal_assignment_helper::operator,(int number) const
{
matrix[r][c] = number;
c++;
if (c == matrix.columns)
r++, c = 0;
return *this;
};

int main()
{
int rows = 3, columns = 3;
Matrix m(rows, columns);
m = 1, 2, 3,
4, 5, 6,
7, 8, 9;
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < columns; j++)
std::cout << m[i][j] << ' ';
std::cout << std::endl;
}
}

此代码的灵感来自DLib库中的矩阵类。

此代码允许分配用逗号分隔的文字值，如下所示：

Matrix m(rows, columns);
m = 1, 2, 3,
4, 5, 6,
7, 8, 9;

注意，你不能这样做：

Matrix m = 1, 2, 3, ...

这是因为构造函数不能返回对另一个对象的引用，这与operator=不同。

在这段代码中，如果literal_assignment_helper::operator,不是常量，那么这种数字链就不起作用，逗号分隔的数字被认为是逗号分隔的表达式。

为什么运算符必须是const？这里的规则是什么？

此外，operator,不是常量的影响是什么？它会被调用吗？

Answer 1

const literal_assignment_helper& operator,(int number) const;

辅助对象和矩阵中的逗号运算符都返回常量引用。因此，要在该引用上调用成员，成员函数/运算符必须是const限定的。

如果你去掉所有的惊愕，比如

literal_assignment_helper& operator,(int number);

这似乎也起到了作用。