Utter confusion

[hauzer]

main.cpp

#include <cstdlib>
#include <iostream>

#include "int128_t.h"

int main(int argc, char **argv)
{
    using namespace std;

    int128_t a = 3434;

    cout << a << endl;

    return EXIT_SUCCESS;
}

int128_t.h

#include <cstdint>
#include <iostream>

class int128_t
{
    /* Basic arithmetic */
    friend inline int128_t operator+(const int128_t &, const int128_t &);
    friend inline int128_t operator-(const int128_t &, const int128_t &);
    friend inline int128_t operator*(const int128_t &, const int128_t &);
    friend inline int128_t operator/(const int128_t &, const int128_t &);
    /* Logical comparison */
    friend inline bool operator==(const int128_t &, const int128_t &);
    template <typename T> friend inline bool operator==(const int128_t &, const T &);
    template <typename T> friend inline bool operator==(const T &, const int128_t &);
    friend inline bool operator!=(const int128_t &, const int128_t &);
    template <typename T> friend inline bool operator!=(const int128_t &, const T &);
    template <typename T> friend inline bool operator!=(const T &, const int128_t &);
    friend inline bool operator<(const int128_t &, const int128_t &);
    template <typename T> friend inline bool operator<(const int128_t &, const T &);
    template <typename T> friend inline bool operator<(const T &, const int128_t &);
    friend inline bool operator<=(const int128_t &, const int128_t &);
    template <typename T> friend inline bool operator<=(const int128_t &, const T &);
    template <typename T> friend inline bool operator<=(const T &, const int128_t &);
    friend inline bool operator>(const int128_t &, const int128_t &);
    template <typename T> friend inline bool operator>(const int128_t &, const T &);
    template <typename T> friend inline bool operator>(const T &, const int128_t &);
    friend inline bool operator>=(const int128_t &, const int128_t &);
    template <typename T> friend inline bool operator>=(const int128_t &, const T &);
    template <typename T> friend inline bool operator>=(const T &, const int128_t &);
    /* Input/Output */
    friend std::ostream &operator<<(std::ostream &ostr, const int128_t &rhs);

    private:
        int64_t lo, hi;
    public:
        /* Assignment and SignEqual operators */
        inline int128_t &operator=(const int128_t &);
        template <typename T> inline int128_t &operator=(const T &);
        inline void operator+=(const int128_t &);
        template <typename T> inline void operator+=(const T &);
        inline void operator-=(const int128_t &);
        template <typename T> inline void operator-=(const T &);
        inline void operator*=(const int128_t &);
        template <typename T> inline void operator*=(const T &);
        inline void operator/=(const int128_t &);
        template <typename T> inline void operator/=(const T &);
};

template <typename T>
inline int128_t &int128_t::operator=(const T &rhs)
{
    lo = rhs;
    hi = 0;

    return *this;
}

/* Basic arithmetic */
template <typename T>
inline void int128_t::operator+=(const T &rhs)
{
    lo += rhs;
    hi = 0;
}

template <typename T>
inline void int128_t::operator-=(const T &rhs)
{
    lo -= rhs;
    hi = 0;
}

template <typename T>
inline void int128_t::operator*=(const T &rhs)
{
    lo *= rhs;
    hi = 0;
}

template <typename T>
inline void int128_t::operator/=(const T &rhs)
{
    lo += rhs;
    hi = 0;
}



/* Logical comparison */
template <typename T>
inline bool operator==(const int128_t &lhs, const T &rhs)
{
    return (lhs.lo == rhs) && (lhs.hi == 0);
}

template <typename T>
inline bool operator==(const T &lhs, const int128_t &rhs)
{
    return (lhs == rhs.lo) && (rhs.hi == 0);
}


template <typename T>
inline bool operator!=(const int128_t &lhs, const T &rhs)
{
    return (lhs.lo != rhs) || (lhs.hi != 0);
}

template <typename T>
inline bool operator!=(const T &lhs, const int128_t &rhs)
{
    return (lhs != rhs.lo) || (rhs.hi != 0);
}


template <typename T>
inline bool operator<(const int128_t &lhs, const T &rhs)
{
    return (lhs.lo < rhs) && (lhs.hi == 0);
}

template <typename T>
inline bool operator<(const T &lhs, const int128_t &rhs)
{
    return (lhs < rhs.lo) && (rhs.hi == 0);
}


template <typename T>
inline bool operator<=(const int128_t &lhs, const T &rhs)
{
    return (lhs.lo <= rhs) && (lhs.hi == 0);
}

template <typename T>
inline bool operator<=(const T &lhs, const int128_t &rhs)
{
    return (lhs <= rhs.lo) && (rhs.hi == 0);
}


template <typename T>
inline bool operator>(const int128_t &lhs, const T &rhs)
{
    return (lhs.lo > rhs) && (lhs.hi == 0);
}

template <typename T>
inline bool operator>(const T &lhs, const int128_t &rhs)
{
    return (lhs > rhs.lo) && (rhs.hi == 0);
}


template <typename T>
inline bool operator>=(const int128_t &lhs, const T &rhs)
{
    return (lhs.lo >= rhs) && (lhs.hi == 0);
}

template <typename T>
inline bool operator>=(const T &lhs, const int128_t &rhs)
{
    return (lhs >= rhs.lo) && (rhs.hi == 0);
}

int128_t.cpp

#include "int128_t.h"

/* Basic arithmetic */
inline int128_t &int128_t::operator=(const int128_t &rhs)
{
    lo = rhs.lo;
    hi = rhs.hi;

    return *this;
}

inline int128_t operator+(const int128_t &a, const int128_t &b)
{
    int128_t x;

    x.lo = a.lo + b.lo;
    x.hi = a.hi + b.hi;

    return x;
}

inline int128_t operator-(const int128_t &a, const int128_t &b)
{
    int128_t x;

    x.lo = a.lo - b.lo;
    x.hi = a.hi - b.hi;

    return x;
}

inline int128_t operator*(const int128_t &a, const int128_t &b)
{
    int128_t x;

    x.lo = a.lo * b.lo;
    x.hi = a.hi * b.hi;

    return x;
}

inline int128_t operator/(const int128_t &a, const int128_t &b)
{
    int128_t x;

    x.lo = a.lo / b.lo;
    if(b.hi == 0) x.hi = 0;
    else x.hi = a.hi / b.hi;

    return x;
}

inline void int128_t::operator+=(const int128_t &rhs)
{
    lo += rhs.lo;
    hi += rhs.hi;
}

inline void int128_t::operator-=(const int128_t &rhs)
{
    lo -= rhs.lo;
    hi -= rhs.hi;
}

inline void int128_t::operator*=(const int128_t &rhs)
{
    lo *= rhs.lo;
    hi *= rhs.hi;
}

inline void int128_t::operator/=(const int128_t &rhs)
{
    lo /= rhs.lo;
    if(rhs.hi == 0) hi = 0;
    else hi /= rhs.hi;
}

/* Logical comparison */
inline bool operator==(const int128_t &lhs, const int128_t &rhs)
{
    return (lhs.lo == rhs.lo) && (lhs.hi == rhs.hi);
}

inline bool operator!=(const int128_t &lhs, const int128_t &rhs)
{
    return (lhs.lo != rhs.lo) || (lhs.hi != rhs.hi);
}

inline bool operator<(const int128_t &lhs, const int128_t &rhs)
{
    return lhs.hi < rhs.hi;
}

inline bool operator<=(const int128_t &lhs, const int128_t &rhs)
{
    return lhs.hi <= rhs.hi;
}

inline bool operator>(const int128_t &lhs, const int128_t &rhs)
{
    return lhs.hi > rhs.hi;
}

inline bool operator>=(const int128_t &lhs, const int128_t &rhs)
{
    return lhs.hi >= rhs.hi;
}

/* Input/Output */
std::ostream &operator<<(std::ostream& ostr, const int128_t &rhs)
{
    if(rhs.hi == 0) ostr << rhs.lo;

    return ostr;
}

I can't find out what's the problem. When trying to assing 3434 to a in main.cpp I get an error: "conversion from ‘int’ to non-scalar type ‘int128_t’ requested" although I have made a template to accept ints and such. Something is obviously wrong, but I don't know what. I'm weary of swimming trough code and diving in the internet. There are probably tons of errors and some enlightenment on this matter is more than welcome.

[bernt]

int128_t a = 3434;

Initialization like this uses the copy constructor, rather than operator=.

[hauzer]

Thanks for the tip, some thing are much clearer now. I've added the copy constructor and removed those inlines for now, everything works perfectly. One question, do I have to declare multiple version of functions like this:

template  friend bool operator>=(const int128_t &, const T &);
template  friend bool operator>=(const T &, const int128_t &);

It seems logical to do so, but I'm asking just in case.

[laserlight]

Initialization like this uses the copy constructor, rather than operator=.

Not really: it would use the most appropriate constructor, not the copy constructor, but no appropriate constructor was defined, hence the error. This class does not need to have the copy constructor (or copy assignment operator or destructor) explicitly defined.

One question, do I have to declare multiple version of functions like this:

If you do not want to rely on implicit conversions, yes. Instead of making these friends:

friend inline int128_t operator+(const int128_t &, const int128_t &);
friend inline int128_t operator-(const int128_t &, const int128_t &);
friend inline int128_t operator*(const int128_t &, const int128_t &);
friend inline int128_t operator/(const int128_t &, const int128_t &);

make them non-member non-friends and implement them using the assignment versions, e.g., implement operator+ in terms of operator+=.

Likewise, I feel that you might as well make these const member functions:

bool operator==(const int128_t &, const int128_t &);
template <typename T> bool operator==(const int128_t &, const T &);

then implement the other operator== function template as a non-member non-friend using the member version of the function template. (Though if you did not have the template versions, then keeping the non-template version as a friend would be good, in my opinion.)

See if you can apply the same "prefer non-member non-friends, otherwise prefer members to friends" approach to the other functions without loss of efficiency. You could even consider implementing operator!= in terms of operator==, and say, >= in terms of < and > in terms of <= (though you could implement all in terms of just < if you wanted to, with small loss of efficiency).

Also, inline functions should be defined in the header. You will not break the one definition rule because they are declared inline. If you define a member function in the class definition (I noticed you did not do so though), it is already inline, so declaring it inline would be redundant.

EDIT:
By the way, I am curious as to the correctness of your implementation, e.g., if you are adding two numbers together, don't you have to care about whether the addition of the lower half overflows so as to pre-emptively perform carry over?

[hauzer]

If you do not want to rely on implicit conversions, yes. Instead of making these friends:

friend inline int128_t operator+(const int128_t &, const int128_t &);
friend inline int128_t operator-(const int128_t &, const int128_t &);
friend inline int128_t operator*(const int128_t &, const int128_t &);
friend inline int128_t operator/(const int128_t &, const int128_t &);

make them non-member non-friends and implement them using the assignment versions, e.g., implement operator+ in terms of operator+=.

Now that's OOP thinking, I like that.

Likewise, I feel that you might as well make these const member functions:

bool operator==(const int128_t &, const int128_t &);
 template <typename T> bool operator==(const int128_t &, const T &);

then implement the other operator== function template as a non-member non-friend using the member version of the function template. (Though if you did not have the template versions, then keeping the non-template version as a friend would be good, in my opinion.)

I'm not sure I understand what you mean here.

See if you can apply the same "prefer non-member non-friends, otherwise prefer members to friends" approach to the other functions without loss of efficiency. You could even consider implementing operator!= in terms of operator==, and say, >= in terms of < and > in terms of <= (though you could implement all in terms of just < if you wanted to, with small loss of efficiency).

I will try to apply that and see how it turns out.

Also, inline functions should be defined in the header.

Yes, it was an error made in haste; I've removed the inline attribute from all functions for now.

By the way, I am curious as to the correctness of your implementation, e.g., if you are adding two numbers together, don't you have to care about whether the addition of the lower half overflows so as to pre-emptively perform carry over?

It's absolutely uncorrect and it's just a placeholder until I design the class.
I come from a strict-C and non-OOP background so grasping these advanced techniques is not a simple task. Although I know the common OOP concepts both in theory and practice, the advanced ones demand more thourough writing and practicing. I like to learn from firsthand experience rather than applying already thought-out alghorithms and designs. It certainly is unproductive at most times, but that's just who I am. Learning for the sake of it is never my goal, no matter how absurd that sounds.

[Elysia]

I'm not sure I understand what you mean here.

It means that if you have a == b, then equivalently, b == a.
So if a has member operator == (const B&), then we could use the above fact by writing a free function (ie, not a member function) operator == (const B&, const A&) that simply returns true if a == b (the member function can perform that task!).

[hauzer]

It means that if you have a == b, then equivalently, b == a.
So if a has member operator == (const B&), then we could use the above fact by writing a free function (ie, not a member function) operator == (const B&, const A&) that simply returns true if a == b (the member function can perform that task!).

That makes sense. I have just got cought in the wording. Thanks.