Creating a custom comparable Tree-like data structor in C++ - c++

Question

I have a type struct Type_Specifier which I want to represent an immutable tree like structure that I can compare. I have the following code to illustrate what I want:
#include <vector>
struct Parameter_Specifier;
struct Type_Specifier
{
explicit Type_Specifier(void* tag = nullptr, std::vector<Parameter_Specifier> parameters = {})
: tag(tag), parameters(parameters) { }
Type_Specifier(const Type_Specifier&) = default;
Type_Specifier(Type_Specifier&&) = default;
Type_Specifier& operator=(const Type_Specifier&) = default;
Type_Specifier& operator=(Type_Specifier&&) = default;
~Type_Specifier() = default;
private:
// Points to an arbitray memory location (whose lifetime is not managed by this type)
void* tag;
std::vector<Parameter_Specifier> parameters;
public:
static bool operator ==(const Type_Specifier& left, const Type_Specifier& right)
{
if (left.tag != right.tag)
return false;
else if (left.parameters.size() != right.parameters.size())
return false;
else for (std::size_t i = 0; i < left.parameters.size(); i++)
{
if (!(left.parameters[i] == right.parameters[i]))
return false;
}
return true;
}
static bool operator <(const Type_Specifier& left, const Type_Specifier& right)
{
if (left.tag < right.tag)
return true;
else if (left.parameters.size() < right.parameters.size())
return true;
else if (left.parameters.size() > right.parameters.size())
return false;
else for (std::size_t i = 0; i < left.parameters.size(); i++)
{
if (left.parameters[i] < right.parameters[i])
return true;
else if (right.parameters[i] < left.parameters[i])
return false;
}
return false; // left == right
}
};
struct Parameter_Specifier
{
explicit Parameter_Specifier(Type_Specifier type = Type_Specifier(), std::vector<char> value = {})
: type(type), value(value) { }
Parameter_Specifier(const Parameter_Specifier&) = default;
Parameter_Specifier(Parameter_Specifier&&) = default;
Parameter_Specifier& operator=(const Parameter_Specifier&) = default;
Parameter_Specifier& operator=(Parameter_Specifier&&) = default;
~Parameter_Specifier() = default;
private:
Type_Specifier type;
// Arbitrary data (not a 'string' or sequence of 'characters')
std::vector<char> value;
public:
static bool operator ==(const Parameter_Specifier& left, const Parameter_Specifier& right)
{
if (!(left.type == right.type))
return false;
else if (left.value.size() != right.value.size())
return false;
else for (std::size_t i = 0; i < left.value.size(); i++)
{
if (left.value[i] != right.value[i])
return false;
}
return true; // left == right
}
static bool operator <(const Parameter_Specifier& left, const Parameter_Specifier& right)
{
if (left.type < right.type)
return true;
else if (left.value.size() < right.value.size())
return true;
else if (left.value.size() > right.value.size())
return false;
else for (std::size_t i = 0; i < left.value.size(); i++)
{
if (left.value[i] < right.value[i])
return true;
else if (left.value[i] > right.value[i])
return false;
}
return false; // left == right
}
};
However it of course will not compile, probably due to struct Parameter_Specifier being incomplete, and the operators '<', and '==' being undefined.
My question is this:
How Can I modify the above types to make it compile and work properly? (and efficiently?)
Notes:
The purpose of this type is to be used in a two-way map structure to be able to map between struct Type_Specifier and std::size_t (i.e. it needs to be both a key type and a value type)
I will define the other comparison operators '!=', '>', '>=' and '<=' based on my definitions of '==' and '>', I have omitted them here for brevity
I am pretty sure that a == b is equivalent to !(a < b) && !(b < a)
The order of comparison isn't really relevant, as look as it is a strict weak ordering relation
I would like the Type_Specifier type to follow the RAII idiom
The Paramater_Specifier type is only used for children of Type_Specifier and nowhere else
I only whish to use the C++ standard library
I was considering making Type_Specifier::parameters an std::vector<Parameter_Specifier*> but then I would have to manually manage allocation, in Type_Specifier, which would cause obvious problems as Parameter_Specifier is incomplete there.

Answer 1

You have problems with relational operators.
1) for operator==(), you have two alternative: (a) a method of the class/struct with one parameter (the left argument, *this, is implicit), that can't be static, or (b) an external function (friend, usually) with two parameter. You have mixed the two alternative and have made the method static. I strongly suggest alternative (b): external function. So (take in count that there is an operator==() for std::vector) operator==() for Type_Specifier could be
friend bool operator== (const Type_Specifier & left,
const Type_Specifier & right)
{
return ( left.tag == right.tag )
&& ( left.parameters == right.parameters );
}
For Parameter_Specifier could be
friend bool operator== (const Parameter_Specifier & left,
const Parameter_Specifier & right)
{
return ( left.type == right.type )
&& ( left.value == right.value );
}
2) same thing for operator<(). Moreover, if "left.tag < rigth.tag" is false, I think you should verify that isn't true that left.tag > right.tag. My suggestion (but with different behaviour; caution) for Type_Specifier is
friend bool operator< (const Type_Specifier & left,
const Type_Specifier & right)
{
return ( left.tag < right.tag )
|| ( ( left.tag == right.tag )
&& ( left.parameters < right.parameters ) );
}
For Parameter_Specifier, my suggestion (with different behaviour; caution) is
friend bool operator< (const Parameter_Specifier & left,
const Parameter_Specifier & right)
{
return ( left.type < right.type )
|| ( (left.type == right.type )
&& (left.value < right.value ) );
}
3) having operator==() and operator<() others relational operator are straightforward. For Type_Specifier
friend bool operator!= (const Type_Specifier & left,
const Type_Specifier & right)
{ return ! (left == right); }
friend bool operator> (const Type_Specifier & left,
const Type_Specifier & right)
{ return (right < left); }
friend bool operator<= (const Type_Specifier & left,
const Type_Specifier & right)
{ return ! (right < left); }
friend bool operator>= (const Type_Specifier & left,
const Type_Specifier & right)
{ return ! (left < right); }
For Parameter_Specifier... well... change Type_Specifier with Parameter_Specifier.
P.s.: sorry for my bad English.