I know it is maybe a little noobie question, But I want to know,
Is using raw number faster than reading it from a variable ? (not talking about the time it requires to initialize the variables, only the read time)
I am talking about situations that I define a global variable and use it so it would be easier to read and understand the code, what does it cost extra time?
Could you write some code snippets to demonstrate the two different ways you have in mind? By "raw numbers" I'm guessing you probably mean numeric constants. If you write some code samples, then you can also check the generated assembly for those code samples to see if there is a difference. Normally the optimizer should be able to automatically make an intelligent choice about two possibilities if there is a difference in speed to be had.
If you were using a global variable, it would make it harder to read and understand the code, so that's surely not what you're doing. If you mean #define, then that name is replaced by the actual number before the compiler actually sees it.
And for that matter, for a number to be used it pretty much has to end up in a register anyway, whether it be directly loaded or copied from memory. Directly loading may be marginally faster, but I doubt the difference would be measurable.
Yeah, I meant using a global variable (#define)
Code:#define ZERO 0 #define TEN 10 int i; //this is using the constants for(i = ZERO; i < TEN; i++){ ..... } //this is using "raw" numbers for(i = 0; i < 10; i++){ ..... }
A macro constant is not a "global variable" in the sense that we commonly speak of global variables. Your macro constant will be replaced at compile time with its value, hence there is no accessing of a variable: the resulting code could well be identical.Originally Posted by patishi
Furthermore, a compiler may (or may not) apply optimisations with respect to variables with constant values. As such, you should strive to use what expresses your intention better and which makes your code easier to read and understand. In this case, the use of the named constant would be better if the name is descriptive: ZERO and TEN are not really better than 0 and 10 since all you did was use the English names of those magic numbers.
Look up a C++ Reference and learn How To Ask Questions The Smart Way
Yeah, ofcourse I just gave those as an example. My real intention is using
instead of 0 and 1 in a game for example.. orCode:enum{WHITE,BLACK}
.Code:enum{FALSE,TRUE}
So you are saying that #define constant is faster than using a normal constans variable?
That could be a good idea.
No, I am saying that: "you should strive to use what expresses your intention better and which makes your code easier to read and understand". If you require your constant to have a limited scope, then a variable declared const could well be appropriate since variables obey the normal rules of scope whereas macros do not. On the other hand, if you want to use the constant to declare an array, and you don't want the array to be variable length, then you would likely declare it as a macro constant.
Look up a C++ Reference and learn How To Ask Questions The Smart Way
Nobody said that. The only way you could find out if that is true is to test it - write two versions of the code that differ only in this specific, develop a test harness so you can gather proper timing measurements by doing the same operations (say) a few billion times, and measure. Repeat for all possible compilers, compiler settings (particularly optimisation settings), and operating systems.
On balance, after a couple of years of your life have been wasted on working this out, you will probably find there is little difference, but that the specifics will vary between compilers. Sometimes a #define will work faster, sometimes an enum will, most of the times the difference will not be significant enough to worry about.
Personally, I'd stick with the enums. The advantages in terms of having understandable code that is easier to get right vastly exceed the occasional saving of CPU cycles you might achieve if you find that some other approach is a picosecond faster on average.
And, by using enums, I would avoid the label "premature optimiser", which you have just earned.
In general compile time constants will probably end up as immediate values as part of instructions, while variables will be loaded from memory, so the compile time constants will be slightly faster. It doesn't matter if the compile time constants are defines, numbers, or enums.
I think the OP has a worthwhile question but more often than not, algorithms >>>>>> such small changes to code.
The question is about trying to find a general answer, where there is no general answer, and where any real-world difference probably doesn't matter
There is no single answer of the form "#define's are more efficient than an enum". If the compiler is smart enough, it will pick the most efficient of the two, so performance does not need to be a factor in deciding which to use. If the compiler is not that smart, it is pretty rare for the difference to even matter for the (user of) the software - and the right answer depends on host machines, compilers, and even compiler settings (i.e. it depends).
It takes considerable effort to get non-trivial code working and to keep it working when maintaining it. If there is not a demonstrated need (e.g. identified through testing and profiling the working software, once some overall performance deficiency is experienced by end users or by excess power usage in a server farm) there is no point worrying about such low level details. Pick the one that is easiest to understand and maintain, that a compiler can detect problems with, etc etc. Usually that means it is better to use enums over #defines.
Pretty sure enums are compile-time constructs only. They should produce code exactly the same as if you used #define (or a literal value).
Indeed. In theory an enum is just an integer literal with compile-time type-safety around it.
Other than possible checking that the value of an enum typed variable holds a value that corresponds to one from the enumeration, which I doubt is common, I would expect identical assembly code.
I would recommend as a first step here to make sure you know the correct terminology for things, i.e. learn what these are:
Global variable
Local variable
Enumeration Definition
Enumeration variable
Integer literal
Pre-processor Macro
My homepage
Advice: Take only as directed - If symptoms persist, please see your debugger
Linus Torvalds: "But it clearly is the only right way. The fact that everybody else does it some other way only means that they are wrong"
