Declare variables at top of function or in separate scopes?

by

Variables should be declared as locally as possible.

Declaring variables “at the top of the function” is always a disastrously bad practice. Even in C89/90 language, where variables can only be declared at the beginning of the block, it is better to declare them as locally as possible, i.e. at the beginning of smallest local block that covers the desired lifetime of the variable. Sometimes it might even make sense to introduce a “redundant” local block with the only purpose of “localizing” the variable declaration.

In C++ and C99, where it is possible to declare variable anywhere in the code, the answer is pretty straightforward: again, declare each variable as locally as possible, and as close as possible to the point where you use it the very first time. The primary rationale for that is that in most cases this will allow you to supply a meaningful initializer to the variable at the point of declaration (instead of declaring it without initializer or with a dummy initializer).

As for the memory usage, in general a typical implementation will immediately (as you enter the function) allocate the maximum space required for all variables that exist at the same time. However, your declaration habits might affect the exact size of that space. For example, in this code

void foo() {
  int a, b, c;

  if (...) {
  }

  if (...) {
  }
}

all three variables exist at the same time and generally the space for all three has to be allocated. But in this code

void foo() {
  int a;

  if (...) {
    int b;
  }

  if (...) {
    int c;
  }
}

only two variables exist at any given moment, meaning that space for only two variables will be allocated by a typical implementation (b and c will share the same space). This is another reason to declare variables as locally as possible.

More Related Contents:

  1. Get error say no match for call in c++ [closed]
  2. Questions regarding constructors
  3. does cout before return statement of recursive function stops it?
  4. Function does not change passed pointer C++
  5. Calling delete on variable allocated on the stack
  6. What is the point of function pointers?
  7. Difference between void main and int main in C/C++? [duplicate]
  8. Global memory management in C++ in stack or heap?
  9. Should I use std::function or a function pointer in C++?
  10. C++ overload resolution [duplicate]
  11. How do I avoid implicit conversions on non-constructing functions?
  12. How to pass a constant array literal to a function that takes a pointer without using a variable C/C++?
  13. Stack-buffer based STL allocator?
  14. How to cin values into a vector
  15. Why should default parameters be added last in C++ functions?
  16. Difference between a virtual function and a pure virtual function [duplicate]
  17. Is it possible to std::move objects out of functions? (C++11)
  18. Simplest way to determine return type of function
  19. Using boost thread and a non-static class function
  20. Is it legal to use the increment operator in a C++ function call?
  21. How to create a template function within a class? (C++)
  22. switch “transfer of control bypasses initialization of:” when calling a function
  23. Store results of std::stack .pop() method into a variable
  24. How to clone object in C++ ? Or Is there another solution?
  25. Function returning array but main showing garbage [duplicate]
  26. How does the friend keyword (Class/Function) break encapsulation in C++?
  27. What does *& mean in a function parameter
  28. Boost.Python: Wrap functions to release the GIL
  29. order of evaluation of function parameters
  30. Differences of using “const cv::Mat &”, “cv::Mat &”, “cv::Mat” or “const cv::Mat” as function parameters?

Leave a Comment