`operator<<` on comma separated values in C++

Question

The following syntax is working in OpenCV

Mat R = (Mat_<double>(4, 4) <<
        1,          0,           0, 0,
        0, cos(alpha), -sin(alpha), 0,
        0, sin(alpha),  cos(alpha), 0,
        0,          0,           0, 1);

How it can be? What operator was overloaded? What is the sense of this expression? Does comma operator can be overloaded in nowadays C++?

yep, the comma operator can be overloaded. The only ones you can't overload are the scope resolution op (`::`), the dot (`.`) and the ternary op (`?:`). — Luchian Grigore, Jun 12 '13 at 21:16
You need to look into the code. Maybe it's using [expression templates](http://stackoverflow.com/questions/2598579/c-expression-templates) — ruben2020, Jun 12 '13 at 21:28

nullptr · Accepted Answer · 2013-06-12T21:28:42.217

A comma operator can be overloaded, although it is typically not recommended (in many cases the overloaded comma is confusing).

The expression above defines 16 values for 4*4 matrix. If you are wondering how this is possible, I'll show a simpler example. Suppose we want to be able to write something like

MyVector<double> R = (MyVector<double>() << 1 , 2 , 3);

then we can define MyVector so that << and , operators append new value to the vector:

template<typename T> 
class MyVector: public std::vector<T> {
 public:
  MyVector<T>& operator << (T value) { push_back(value); return *this; }
  MyVector<T>& operator , (T value) { push_back(value); return *this; }
  ...
};

score 3 · Answer 2 · answered Jun 12 '13 at 21:28

Here is the actual code taken from here, as you can see the operator, is being used:

template<typename _Tp> template<typename T2> inline MatCommaInitializer_<_Tp>&
MatCommaInitializer_<_Tp>::operator , (T2 v)
{
     CV_DbgAssert( this->it < ((const Mat_<_Tp>*)this->it.m)->end() );
     *this->it = _Tp(v); ++this->it;
    return *this;
}

It takes the next value and simply puts it in the matrix, increments the iterator and then returns a reference to the MatCommaInitializer object (so these operators can be chained together).

score 2 · Answer 3 · edited Dec 15 '15 at 04:56

Below is the source code of OpenCV. We can know the class MatCommaInitializer_ overloaded the , operator, and overloaded the << operator in the global static field.

`
core.hpp
...
template<typename _Tp> class MatCommaInitializer_
{
public:
    //! the constructor, created by "matrix << firstValue" operator, where matrix is cv::Mat
    MatCommaInitializer_(Mat_<_Tp>* _m);
    //! the operator that takes the next value and put it to the matrix
    template<typename T2> MatCommaInitializer_<_Tp>& operator , (T2 v);
    //! another form of conversion operator
    Mat_<_Tp> operator *() const;
    operator Mat_<_Tp>() const;
protected:
    MatIterator_<_Tp> it;
};
...
`

`
mat.hpp
...
template<typename _Tp, typename T2> static inline MatCommaInitializer_<_Tp>
operator << (const Mat_<_Tp>& m, T2 val)
{
    MatCommaInitializer_<_Tp> commaInitializer((Mat_<_Tp>*)&m);
    return (commaInitializer, val);
}
...
`

So the working process of your code is as follows:

Mat_(4, 4) creates an instance that contains 4 row 4 column elements of double type.
It then calls the << overloaded operator and returns MatCommaInitializer_ instance.
It then calls the , overloaded operator and returns MatCommaInitializer_ instance, and so on.
Finally calls the constructor Mat(const MatCommaInitializer_<_Tp>& commaInitializer)

`operator<<` on comma separated values in C++

3 Answers3