Declaring constants or using numbers inside the code - c++

Question

So, i have this C++ test and the teacher is really hard on declaring constants instead of using numbers directly in the code. In the example below i have even declared ZERO as a constant.
Is this unnecessary or is this a good thing to do? Does this way take up more memory or make the code "slower"?
int main() {
int kmStart, kmEnd;
const int ZERO = 0;
cout << "Starting Kms? ";
cin >> kmStart;
cout << "Ending Kms? ";
cin >> kmEnd;
while (kmStart < ZERO || kmStart > kmEnd) {
cout << "Invalid Input!" << endl << endl;
cout << "Starting Kms? ";
cin >> kmStart;
cout << "Ending Kms? ";
cin >> kmEnd;
}
}

Answer 1

constexpr int ZERO = 0; would almost certainly be completely compiled out.
Note the new keyword constexpr, from C++11 onwards.
For you current code, ZERO may well be compiled out, but even if it isn't any degradation in performance will be negligible cf. the input / output functions.
I wonder why your teacher regards ZERO to be clearer than 0. Everyone knows what they are dealing with when they see a 0. For example, ZERO could feasibly mean '0', or even "0" which are entirely different beasts: you'd always have be checking back through the code when debugging this.

Answer 2

Use of properly named constants is mandatory for a development of long-living applications. Managing plain numeric literals quickly goes off hands. Consider the following example:
foo(42);
bar(42);
It has several problems:
it is not possible to guess where 42 value came from
it is not possible to guess whether 42 in both function calls is just a coincidence or we are intentionally passing the same value
as a consequence of the previous point changing program behavior may be challenging because we need to manually identify all the places where particular value that we want to adjust is utilized
If your application consists of hundreds of files it will be a literal nightmare.
So if constants are used instead the example code piece may become
constexpr int const fast_foobing_rate{42};
constexpr int const slow_barring_coeff{42};
foo(fast_foobing_rate);
bar(slow_barring_coeff);
or
constexpr int const days_in_week_count{7};
constexpr int const frobbing_weeks_count{6};
inline constexpr int get_frob_repetitions_count(void) noexcept
{
return(days_in_week_count * frobbing_weeks_count);
}
foo(get_frob_repetitions_count());
bar(get_frob_repetitions_count());
So now:
we are able to track origins of values
we can locate places where these persistent values are used
we can easily adjust these persistent values by modifying their definitions and our changes will be automatically applied across the entire codebase
And with all these benefits we won't suffer from performance penalties. Depending on constant type there could even be some benefits for performance as well.

Answer 3

In general, using constants instead of numbers in the code directly can make your code more readable and easier to maintain.
Consider the following example:
For example you have some kind of simulation with a timestep of 0.1 seconds and you need this timestep value in different locations of your source code, then it would be easier to use a
const double timesstep = 0.1
instead of writing 0.1 every where.
Advantage is:
only one line must be changed if you want to change the value of
timestep
the code becomes more readable, if you know the constants meaning
But in your case, I think its more readable to use 0 instead of zero, or you rename it to something more expressive as "minimum_start" or something like that...

Answer 4

Personnaly, for integer constant I am using enumerations (source == Scott Meyer, Effective C++) :
int main (int argc, char* argv []) {
enum Constant {
NTRY = 32,
NEQ = 8,
SMAX = 200000000,
ALERT = 65536
};
size_t ntry (Constant::NTRY);
std::cout << "ntry == " << ntry << std::endl;
return 0;
}