A reusable variable: still good to define in the scope that uses it?

[SlurrerOfSpeech]

I'll give you an example.

Let's say I have a snippet of code like

   while(*s2)
   {
       char* c = s1;
       while(*c++==*s2++);
       if(!*c)
       {
          flag=true;
          break;
       }
       else
       {
          flag=false;
       }
   }

(which is a real snippet of code I have).

One might alternatively write it like

    char* c;
   while(*s2)
   {
       c = s1;
       while(*c++==*s2++);
       if(!*c)
       {
          flag=true;
          break;
       }
       else
       {
          flag=false;
       }
   }

The main argument I can see for the first way is

"The variable c is only used in the while loop and therefore should be defined there as best practice."

The main argument I can see for the second way is

"It's equiavlent and more efficient because you don't have to initialize c during every iteration of the while loop."

What are your thoughts?

 

[DrClaude]

The main argument I can see for the second way is

"It's equiavlent and more efficient because you don't have to initialize c during every iteration of the while loop."

This is not a correct statement. In both cases, what changes is where c is declared, not initialized. After compilation, there will be no difference between the two pieces of code. The first approach is preferable.

 

[Integrand]

You can verify DrClaude's claim easily at http://gcc.godbolt.org/. It is a very convenient tool for showing how your code maps to the machine.

(In many cases, it will also show just how much work your compiler does for you. This can give you confidence in writing the clearest code you can think of, and leaving micro-optimization to the compiler. It's usually much better at it than you. Modern optimizing compilers are remarkable.)

 

[jedishrfu]

The only advantage for c being defined outside of the loop is if you need to reference later on outside of the loop.

In either case, the code you've shown gives me a headache as you have to remember the operator precedence for the more arcane C operators and its easy to get it wrong. I especially hate the expression: *c++==*s2++

 

[newjerseyrunner]

I especially hate the expression: *c++==*s2++

Good lord. Yeah, at least get some parenthesis in there.Uhh... your code is incorrect. That can also go pass the null terminator easily if the strings are the same length.

 

[SlurrerOfSpeech]

This is not a correct statement. In both cases, what changes is where c is declared, not initialized. After compilation, there will be no difference between the two pieces of code. The first approach is preferable.

Sorry, the mord I meant to use is instantiated.

 

[newjerseyrunner]

The only advantage for c being defined outside of the loop is if you need to reference later on outside of the loop

Bad idea, I could cause that to give you undefined behavior by setting s2 = ""; If your planning on using something outside of a loop that may run 0-n times, you should always initialize it. I like to initialize my variables outside of loops even if I'm 100% sure it'll run at least once, it prevents me from messing things up if I refactor it later.

 

[jim mcnamara]

Hint: smashing things together in one line of code is all of these: cool, hard to read, more prone to problems.
So, what do you gain: cool? Not cool actually.

Quite simply: Don't do that. The compiler will undo it anyway. Follow the advice @Integrand gave you.

Plus I would suggest very strongly that you learn the standard C library, one member of which does what it appears your code tries to do.
See if you can tell us which one that is. Try the string section, you know strcmp() and friends.

 

[QuantumQuest]

It is a question of the well known software engineering "least privilege" principle: at every function or construct for procedural code and their counterparts in OOP, you must always give a variable the least chance to be modified by the rest of your code or so to speak, you always have to begin in local scope and expand to the "outside" only for very good reasons.

 

[jedishrfu]

Bad idea, I could cause that to give you undefined behavior by setting s2 = ""; If your planning on using something outside of a loop that may run 0-n times, you should always initialize it. I like to initialize my variables outside of loops even if I'm 100% sure it'll run at least once, it prevents me from messing things up if I refactor it later.

I didn't mean not to initialize it only that if you need it later then you promote it to the next higher scope. I figured it wasn't apparent as often posters don't post all of their code.