struct Something {
union {
float k;
int n;
};
bool isFloat;
bool operator==(const Something& mS)
{
if(isFloat != mS.isFloat) return false;
if(isFloat && mS.k == k) return true;
if(!isFloat && mS.n == n) return true;
}
};
My implementation of Something::operator== seems rather expensive and convoluted. Is this the only way to check equality in classes with union types?
Or is there a better way that avoids branches/checking additional variables?
bool operator==(const Something& mS)
{
if (isFloat != mS.isFloat)
{
return false;
}
else if (isFloat)
{
return mS.k == k;
}
else
{
return mS.n == n;
}
}
Clear and debuggable with the minimum number of checks. You want to have a constructor and/or set methods to ensure isFloat is correct at all times.
You can remove one redundant check, and perhaps enhance readability slightly, by replacing the last two lines with
if(isFloat != mS.isFloat) return false; // As you have
return isFloat ? mS.k == k : mS.n == n;
(or the equivalent if construct, as in Sean Perry's answer) but the compiler will probably do just as good a job of optimising your version.
There's no way to avoid a runtime check that the types match. You might consider a ready-made discriminated union type like Boost.Variant; it won't be any more efficient, but it might be easier and less error-prone to use.
return (isFloat && mS.isFloat && k==mS.k) || (!isFloat && !mS.isFloat && n==mS.n);
I do not think that you can escape checking all the conditions. So the question can be how to write them more simpler and expressively.
I would write them the following way
bool operator==( const Something &mS ) const
{
return ( ( isFloat == mS.isFloat ) && ( isFloat ? k == mS.k : n == mS.n ) );
}
Related
I wanted to make one of my code more concise so I wrote this:
while(m <= r)
nums[m] ? nums[m] == 1 ? m++ : swap(nums[m], nums[r--]) : swap(nums[m++], nums[l++]);
But it's not working because 'swap' is a void function but 'm++' returns int. ('right operand to ? is void, but left operand is of type int' error). So I'd like to know how can I replace m++ so it's of type void.
I know that I can create a new void function (for example void increase(int &x){x++;}) but I want to keep my code as an one liner.
The best working variant I made is 'swap(nums[m], nums[m++])', which does nothing to my array, but it looks awful. What other functions can I use?
I wanted to make one of my code more concise
Baking in a number of side effects into a single expression of nested non-parenthesized ternary operators (making use of implicit conversion to bool) does, if anything, make your code more complex, more bug-prone and may hide the fact that the original code should actually have been broken up and re-factored into something simpler.
Why not favour clarity over over-complex brevity? E.g. starting with the straight-forward approach:
while(m <= r) {
if (nums[m] != 0) {
if (nums[m] == 1) {
++m;
}
else {
swap(nums[m], nums[r--]);
}
}
else {
swap(nums[m++], nums[l++]);
}
}
which can be re-factored into:
while(m <= r) {
if (nums[m] != 0) {
if (nums[m] == 1) {
++m;
}
else {
swap(nums[m], nums[r]);
--r;
}
}
else {
swap(nums[m], nums[l]);
++m;
++l;
}
}
which can be re-factored into:
while(m <= r) {
const std::size_t swap_from_idx = m;
std::size_t swap_with_idx = m; // default: no swapping.
if (nums[m] == 1) {
++m;
continue;
}
else if (nums[m] == 0) {
swap_with_idx = l;
++l;
}
else {
swap_with_idx = r;
--r;
++m;
}
swap(nums[swap_from_idx], nums[swap_with_idx]);
}
or e.g.:
while(m <= r) {
// No swapping.
if (nums[m] == 1) {
++m;
}
// Swapping.
else {
const std::size_t swap_from_idx = m;
std::size_t swap_with_idx = l;
if (nums[m] == 0) {
++l;
}
else {
swap_with_idx = r;
--r;
++m;
}
swap(nums[swap_from_idx], nums[swap_with_idx]);
}
}
At this point you may ask yourself is the original loop design is overly complex, and/or if you should break out part of the loop body into a separate utility function.
If your if/else if/else logic is reaching a too high cyclomatic complexity, the answer is seldom to try to hide it by means of a highly complex tenary operator expression, but rather by re-factoring and, if applicable, breaking out some parts in separate functions.
If you want the expression m++ to have a side-effect, and have a void type, you can simply cast the expression like this:
(void)m++
which will evaluate the m++ first, and then cast it to void.
Here's a demo.
I am testing whether a number lies between two values. I leave it up to the user to choose whether the logical comparison should include an equal to on either (or both) of the limits or not.
They set this by defining a structwhich contains the two edge values and which comparison operator to use:
typedef struct {
double low;
double high;
bool low_equal; //false if a greater than operator (`>`) should be used, true if a greater-than-or-equal-to (`>=`) operator should be used
bool high_equal; //Same as low_equal but for a less-than operator
} Edges;
An array of Edges is created, (termed bins below) and for each input value I check whether it lies within the bin edges.
However, in order to use the desired pair of comparison operators, I've ended up with this hideous conditional block:
if (bins[j].low_equal && bins[j].high_equal)
{
if (value >= bins[j].low && value <= bins[j].high)
{
break;
}
}
else if (bins[j].low_equal)
{
if (value >= bins[j].low && value < bins[j].high)
{
data[i] = bins[j].value;
break;
}
}
else if (bins[j].high_equal)
{
if (datum > bins[j].low && datum <= bins[j].high)
{
break;
}
}
else
{
if (value > bins[j].low && value < bins[j].high)
{
break;
}
}
Is there a better way to do this? Can I somehow set the operators to use and then just call them?
A simple approach could be:
bool higher = (value > bins[j].low) || (bins[j].low_equal && value == bins[j].low);
bool lower = (value < bins[j].high) || (bins[j].high_equal && value == bins[j].high);
if (higher && lower)
{
// In range
}
you may use pointer on function
bool less(double lhs, double rhs) { return lhs < rhs; }
bool less_or_equal(double lhs, double rhs) { return lhs <= rhs; }
using comp_double = bool(double, double);
and then
comp_double *low_comp = bins[j].low_equal ? less_or_equal : less;
comp_double *high_comp = bins[j].high_equal ? less_or_equal : less;
if (low_comp(bins[j].low, value) && high_comp(value, bins[j].high)) {
// In range
}
This would be IMO a good case for the ternary operator
if ((bins[j].low_equal ? bins[j].low <= value : bins[j].low < value) &&
(bins[j].high_equal ? value <= bins[j].high : value < bins[j].high)) {
...
}
I have two structs, for example, first struct as key in QMultiMap:
struct KeyStruct
{
int keydata1;
int keydata2;
int keydata3;
bool operator < ( const KeyStruct& o ) const
{
return keydata1 < o.keydata1 || keydata2 < o.keydata2 || keydata3 < o.keydata3;
}
};
And second struct as value:
struct ValueStruct
{
int valuedata1;
QString valuedata2;
};
I tried to use QMultiMap like this:
multiMap.insert( keyStruct, valueStruct ); // in a loop
foreach( keyStruct, multiMap.keys()){
foreach( valueStruct, multiMap.values( keyStruct )){
// it never reaches this line
}
}
I'm shure in some cases I have multiple values per key, but can't even get one. I think the problem is in comparsion.
Also, I tried this:
bool operator == ( const KeyStruct& o ) const
{
return keydata1 == o.keydata1 &&
keydata2 == o.keydata2 &&
keydata3 == o.keydata3;
}
But it seems QMultiMap just doesn't use this code in my case.
Any data structure ( to my knowledge) that requires an operator<() to function has also the condition that:
A<B => ! B<A
This seems trivial, but in your case, it is possible that A<B && B<A. For instance if A.keydata1 < B.keydata1 but A.keydata2 > B.keydata2.
To fix this you should write your operator something like this:
bool operator < ( const KeyStruct& o ) const
{
if(keyData1 != o.keyData1) return keyData1 < o.keyData1;
if(keyData2 != o.keyData2) return keyData2 < o.keyData2;
//etc
return false; //they are equal
}
Sorry if this is a stupid question, but it's something that I'm curious about.
I am overloading the less-than operator for my sort algorithm based on last name, first name, middle name. I realize there is not a right or wrong here, but I'm curious as to which style is written better or preferred among fellow programmers.
bool CPerson::operator<(const CPerson& key) const
{
if (m_Last < key.m_Last)
|| ( (m_Last == key.m_Last) && (m_First < key.m_First) )
|| ( (m_Last == key.m_Last) && (m_First == key.m_First) && (m_Middle < key.m_Middle) )
return true;
return false;
}
or
bool CPerson::operator<(const CPerson& key) const
{
if (m_Last < key.m_Last)
return true;
else if ( (m_Last == key.m_Last) && (m_First < key.m_First) )
return true;
else if ( (m_Last == key.m_Last) && (m_First == key.m_First) && (m_Middle < key.m_Middle) )
return true;
else
return false;
}
or
bool CPerson::operator<(const CPerson& key) const
{
if (m_Last < key.m_Last)
return true;
if (m_Last == key.m_Last)
if (m_First < key.m_First)
return true;
if (m_Last == key.m_Last)
if (m_First == key.m_First)
if (m_Middle < key.m_Middle)
return true;
return false;
}
I prefer:
bool CPerson::operator<(const CPerson& key) const
{
if (m_Last == key.m_Last) {
if (m_First == key.m_First) {
return m_Middle < key.m_Middle;
}
return m_First < key.m_First;
}
return m_Last < key.mLast;
}
Nice and systematic, and it is obvious how new members can be added.
Because these are strings, the repeated comparison may be needlessly inefficient. Following David Hamman's suggestion, here is a version which only does the comparisons once per string (at most):
bool CPerson::operator<(const CPerson& key) const
{
int last(m_Last.compare(key.m_Last));
if (last == 0) {
int first(m_First.compare(key.m_First));
if (first == 0) {
return m_Middle < key.m_Middle;
}
return first < 0;
}
return last < 0;
}
All of your implementations are essentially the same and they are all wrong by any reasonable definition of sort order for people's names. Your algorithm will place Jonathan Abbott Zyzzyk ahead of Jonathan Zuriel Aaron.
What you want is person A's name is less than person B's name if:
The last name of person A is less than the last name of person B or
The two have the same last name and
The first name of person A is less than the first name of person B or
The two have the same first name and the middle name of person A is less than the middle name of person B.
Whether you implement this as a single boolean expression versus a staged if/else sequence is a bit of personal preference. My preference is the single boolean expression; to me that logical expression is clearer than a cluttered if/else sequence. But apparently I'm weird. Most people prefer the if/else construct.
Edit, per request
As a single boolean expression,
bool Person::operator< (const Person& other) const {
return (last_name < other.last_name) ||
((last_name == other.last_name) &&
((first_name < other.first_name) ||
((first_name == other.first_name) &&
(middle_name < other.middle_name))));
}
I find the first one the most difficult to read of the three (although none of them are too difficult) and the first one has unnecessary parentheses. The second one is my personal preference, because the third one seems too long and verbose.
This really is subjective though.
I normally write a comparison function roughly like this:
bool whatever::operator<(whatever const &other) {
if (key1 < other.key1)
return true;
if (other.key1 < key1)
return false;
// compare the second key item because the first ones were equal.
if (key2 < other.key2)
return true;
if (other.key2 < key2)
return false;
// repeat for as many keys as needed
// for the last key item, we can skip the second comparison:
if (keyN < other.keyN)
return true;
return false; // other.keyN >= keyN.
}
Along a slightly different vein, all of the solutions (including my first answer) tend to compare names twice, once for less than and again for equality. Since sort is at best an N*logN algorithm, efficiency can be quite important when sorting a big list of names, and these duplicative comparisons are rather inefficient. The string::compare method provides a mechanism for bypassing this problem:
bool Person::operator< (const Person& other) const {
int cmp = last_name.compare (other.last_name);
if (cmp < 0) {
return true;
} else if (cmp == 0) {
cmp = first_name.compare (other.first_name);
if (cmp < 0) {
return true;
} else if (cmp == 0) {
cmp = middle_name.compare (other.middle_name);
if (cmp < 0) {
return true;
}
}
}
return false;
}
Edit, per request
Elided.
A boolean version of the above will either result in undefined behavior or will use multiple embedded uses of the ternary operator. It is ugly even given my penchant for hairy boolean expressions. Sorry, Mankarse.
I like to reduce this to tuples, which already implement this kind of lexicographical ordering. For example, if you have boost, you can write:
bool Person::operator< (const Person& Rhs) const
{
return boost::tie(m_Last, m_First, m_Middle) < boost::tie(Rhs.m_Last, Rhs.m_First, Rhs.m_Middle);
}
can this be done somehow?
if((a || b) == 0) return 1;
return 0;
so its like...if a OR b equals zero, then...but it is not working for me.
my real code is:
bool Circle2::contains(Line2 l) {
if((p1.distanceFrom(l.p1) || p1.distanceFrom(l.p2)) <= r) {
return 1;
}
return 0;
}
You need to write the full expression:
(a==0)||(b==0)
And in the second code:
if((p1.distanceFrom(l.p1)<= r) || (p1.distanceFrom(l.p2)<=r) )
return 1;
If you do ((a || b) == 0) this means "Is the logical or of a and b equal to 0. And that's not what you want here.
And as a side note: the if (BooleanExpression)return true; else return false pattern can be shortened to return BooleanExpression;
You have to specify the condition separately each time:
if (a == 0) || (b == 0))
bla bla;
When you do
if ((a || b) == 0)
bla bla;
it has a different meaning: (a || b) means "if either a or b is non-zero (ie. true), then the result of this expression is true".
So when you do (a||b) == 0, you are checking if the result of the previously explained expression is equal to zero (or false).
The C++ language specifies that the operands of || ("or") be boolean expressions.
If p1.distanceFrom(l.p1) is not boolean (that is, if distanceFrom returns int, or double, or some numeric class type), the compiler will attempt to convert it to boolean.
For built in numeric type, the conversion is: non-zero converts to true, zero converts to false. If the type of p1.distanceFrom(l.p1) is of class type Foo, the compiler will call one (and only one) user defined conversion, e.g., Foo::operator bool(), to convert the expression's value to bool.
I think you really want something like this:
bool Circle2::contains(Line2 l) {
if((p1.distanceFrom(l.p1) <= r) || (p1.distanceFrom(l.p2) <= r)) return 1;
return 0;
}
Fun with templates:
template <typename T>
struct or_t
{
or_t(const T& a, const T& b) : value1(a), value2(b)
{
}
bool operator==(const T& c)
{
return value1 == c || value2 == c;
}
private:
const T& value1;
const T& value2;
};
template <typename T>
or_t<T> or(const T& a, const T& b)
{
return or_t<T>(a, b);
}
In use:
int main(int argc, char** argv)
{
int a = 7;
int b = 9;
if (or(a, b) == 7)
{
}
return 0;
}
It performs the same comparison you would normally do, though, but at your convenience.
If you have lot of that code, you may consider a helping method:
bool distanceLE (Point p1, Point p2, double threshold) {
return (p1.distanceFrom (p2) <= threshold)
}
bool Circle2::contains (Line2 l) {
return distanceLE (p1, l.p1, r) && distanceLE (p1, l.p2, r);
}
If you sometimes have <, sometimes <=, >, >= and so on, maybe you should pass the operator too, in form of a function.
In some cases your intentions by writing this:
if ((a || b) == 0) return 1;
return 0;
could be expressed with an bitwise-or:
if ((a | b) == 0) return 1;
return 0;
and simplified to
return ! (a | b);
But read up on bitwise operations and test it carefully. I use them rarely and especially I didn't use C++ for some time.
Note, that you inverted the meaning between your examples 1 and 2, returning true and false in the opposite way.
And bitwise less-equal doesn't make any sense, of course. :)
C++ doesn't support any construct like that. Use if (a == 0 || b == 0).
Your condition should be (a == 0 || b == 0) or (p1.distanceFrom(l.p1) <= r || p1.distanceFrom(l.p2)) <= r)
C++ isn't that smart. You have to do each comparison manually.
bool Circle2::contains(Line2 l) {
if((p1.distanceFrom(l.p1) <= r) || (p1.distanceFrom(l.p2) <= r)) return 1;
return 0;
}