21–30 of 57 posts
int a = f();
if (a Assuming MAX(0,f()) expands to something like this:
if( f() int a = f(); if (a I believe the latter will generally result in 2 calls to f() (unless it returns less than zero), which could cause undesired behavior or just be inefficient. Of course, it depends on what f() does. Assuming MAX(0,f()) expands to something like this: if( f()
> if (a
> has been replaced with
> const int a = MAX(0,f());
Going by MAX capitalization, it must be a macro, in which case the code is wrong. I am guessing this is a synthetic example, but still - try and get the basics right.
int a = f(); if (a I believe the latter will generally result in 2 calls to f() (unless it returns less than zero), which could cause undesired behavior or just be inefficient. Of course, it depends on what f() does. Assuming MAX(0,f()) expands to something like this: if( f()
template
const T& max(const T& a, const T& b) {
return a
const T& max(const T& a, const T& b, Predicate p) {
return p(a, b) ? b : a;
}
#define MAX(a, b) ((a) > int a = f(); > if (a > has been replaced with > const int a = MAX(0,f()); Going by MAX capitalization, it must be a macro, in which case the code is wrong. I am guessing this is a synthetic example, but still - try and get the basics right.
map and fold are available in C++, though they're called std::transform (in ) and std::accumulate (in ). Totally agree with the author's point, the C++ I write nowadays is heavily influenced by my Scala/Haskell/Lisp exposure and is much better for it.
> int a = f(); > if (a > has been replaced with > const int a = MAX(0,f()); Going by MAX capitalization, it must be a macro, in which case the code is wrong. I am guessing this is a synthetic example, but still - try and get the basics right.
Technically, the code is wrong only if f() is not pure.
So if you want to grow as an engineer and computer scientist, learn these languages. You'll learn a lot fast, and not just about one programming paradigm (FP) but about complexity and how to manage it. You'll just learn a lot more about software because the way to learn software is to write it and one person can actually accomplish significant things in these languages. Java and C++ demote the individual contributor: "commodity" developers crank out classes and a more senior "architect" figures out how to bolt them together.
That said, these languages won't improve your performance in typical Java and C++ jobs. Six months of practice for exposure might give you some new ideas and make your code and performance better. Beyond that, they might diminish it. Why? Because you start hating these languages (Java and C++) and the accidental complexity they throw at you, which starts to look foreign and unnecessary. You get to a point where your own code (if you use the idioms of these languages, and you probably should, because it's not just about you) starts to look like someone else's. When you start hating your own code, disengagement sets in and it gets ugly fast. I can "hack" Java and C++ but I certainly wouldn't do a major project in them at this point.
My Java and C++ are uninspired now that I know better languages. Often, the only way I can write decent Java is to write it first in Scala (which I like, a lot) and transliterate the solution. Whether this produces "good" Java I don't even know.
Also, I really believe that C++ is the 21st-century COBOL. Java was gunning for that distinction, but Scala and Clojure gave it an assembly-like status, as the lowest-level language on the JVM (which will remain important for at least 15 years because of Scala and Clojure).
int a = f(); if (a I believe the latter will generally result in 2 calls to f() (unless it returns less than zero), which could cause undesired behavior or just be inefficient. Of course, it depends on what f() does. Assuming MAX(0,f()) expands to something like this: if( f()
It was a poor choice on the part of the author to use the macro-looking MAX() in his example. There is in fact a standard max() function in the header that does not suffer from silly macro-expansion problems: template const T& max(const T& a, const T& b) { return a const T& max(const T& a, const T& b, Predicate p) { return p(a, b) ? b : a; } And your definition of MAX() is wrong, not just because of multiple evaluati…
That said, for me, your code would be clear, as not being in all caps, I would assume it's a function and therefore doesn't have the same weakness.
As someone else pointed out, there's no way you can look at MAX(0,f()) and know that it's enforced that f() is only used once within the macro.
Earlier quoted context omitted.
Technically, the code is wrong only if f() is not pure.
Yes, I know, but there is no way to enforce it. This a classic "noob" mistake with macros - using a macro argument more than once.
Of course, people still misuse macros.