CODEWITHSUNDEEP
c++coding-stylec-preprocessor
zar
zar

Reputation: 12247

Will it be odd to #define inside a C++ function?

My little C++ function needs to calculate a simple timeout value.

CalcTimeout(const mystruct st)
{
    return (st.x + 100) * st.y + 200;
}

The numbers 100 and 200 would be confusing to read the code later so I would like to use #define for them. But these defines are only going to be needed for this function only, can I define them inside the function? The advantages this way are:

The disadvantage can be it is rather crude way to define something like local variable/const but it is obviously not local.

Other than that would this be odd to #define inside a C++ function? Most of the time we use #defines at the top of the file. Is using const variables better in any way in replacing a fixed local hard coded value like this?

The objective really is make code more readable/understandable.

Upvotes: 4

Views: 4328

Answers (2)

AnT stands with Russia
AnT stands with Russia

Reputation: 320719

In C++ specifically it would be rather weird to see macros being used for that purpose. In C++ const completely replaces macros for defining manifest constants. And const works much better. (In C you'd have to stick with #define in many (or most) cases, but your question is tagged C++).

Having said that, pseudo-local macros sometimes come handy in C++ (especially in pre-C++11 versions of the language). If for some reason you have to #define such a macro "inside" a function, it is a very good idea to make an explicit #undef fro that macro at the end of the same scope. (I enclosed the word inside in quotes since preprocessor does not really care about scopes and can't tell "inside" from "outside".) That way you will be able to simulate the scoped visibility behavior other local identifiers have, instead of having a "locally" defined macro to spill out into the rest of the code all the way to the end of the translation unit.

Upvotes: 3

Mike Seymour
Mike Seymour

Reputation: 254721

Don't use a macro to define a constant; use a constant.

const int thingy = 100;  // Obviously, you'll choose a better name
const int doodad = 200;

return (st.x + thingy) * st.y + doodad;

Like macros that expand to constant expressions, these can be treated as compile-time constants. Unlike macros, these are properly scoped within the function.

If you do have a reason for defining a macro that's only used locally, you can use #undef to get rid of it once you're done. But in general, you should avoid macros when (like here) there's a language-level construct that does what you want.

Upvotes: 17

Related Questions