Generic symmetric pair c++ for double and single types

Question

I am trying to have a template structure which can handle symmetric pairs. The comparisons operators are implemented to make the struct work in std::map.

So far I am using the following code :

template<typename T, typename U>
struct SymmetricPair
{
    SymmetricPair() : m_id(std::pair<T,U>()) {}
    SymmetricPair(const SymmetricPair<T,U>& id) : m_id(id) {}
    SymmetricPair(const SymmetricPair<U,T>& id) : SymmetricPair(id.m_id) {}
    SymmetricPair(const std::pair<T,U>& id) : m_id(id) {}
    SymmetricPair(const std::pair<U,T>& id) : m_id(std::pair<T,U>(id.second,id.first)) {}
    SymmetricPair(const T id_t, const U id_u) : m_id(std::pair<T,U>(id_t, id_u)) {}
    SymmetricPair(const U id_u, const T id_t) : m_id(std::pair<T,U>(id_t, id_u)) {

    bool operator< (const SymmetricPair<T,U>& rhs) const { return m_id <  rhs.m_id; }
    bool operator!=(const SymmetricPair<T,U>& rhs) const { return m_id != rhs.m_id; }
    bool operator==(const SymmetricPair<T,U>& rhs) const { return m_id == rhs.m_id; }
    bool operator< (const SymmetricPair<U,T>& rhs) const { return m_id <  SymmetricPair<T,U>(rhs.m_id).m_id; }
    bool operator!=(const SymmetricPair<U,T>& rhs) const { return m_id != SymmetricPair<T,U>(rhs.m_id).m_id; }
    bool operator==(const SymmetricPair<U,T>& rhs) const { return m_id == SymmetricPair<T,U>(rhs.m_id).m_id; }

    std::pair<T,U> m_id;
};

Using SymmetricPair<std::string,int> pair(std::pair<int,std::string>(42,"bde")); for example works fine.

However, I have troubles (compile time errors) when template arguments T and U are the same e.g. SymmetricPair<std::string,std::string> since some operations are considered already defined

'SymmetricPair<T,U>::SymmetricPair(const SymmetricPair<T,U> &)' : member function already defined or declared   
'SymmetricPair<T,U>::SymmetricPair(const std::pair<_Ty1,_Ty2> &)' : member function already defined or declared 
'SymmetricPair<T,U>::SymmetricPair(const T,const U)' : member function already defined or declared
'bool SymmetricPair<T,U>::operator <(const SymmetricPair<T,U> &) const' : member function already defined or declared   
 'bool SymmetricPair<T,U>::operator !=(const SymmetricPair<T,U> &) const' : member function already defined or declared 
'bool SymmetricPair<T,U>::operator ==(const SymmetricPair<T,U> &) const' : member function already defined or declared

How can I fix that ? I am using VC++ 2005 (so no C++11).

If there is a also a way to make the structure more elegant, I am interested.

When you say you "have troubles", what do you mean by that? Build errors? Runtime errors? Unexpected results? Something else? Please elaborate. — Some programmer dude, May 20 '15 at 11:34
You could partially specialize `SymmetricPair` for `T == U`, i.e. `template struct SymmetricPair { /* ... */ };`. I don't fully understand what's the purpose of the symmetry, though. — dyp, May 20 '15 at 11:36
@dyp In order to handle a foo element the same as foo element. I will investigate your solution thanks ! — coincoin, May 20 '15 at 11:38
can you use `std::enable_if` from C++11? http://en.cppreference.com/w/cpp/types/enable_if — Hcorg, May 20 '15 at 11:39
@coincoin So it seems your class template shall ignore the order of the template arguments. How then shall one access the data members of a `foo`? There's nothing to distinguish the first `A` from the second `A` once you take away the order. -- I just don't understand the concept. — dyp, May 20 '15 at 11:43
@coincoin: "I cannot use C++11"*, but you use it with your forward constructor. — Jarod42, May 20 '15 at 11:45
@dyp I agree that it is weird. Trying to look for an alternative thanks ! — coincoin, May 20 '15 at 11:51
@Jarod42 Oh you have good eyes ! I tried to reproduce simply the problem on another platform, my mistake. — coincoin, May 20 '15 at 11:52

score 3 · Accepted Answer · answered May 20 '15 at 11:40

I believe the easiest way is partial specialization, especially if C++11 is not available:

template<typename T>
struct SymmetricPair<T, T>
{
    SymmetricPair() : m_id() {}
    SymmetricPair(const SymmetricPair& id) : m_id(id.m_id) {}
    SymmetricPair(const std::pair<T,T>& id) : m_id(id) {}
    SymmetricPair(const T id_t, const T id_u) : m_id(id_t, id_u) {}

    bool operator< (const SymmetricPair<T,T>& rhs) const { return m_id <  rhs.m_id; }
    bool operator!=(const SymmetricPair<T,T>& rhs) const { return m_id != rhs.m_id; }
    bool operator==(const SymmetricPair<T,T>& rhs) const { return m_id == rhs.m_id; }

    std::pair<T,T> m_id;
};

Thank you Anton. You answered my question. However, as dyp mentionned I will think about an alternative, this structure is surely wrong to use. — coincoin, May 20 '15 at 11:53

score 1 · Answer 2 · answered Aug 04 '16 at 12:01

I would rather extend pair, or just use a different equality operator and hash operator in a specific case.

I just wrote this class:

/** Copyright (C) 2016 Ultimaker - Released under terms of the AGPLv3 License */
#ifndef UTILS_SYMMETRIC_PAIR
#define UTILS_SYMMETRIC_PAIR

#include <utility> // pair

namespace cura 
{

/*!
* A utility class for a pair of which the order between the first and the second doesn't matter.
* 
* \tparam A The type of both elements of the pair.
*/
template<class A>
class SymmetricPair : public std::pair<A, A>
{
public:
    /*!
    * Forwarding std::pair constructor
    */
    template<class U>
    SymmetricPair(const SymmetricPair<U>& pr)
    : std::pair<A, A>(pr)
    {
    }
    /*!
    * Forwarding std::pair constructor
    */
    template<class U>
    SymmetricPair(SymmetricPair<U>&& pr)
    : std::pair<A, A>(pr)
    {
    }
    /*!
    * Forwarding std::pair constructor
    */
    SymmetricPair(const A& first, const A& second)
    : std::pair<A, A>(first, second)
    {
    }
    /*!
    * Forwarding std::pair constructor
    */
    template<class U>
    SymmetricPair(U&& first, U&& second)
    : std::pair<A, A>(first, second)
    {
    }
    /*!
    * Forwarding std::pair constructor
    */
    template <class... Args1, class... Args2>
    SymmetricPair(std::piecewise_construct_t pwc, std::tuple<Args1...> first_args, std::tuple<Args2...> second_args)
    : std::pair<A, A>(pwc, first_args, second_args)
    {
    }

    /*!
    * Equality operator which checks if two SymmetricPairs are equal regardless of the order between first and second
    */
    bool operator==(const SymmetricPair& other) const
    {
        return (std::pair<A, A>::first == other.first && std::pair<A, A>::second == other.second) || (std::pair<A, A>::first == other.second && std::pair<A, A>::second == other.first);
    }
};

}//namespace cura

namespace std
{

/*!
* Hash operator which creates a hash regardless of the order between first and second
*/
template<class A>
struct hash<cura::SymmetricPair<A>>
{
    size_t operator()(const cura::SymmetricPair<A>& pr) const
    { // has to be symmetric wrt a and b!
        return std::hash<A>()(pr.first) + std::hash<A>()(pr.second);
    }
};
}//namespace std


#endif // UTILS_SYMMETRIC_PAIR

On other occasions I simply defined a separate equality and hash function and used those for example in unordered_map<Key, Value, MyHasher, MyEquality>.

Generic symmetric pair c++ for double and single types

2 Answers2