如何重载从c ++中继承模板的类的赋值运算符

Question

I have a given utility template class tagged. I had to declare 2 new structs using these template classes as follows.

tagged.h

#ifndef TAGGED_H
#define TAGGED_H

#include <iostream>


template<typename T, typename TAG>
class tagged
{
private:
    T _value;

public:
    tagged() : _value() { }

    explicit tagged(const T& value) : _value(value) { }    

    // https://isocpp.org/wiki/faq/templates#template-friends
    friend T& value(tagged<T, TAG>& st)
    {
        return st._value;
    }

    friend const T& value(const tagged<T, TAG>& st)
    {
        return st._value;
    }
};

template<typename T>
struct equality
{
    friend bool operator ==(const T& x, const T& y)
    {
        return value(x) == value(y);
    }

    friend bool operator !=(const T& x, const T& y)
    {
        return value(x) != value(y);
    }
};

template<typename T>
struct ordered : equality<T>
{
    friend bool operator <(const T& x, const T& y)
    {
        return value(x) < value(y);
    }

    friend bool operator <=(const T& x, const T& y)
    {
        return value(x) <= value(y);
    }

    friend bool operator >(const T& x, const T& y)
    {
        return value(x) > value(y);
    }

    friend bool operator >=(const T& x, const T& y)
    {
        return value(x) >= value(y);
    }
};

These are the two structs i declared following the rules given by the assignment. primitives.h

//Time
struct __declspec(empty_bases)Time : tagged<uint64_t, Time>, ordered<Time>, show_value<Time, int>{ using tagged::tagged; };


//Duration
struct __declspec(empty_bases)Duration : tagged<uint64_t, Duration>, ordered<Duration>, show_value<Duration, int> { using tagged::tagged; };

I succeeded in writing all other operators like + and - but i cant seem to solve how to overload += and -= I'm not allowed to change the objects in tagged.h I know assignment operators can only be member functions. Because of the way the template works i've tried casting 'const Time&' and const Duration& to non consts but that didnt seem to work. I've tried the examples you can find online about assigment operator overloading but the examples all overload in the template and not in the inherited class where I barely have write access to '_value' which is the value I should overwrite of reassign the pointer of.

Thanks

edit:

 struct __declspec(empty_bases)Time : tagged<uint64_t, Time>, ordered<Time>, show_value<Time, int>
    {
        using tagged::tagged;

        Time& operator+(const Duration& right) {
            Time t = Time(value(*this) + value(right));
            return t;
        };

        Time& operator+=(const Duration& right) {
            (uint64_t&)(*this) = value(*this) + value(right);
            return (*this);
        };

    };


    //Duration
    struct __declspec(empty_bases)Duration : tagged<uint64_t, Duration>, ordered<Duration>, show_value<Duration, int> {
        using tagged::tagged;

        Duration& operator+(const Duration& right) {
            Duration d = Duration(value(*this) + value(right));
            return d;
        };

        Time& operator+(const Time & right) {
            Time t = Time(value(*this) + value(right));
            return t;
        };

        Duration& operator-(const Time & right) {
            Duration d = Duration(value(*this) - value(right));
            return d;
        };

        Duration& operator-(const Duration & right) {
            Duration d = Duration(value(*this) - value(right));
            return d;
        };

         Duration& operator+=(const Duration& right) {
             (uint64_t&)(*this) = (uint64_t&)(*this) + (uint64_t&)(right);
             return (*this);
        }

         Duration& operator-=(const Duration& right) {
            (uint64_t&)(*this) = value(*this) - value(right);
            return (*this);
                };
            };

This is what I have now. Still have the same syntax errors that keep popping up. I dont know anymore lmao

Answer 1

From what I see you should be able to implement it using value() function; Since value returns by reference something like this should work:

Duration & operator+=(const Duration & right) {
    value(*this) += value( right );
    return *this;
}

Just be careful on the other operators (I'm looking at + and -) because you return references to temporal objects.

Duration & operator+(const Duration & right) {                // this returns a reference to an object
  Duration d = Duration( value( *this ) + value( right ) );   // this creates a temporal variable
  return d;                                                   // you return a reference to d bu its lifetime is over -> undefined behavior I believe
}