Is the Eigen Library Modifying C++ Syntax

Question

I've been using Eigen recently and while everything makes sense, and I am just a little confused about how the library gets away with the weird syntax that it uses.

For example, when defining an matrix, you are supposed to do:

MatrixXd m(2,2); //defines a 3 x 4 matrix
m(0, 0) = 1;
m(0, 1) = 2;
m(1, 0) = 3;
m(1, 1) = 4;

or you can do something like:

Matrix3f m;
m << 1, 2, 3,
     4, 5, 6,
     7, 8, 9;
std::cout << m;

While these commands make sense conceptually to me, I am curious about how they make sense to the compiler. I thought << was used for bit-shifting and that the bracket notation was used for inputting parameter functions or something, not for parsing through a matrix structure like an array.

I haven't been working with C++ for long enough to understand all of this syntax, but I was wondering if the writers of Eigen somehow defined custom syntax or something.

[What are the basic rules and idioms for operator overloading?](https://stackoverflow.com/questions/4421706/what-are-the-basic-rules-and-idioms-for-operator-overloading) — Evg, Dec 11 '19 at 19:12
It seems that you are not familiar with [Operator overloading](https://en.cppreference.com/w/cpp/language/operators). — r3mus n0x, Dec 11 '19 at 19:12
With enough operator overloading you can almost turn C++ into a completely different language. — tadman, Dec 11 '19 at 19:13
Code can't modify core language syntax. But, operator overloading is part of the language. — Jesper Juhl, Dec 11 '19 at 19:15
Just wait until your first encounter with a lunatic using macros like `#define public private`. — user4581301, Dec 11 '19 at 19:19
Boost Spirit uses operator overloading to allow a pretty fair approximation of BNF grammars in C++. It's amazing. — Fred Larson, Dec 11 '19 at 19:25
@user4581301 Well that's not only lunatic, but also technically UB. — walnut, Dec 11 '19 at 19:30
With great power comes great responsibility, and C++ offers a LOT of power. — user4581301, Dec 11 '19 at 19:37

score 1 · Answer 1 · answered Dec 11 '19 at 19:47

I dont know Eigen and I think you should take a look at how these operators are implemented. However, a small toy example may help to see what is going on.

#include <array>
#include <iostream>

struct my_matrix {
    std::array< std::array< int,10>,10> data;
    int& operator()(size_t i,size_t j) { return data[i][j]; }
    const int& operator()(size_t i,size_t j) const { return data[i][j]; }
};


int main (){
    my_matrix x;
    x(1,1) = 42;
    std::cout << x(1,1);
}

Overloading operator() is rather flexible, because it allows aribtrary number of parameters. Returning a reference to an element of data allows the user to modify elements of a non-const my_matrix. To also allow accessing elements of a const my_matrix (without modifiying them) there is also a const overload of the operator. Similarly to overloading operator(), << is also an operator that can be overloaded to do different things. For more on operator overloading see here and here.

score 1 · Accepted Answer · answered Dec 11 '19 at 22:36

In both code blocks there is some operator overloading.

In the first code block, the line MatrixXd m(2,2); is creating the object, since it's the declaration and we have the type MatrixXd there. Therefore, the syntax m(i, j) must be a call to a constructor receiving two parameters (it can also be a constructor receiving more parameters as long as te other parameters have default values).

The other lines in the first code block are not calling the constructor and therefore the syntax m(i, j) means calling the implementation of operator()(i, j). Technically, something similar to operator()(int i, int j). In summary, the first code block only needs one operator overload, and it is one people often implement.

The second code block is what seems more like magic to me. The part m << Number means that the type of m, which is Matrix3f, has an overload for operator<<. Then I think that the type of whatever operator<< returns¹ must have an implementation of the comma operator to allow the 1, 2, 3, ... part. The comma operator is rarely used and it is the most obscure operator to overload IMHO. In summary, the second code block requires two operator overloads and one of them is more obscure. Yeah, it's magic.

¹ It could be a reference to m and thus be Matrix3f or it could even be a completely different type created by Eigen authors to allow this nice syntax to initialize a matrix.

FYI: The return type of `operator<<` is [`Eigen::CommaInitializer`](https://gitlab.com/libeigen/eigen/blob/master/Eigen/src/Core/CommaInitializer.h) which keeps a reference to the object which gets initialized, overloads `operator,` and internally keeps track how far the object is already initialized. — chtz, Dec 12 '19 at 16:54
I imagine that Eigen probably had a separated type just for this, since implementing this functionality directly in the matrix class would just make it more bloated. — darcamo, Dec 12 '19 at 20:48

Is the Eigen Library Modifying C++ Syntax

2 Answers2