Class method returning reference C++/SystemC

Question

To pass user-defined datatypes into SystemC channels templates requires these datatypes to be defined as a class that implements also different kind of operators <<, =, ==.

I need to define a sc_fifo such as:

sc_fifo<route_t>

For this to be correct, route_t datatype has to be written as in the below example.

class route_t
{
    public: 
    route_dir_t                     route_dir; 
    unsigned int                    vc_index; 

    // methods allowing the structure to be passed into SystemC channels
    // constructor
    route_t(route_dir_t _route_dir, unsigned int _vc_index) {
        route_dir = _route_dir; 
        vc_index  = _vc_index; 
    }

    inline bool operator == (const route_t& _route) const {
        return (route_dir == _route.route_dir && vc_index == _route.vc_index); 
    }

    inline route_t& operator = (const route_t& _route) {
        route_dir = _route.route_dir; 
        vc_index  = _route.vc_index; 
        return *this; 
    }

}; // end class route_t

Why does SystemC require such an implementation?
Why does the operator= need to return a reference to the object itself? It just updates the internal members.
Can the datatype be defined as a struct instead with internal methods implementing the required operators?
Why is inline used in this context?
How can returning *this be equivalent to returning a reference to the object as expected in the declaration of the method?

Why not just ask about assignment operator's semantics instead of posting mainly irrelevant stuff? It would make the question(s) clearer. — juanchopanza, Jun 14 '15 at 13:10
Not everyone is expert in c++ here and thanks for your nice comments. Irrelevant to you does not make it irrelevant to everyone. I'll delete the post and refer to the answers which I tried to find before posting. — Theo, Jun 14 '15 at 13:19
Most of your post is irrelevant to the questions you're asking, which makes the post confusing. — juanchopanza, Jun 14 '15 at 13:21
Fine, keep it your way. Just don't be surprised if you don't get much help. — juanchopanza, Jun 14 '15 at 13:37

score 0 · Answer 1 · answered Jun 14 '15 at 13:11

operator= is expected to return a reference to the class itself so you can do any of the following.

a = b = c;
if (a = b) { } // check the resulting value of a
(a = b).foo();

Although these may not be things you expect to do it follows the general guideline of having user defined objects behave in the same way as built in objects behave.

As for returning a reference, you have to make sure that you don't return a reference to a local object but it has the expected semantics.

Glenn Teitelbaum · Answer 2 · 2015-06-14T13:21:12.553

Look at the following:

Myclass a, b, c;

a=b=c=otherMyclass;

For that to work, each operator= must return the reference to be used by the next in the chain.

Also you should generally check that the assignment is not to itself

    inline route_t& operator = (const route_t& _route) {
   if (&_route != this)
   {
        route_dir = _route.route_dir; 
        vc_index  = _route.vc_index; 
        return *this; 
    }
}

This will handle:

   a=a;

Class method returning reference C++/SystemC

2 Answers2