It's not a case of not understanding the ternary operator, it's a way to make your code more understandable for future developers who will not want to pick their way through every line in detail. Calling the method GetMin(a, b) perfectly describes what that method does and removes any ambiguity as to it's behavour.
It's definately a situational thing. I would not advocate that every multiply option is wrapped up in every case, but you posted example code which is very difficult to follow without it being refactored out into smaller, understandable, sections and therefore is a perfect candidate.
This is a very common thing to do. Take a look at some of the methods available in the .NET framework for the string object. Microsoft have provided stuff like 'string.IsNullOrEmpty()'. I'm guessing that you can tell what that method does without seeing a line of code underneath it, or even having to think about it at all. The code underneath is a simple one-liner, but it increases the readability of the code if it's used.
It's all about giving future developers of your code the best possible chance of understand what you are doing after the documenation has either been lost in time or falls out of line with the code (which *will* happen. Have you updated the documenation with the code changes you've made in this thread yet?
)
In regards to the performance increase... get a better compiler. A modern compiler should generate the same asm no matter if you write a ternary or the equivalent 'if' statement (more evidence of this here -
http://stackoverflow.com/questions/...nce-between-if-else-and-ternary-operator-in-c)
The thing is, if I wanted a function to getMin then i would want one available across classes, better still I would just use the built in min function.
But if don't want the function overhead then using the ternary operator as it is, is going to be much faster. If performance matters, then the over head is too expensive, if the function is rarely called then the overhead is acceptable.
Methods like the ExtendBoundsY are very useful and have always been in this class, but there isn't always a good reason to call those methods internally
In my example a developer just needs to know that the bounding box of a vector of points is computed by iterating over all points and assigning the min and max of the latitude and longitude to the x, and y respectively. that is self evident from the ternary operators, especially with the variables names min.x = ???? is obviously assigning the min on the x dimension based on the condition. If the user is wanting to extend the bounding box to include a new point P I don't expect them to use 4 new ternary operators, because yes they might make a mistake. Instead they just use use the Extend(const Point& p) class method.
This might be different if the comparisons were some more complex function liable to coding errors but simple 1 line single op, no, not needed. As I said, you would never write a function to increment an index For example, what you seem to be advocating is something like this:
Code:
int addOne(int i)
{
return i + 1;
}
int getZero()
{
return 0;
}
bool isLessThan(int i, int j)
{
return i < j;
}
...
...
vector<int> vec = ........./// contains some times
for (int i = getZero(); isLessThan(i,vec.size()); i = addOne(i))
{
// do something with vec[i]
}
You can go far too far factoring code to the point that it reduced readability and massively impacts performance.
Containers and strings (strings are just vectors of underlying datatypes) have simple methods like size) and empty() because the underlying datastructure ultimately has a private int size value that it is making available through an accessor.
just have a look at some of the math functions or hashing and the like, hundreds and hundreds of lines of dense code, complex logic, taking advantage of peculiarities in integer or floating point instruction sets and loads of general trickery that outsiders can never easily understand. Why, because it provides highly performant code
have a look here to see some trig code from libC:
https://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/ieee754/dbl-64/s_sin.c;hb=HEAD
And lastly, you have no guarantee what the compiler does, compilers can be very stupid. Some If statements might be compiled into the same conditional assignment instruction, but you have no guarantee. One reason why my example code was 5x slower using IF statements was that dependent on the result of the min test the max value was conventionalized. Therefore this was compiled as a branch, and branches are far slower than a specialized single instruction.
The code was compiled with the latest GCC version 4.8.1 with O3 optimizations. This effect has nothing to do with a bad compiler.
