Declaring variables inside loops good practice or bad practice

Question

Question  1  Is declaring a variable inside a loop a good practice or bad practice   I ve read the other threads about whether or not there is a performance issue  most said no   and that you should always declare variables as close to where they are going to be used  What I m wondering is whether or not this should be avoided or if it s actually preferred   Example   for int counter   0  counter  lt   10  counter         string someString    testing       cout  lt  lt  someString      Question  2  Do most compilers realize that the variable has already been declared and just skip that portion  or does it actually create a spot for it in memory each time

User · Answer

I didn t post to answer JeremyRR s questions  as they have already been answered   instead  I posted merely to give a suggestion   To JeremyRR  you could do this       string someString    testing         for int counter   0  counter  lt   10  counter            cout  lt  lt  someString            The variable is in scope        The variable is no longer in scope    I don t know if you realize  I didn t when I first started programming   that brackets  as long they are in pairs  can be placed anywhere within the code  not just after  if    for    while   etc   My code compiled in Microsoft Visual C   2010 Express  so I know it works  also  I have tried to to use the variable outside of the brackets that it was defined in and I received an error  so I know that the variable was  destroyed    I don t know if it is bad practice to use this method  as a lot of unlabeled brackets could quickly make the code unreadable  but maybe some comments could clear things up

User · Answer

For C   it depends on what you are doing  OK  it is stupid code but imagine   class myTimeEatingClass    public     constructor       myTimeEatingClass                     sleep 2000             ms usedTime  2                 myTimeEatingClass                     sleep 3000             ms usedTime  3                const unsigned int getTime   const                   return  ms usedTime                static unsigned int ms usedTime        myTimeEatingClass  ms CreationTime 0   myFunc         for  int counter   0  counter  lt   10  counter               myTimeEatingClass timeEater              do something           cout  lt  lt   Creating class took   lt  lt  timeEater getTime    lt  lt  seconds at all lt  lt endl     myOtherFunc         myTimeEatingClass timeEater        for  int counter   0  counter  lt   10  counter                do something           cout  lt  lt   Creating class took   lt  lt  timeEater getTime    lt  lt  seconds at all lt  lt endl       You will wait 55 seconds until you get the output of myFunc  Just because each loop contructor and destructor together need 5 seconds to finish   You will need 5 seconds until you get the output of myOtherFunc   Of course  this is a crazy example   But it illustrates that it might become a performance issue when each loop the same construction is done when the constructor and   or destructor needs some time

User · Answer

Generally  it s a very good practice to keep it very close   In some cases  there will be a consideration such as performance which justifies pulling the variable out of the loop   In your example  the program creates and destroys the string each time  Some libraries use a small string optimization  SSO   so the dynamic allocation could be avoided in some cases   Suppose you wanted to avoid those redundant creations allocations  you would write it as   for  int counter   0  counter  lt   10  counter            compiler can pull this out    const char testing      testing      cout  lt  lt  testing      or you can pull the constant out   const std  string testing    testing   for  int counter   0  counter  lt   10  counter         cout  lt  lt  testing         Do most compilers realize that the variable has already been declared and just skip that portion  or does it actually create a spot for it in memory each time    It can reuse the space the variable consumes  and it can pull invariants out of your loop  In the case of the const char array  above  - that array could be pulled out  However  the constructor and destructor must be executed at each iteration in the case of an object  such as std  string   In the case of the std  string  that  space  includes a pointer which contains the dynamic allocation representing the characters  So this   for  int counter   0  counter  lt   10  counter         string testing    testing      cout  lt  lt  testing      would require redundant copying in each case  and dynamic allocation and free if the variable sits above the threshold for SSO character count  and SSO is implemented by your std library    Doing this   string testing  for  int counter   0  counter  lt   10  counter         testing    testing      cout  lt  lt  testing      would still require a physical copy of the characters at each iteration  but the form could result in one dynamic allocation because you assign the string and the implementation should see there is no need to resize the string s backing allocation  Of course  you wouldn t do that in this example  because multiple superior alternatives have already been demonstrated   but you might consider it when the string or vector s content varies   So what do you do with all those options  and more   Keep it very close as a default -- until you understand the costs well and know when you should deviate

User · Answer

Declaring variables inside or outside of a loop  It s the result of JVM specifications But in the name of best coding practice it is recommended to declare the variable in the smallest possible scope  in this example it is inside the loop  as this is the only place where the variable is used   Declaring objects in the smallest scope improve readability  The scope of local variables should always be the smallest possible  In your example I presume str is not used outside of the while loop  otherwise you would not be asking the question  because declaring it inside the while loop would not be an option  since it would not compile  Does it make a difference if I declare variables inside or outside a   Does it make a difference if I declare variables inside or outside a loop in Java  Is this for int i   0  i  lt  1000  i      int  At the level of the individual variable there is no significant difference in effeciency  but if you had a function with 1000 loops and 1000 variables  never mind the bad style implied  there could be systemic differences because all the lives of all the variables would be the same instead of overlapped  Declaring Loop Control Variables Inside the for Loop  When you declare a variable inside a for loop  there is one important point to remember  the scope of that variable ends when the for statement does   That is  the scope of the variable is limited to the for loop   This Java Example shows how to declare multiple variables in Java For loop using declaration block

User · Answer

Once upon a time  pre C  98   the following would break        for  int i 0  i lt      i   std  string foo       for  int i 0  i lt      i   std  string foo      with the warning that i was already declared  foo was fine as that s scoped within the       This is likely the WHY people would first argue it s bad   It stopped being true a long time ago though  If you STILL have to support such an old compiler  some people are on Borland  then the answer is yes  a case could be made to put the i out the loop  because not doing so makes it makes it  quot harder quot  for people to put multiple loops in with the same variable  though honestly the compiler will still fail  which is all you want if there s going to be a problem  If you no longer have to support such an old compiler  variables should be kept to the smallest scope you can get them so that you not only minimise the memory usage  but also make understanding the project easier   It s a bit like asking why don t you have all your variables global   Same argument applies  but the scopes just change a bit

User · Answer

This is excellent practice   By creating variables inside loops  you ensure their scope is restricted to inside the loop  It cannot be referenced nor called outside of the loop   This way    If the name of the variable is a bit  generic   like  i    there is no risk to mix it with another variable of same name somewhere later in your code  can also be mitigated using the -Wshadow warning instruction on GCC  The compiler knows that the variable scope is limited to inside the loop  and therefore will issue a proper error message if the variable is by mistake referenced elsewhere  Last but not least  some dedicated optimization can be performed more efficiently by the compiler  most importantly register allocation   since it knows that the variable cannot be used outside of the loop  For example  no need to store the result for later re-use    In short  you are right to do it   Note however that the variable is not supposed to retain its value between each loop  In such case  you may need to initialize it every time  You can also create a larger block  encompassing the loop  whose sole purpose is to declare variables which must retain their value from one loop to another  This typically includes the loop counter itself         int i  retainValue      for  i 0  i lt N  i                 int tmpValue            tmpValue is uninitialized              retainValue still has its previous value from previous loop               Do some stuff here                 Here  retainValue is still valid  tmpValue no longer        For question  2  The variable is allocated once  when the function is called  In fact  from an allocation perspective  it is  nearly  the same as declaring the variable at the beginning of the function  The only difference is the scope  the variable cannot be used outside of the loop  It may even be possible that the variable is not allocated  just re-using some free slot  from other variable whose scope has ended    With restricted and more precise scope come more accurate optimizations  But more importantly  it makes your code safer  with less states  i e  variables  to worry about when reading other parts of the code   This is true even outside of an if        block  Typically  instead of        int result                result   f1        if  result  then                         result   f2        if  result  then             it s safer to write                            int const result   f1            if  result  then                                         int const result   f2            if  result  then                   The difference may seem minor  especially on such a small example  But on a larger code base  it will help   now there is no risk to transport some result value from f1   to f2   block  Each result is strictly limited to its own scope  making its role more accurate  From a reviewer perspective  it s much nicer  since he has less long range state variables to worry about and track   Even the compiler will help better   assuming that  in the future  after some erroneous change of code  result is not properly initialized with f2    The second version will simply refuse to work  stating a clear error message at compile time  way better than run time   The first version will not spot anything  the result of f1   will simply be tested a second time  being confused for the result of f2     Complementary information  The open-source tool CppCheck  a static analysis tool for C C   code  provides some excellent hints regarding optimal scope of variables   In response to comment on allocation  The above rule is true in C  but might not be for some C   classes   For standard types and structures  the size of variable is known at compilation time  There is no such thing as  construction  in C  so the space for the variable will simply be allocated into the stack  without any initialization   when the function is called  That s why there is a  zero  cost when declaring the variable inside a loop   However  for C   classes  there is this constructor thing which I know much less about  I guess allocation is probably not going to be the issue  since the compiler shall be clever enough to reuse the same space  but the initialization is likely to take place at each loop iteration

User · Answer

It s a very good practice  as all above answer provide very good theoretical aspect of the question let me give a glimpse of code  i was trying to solve DFS over GEEKSFORGEEKS  i encounter the optimization problem       If you try to solve the code declaring the integer outside the loop will give you Optimization Error    stack lt int gt  st  st push s   cout lt  lt s lt  lt      vis s  1  int flag 0  int top 0  while  st empty         top   st top        for int i 0 i lt g top  size   i             if vis g top  i      1               st push g top  i                cout lt  lt g top  i  lt  lt                  vis g top  i   1              flag 1              break                      if  flag           st pop              Now  put integers inside the loop this will give you correct answer      stack lt int gt  st  st push s   cout lt  lt s lt  lt      vis s  1     int flag 0     int top 0  while  st empty         int top   st top        int flag   0      for int i 0 i lt g top  size   i             if vis g top  i      1               st push g top  i                cout lt  lt g top  i  lt  lt                  vis g top  i   1              flag 1              break                      if  flag           st pop              this completely reflect what sir  justin was saying in 2nd comment     try this here  https   practice geeksforgeeks org problems depth-first-traversal-for-a-graph 1  just give it a shot     you will get it Hope this help

User · Answer

Chapter 4 8 Block Structure in K amp R s The C Programming Language 2 Ed       An automatic variable declared and initialized in a   block is initialized each time the block is entered    I might have missed seeing the relevant description in the book like      An automatic variable declared and initialized in a   block is allocated only one time before the block is entered    But a simple test can prove the assumption held     include  lt stdio h gt                                                                                                        int main int argc  char  argv                                                                                               for  int i   0  i  lt  2  i                                                                                                    for  int j   0  j  lt  2  j                                                                                                    int k                                                                                                                   printf   p n    amp k                                                                                                                                                                                                                                                                                                                                               return 0

User · Answer

Since your second question is more concrete  I m going to address it first  and then take up your first question with the context given by the second  I wanted to give a more evidence-based answer than what s here already   Question  2  Do most compilers realize that the variable has already been declared and just skip that portion  or does it actually create a spot for it in memory each time   You can answer this question for yourself by stopping your compiler before the assembler is run and looking at the asm   Use the -S flag if your compiler has a gcc-style interface  and -masm intel if you want the syntax style I m using here   In any case  with modern compilers  gcc 10 2  clang 11 0  for x86-64  they only reload the variable on each loop pass if you disable optimizations  Consider the following C   program   for intuitive mapping to asm  I m keeping things mostly C-style and using an integer instead of a string  although the same principles apply in the string case   include  lt iostream gt   static constexpr std  size t LEN   10   void fill arr int a LEN                       for  std  size t i   0  i  lt  LEN    i            const int t   8           a i    t                         int main void        int a LEN        fill arr a        for  std  size t i   0  i  lt  LEN    i            std  cout  lt  lt  a i   lt  lt   quot   quot              std  cout  lt  lt   quot  n quot        return 0     We can compare this to a version with the following difference                    const int t   8       for  std  size t i   0  i  lt  LEN    i            a i    t                       With optimization disabled  gcc 10 2 puts 8 on the stack on every pass of the loop for the declaration-in-loop version      mov QWORD PTR -8 rbp   0  L3      cmp QWORD PTR -8 rbp   9     ja   L4     mov DWORD PTR -12 rbp   8     whereas it only does it once for the out-of-loop version      mov DWORD PTR -12 rbp   8        mov QWORD PTR -8 rbp   0  L3      cmp QWORD PTR -8 rbp   9     ja   L4  Does this make a performance impact  I didn t see an appreciable difference in runtime between them with my CPU  Intel i7-7700K  until I pushed the number of iterations into the billions  and even then the average difference was less than 0 01s  It s only a single extra operation in the loop  after all   For a string  the difference in in-loop operations is obviously a bit greater  but not dramatically so   What s more  the question is largely academic  because with an optimization level of -O1 or higher gcc outputs identical asm for both source files  as does clang  So  at least for simple cases like this  it s unlikely to make any performance impact either way  Of course  in a real-world program  you should always profile rather than make assumptions   Question  1  Is declaring a variable inside a loop a good practice or bad practice   As with practically every question like this  it depends  If the declaration is inside a very tight loop and you re compiling without optimizations  say for debugging purposes  it s theoretically possible that moving it outside the loop would improve performance enough to be handy during your debugging efforts  If so  it might be sensible  at least while you re debugging  And although I don t think it s likely to make any difference in an optimized build  if you do observe one  you your pair your team can make a judgement call as to whether it s worth it  At the same time  you have to consider not only how the compiler reads your code  but also how it comes off to humans  yourself included  I think you ll agree that a variable declared in the smallest scope possible is easier to keep track of  If it s outside the loop  it implies that it s needed outside the loop  which is confusing if that s not actually the case  In a big codebase  little confusions like this add up over time and become fatiguing after hours of work  and can lead to silly bugs  That can be much more costly than what you reap from a slight performance improvement  depending on the use case

[c++] Declaring variables inside loops, good practice or bad practice?

Examples related to c++

Examples related to loops

Examples related to variable-declaration