When to use int, const int, const byte and Define

When compiling, you have multiple steps, three of them being preprocessor, compiler and linker in that order

The preprocessor takes your source files, modifies them "in memory" and passes the result to the compiler

The compiler takes its input and generates machine code in the form of object files (.o)

The linker takes all object files and creates the final application file (.exe under Windows, .bin for firmware...)

#define NAME value tells the preprocessor to replace NAME by value wherever it sees it. It is just like copy/paste but done for you by the preprocessor, which means the compiler will never see the NAME item, only a repetition of value in lots of places

const int and int only differ in semantics, the "const" specifier telling the compiler that it should not allow any code to change the value. As this is seen by the compiler, you can "take" the address of the constant by using the ampersand (&) operator, which might be required by some libraries and is even more convenient when dealing with structures because all you deal with is a pointer (32 bits on 32 bits architecture) and not the entire structure itself (that can range in the dozen of bytes)

Finally, the linker can do some serious optimizations with constants when they have the same value by "merging" them together, meaning that 10 constants with the same value only occupy their size once in the final firmware. While this does not mean much under desktop OSes, it can be very important on embedded architectures.
One other benefit of "const" is that on architectures like the ESP32, the value is not placed in RAM but in Program memory. As RAM is very limited (120k contiguous at most), it is of the utmost importance to place as little things as possible in there.

When compiling, you have multiple steps, three of them being preprocessor, compiler and linker in that order

The preprocessor takes your source files, modifies them "in memory" and passes the result to the compiler

The compiler takes its input and generates machine code in the form of object files (.o)

The linker takes all object files and creates the final application file (.exe under Windows, .bin for firmware...)

#define NAME value tells the preprocessor to replace NAME by value wherever it sees it. It is just like copy/paste but done for you by the preprocessor, which means the compiler will never see the NAME item, only a repetition of value in lots of places

const int and int only differ in semantics, the "const" specifier telling the compiler that it should not allow any code to change the value. As this is seen by the compiler, you can "take" the address of the constant by using the ampersand (&) operator, which might be required by some libraries and is even more convenient when dealing with structures because all you deal with is a pointer (32 bits on 32 bits architecture) and not the entire structure itself (that can range in the dozen of bytes)

Finally, the linker can do some serious optimizations with constants when they have the same value by "merging" them together, meaning that 10 constants with the same value only occupy their size once in the final firmware. While this does not mean much under desktop OSes, it can be very important on embedded architectures.
One other benefit of "const" is that on architectures like the ESP32, the value is not placed in RAM but in Program memory. As RAM is very limited (120k contiguous at most), it is of the utmost importance to place as little things as possible in there.

 obones 

obones said:

#define NAME value tells the preprocessor to replace NAME by value wherever it sees it. It is just like copy/paste but done for you by the preprocessor, which means the compiler will never see the NAME item, only a repetition of value in lots of places

Sorry you don't get the star for this, you the  Penalty Box. "the #define" is a not copy and paste! It is a MACRO de-expansion tool. please see this example which I posted just before you did. " square #define sqr(a)  ((a)*(a)",  this is not copy and paste! just for giggles you can also do pi which is NOT in the Math lib you can do this:  #define pi 3.1416  kind of this and then nothing is correct you could use this: π=atan2(0,−1) now turn this into a 

#define  pi  atan2(0, -1)  

Cris.

Yeah, you can do all kind of crazy stuff with the preprocessor, it's turing complete after all.

But for a "beginner's" explanation, seeing it a as copy/paste tool that replaces a given text by another one before sending it to the compiler is a much simpler way to grasp what it does.

And that also helps a lot understanding why the compiler will emit error messages that never mention the preprocessor symbol, which can be off putting when starting to work with this kind of concepts.

I don't agree, I taught K&R C on the side to students that had one semester. of Pascal. The two languages are very similar in construction ie semantically, even though one is a compiler, and the other is an interpreter. After getting to un-learn Pascals over the use of English to describe variables ( like fred_ponts_to_tom. the #derine though yes I start out with #define FAIL -1

but in the same had I also showed them things like a square which is #define SQR(a)  ((a)*(a)) and also pi see above and for pete sake hallway make your defines in UPPERCASE

If you try and learn a programing language you need to learn ALL of it. not some of it. 

btw what to make you Android programing easier?? don't use void loop()  as guess what void loop is a defined macro and invokes main()

which means now you can have return codes in main()   like int main( ){  return FAIL;}

phoenixcomm said:

btw what to make you Android programing easier?? don't use void loop()  as guess what void loop is a defined macro and invokes main()

Are you sure about that one?