Question

I a writing a Simulation program and wondering if the use of const double is of any use when storing intermediate results. Consider this snippet:

double DoSomeCalculation(const AcModel &model) {
   (...)
   const double V = model.GetVelocity();
   const double m = model.GetMass();
   const double cos_gamma = cos(model.GetFlightPathAngleRad());
   (...)
   return m*V*cos_gamma*Chi_dot;
}

Note that the sample is there only to illustrate — it might not make to much sense from the engineering side of things. The motivation of storing for example cos_gamma in a variable is that this cosine is used many time in other expressions covered by (…) and I feel that the code gets more readable when using

cos_gamma 

rather than

cos(model.GetFlightPathAngleRad())

in various expressions. Now the actual is question is this: since I expect the cosine to be the same througout the code section and I actually created the thing only as a placeholder and for convenience I tend to declare it const. Is there a etablished opinion on wether this is good or bad practive or whether it might bite me in the end? Does a compiler make any use of this additional information or am I actually hindering the compiler from performing useful optimizations?

Arne

Answer 1

Given your code:

const double V = model.GetVelocity();
const double m = model.GetMass();
const double cos_gamma = cos(model.GetFlightPathAngleRad());

I would probably leave cos_gamma as it is. I’d consider changing V and m to references though:

const double &V = model.GetVelocity();
const double &m = model.GetMass();

This way you’re making it clear that these are strictly placeholders. It does, however, raise the possibility of lifetime issues — if you use a reference, you clearly have to ensure that what it refers to has sufficient lifetime. At least from the looks of things, this probably won’t be a problem though. First of all, GetVelocity() and GetMass() probably return values, not references (in which case you’re initializing the references with temporaries, and the lifetime of the temporary is extended to the lifetime of the reference it initializes). Second, even if you return an actual reference, it’s apparently to a member of the model, which (at a guess) will exist throughout the entire calculation in question anyway.