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

  • #1
SlurrerOfSpeech
141
11
I'll give you an example.

Let's say I have a snippet of code like

Code:
   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

Code:
    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?
 
Last edited by a moderator:

Answers and Replies

  • #2
DrClaude
Mentor
7,967
4,644
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.
 
  • Like
Likes FactChecker
  • #3
Integrand
66
24
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.)
 
  • Like
Likes FactChecker and DrClaude
  • #4
14,074
8,029
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++
 
  • #5
newjerseyrunner
1,535
637
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.
 
  • #6
SlurrerOfSpeech
141
11
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.
 
  • #7
newjerseyrunner
1,535
637
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.
 
  • #8
jim mcnamara
Mentor
4,674
3,595
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 :nb) tries to do.
See if you can tell us which one that is. Try the string section, you know strcmp() and friends.
 
  • #9
QuantumQuest
Science Advisor
Insights Author
Gold Member
926
483
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.
 
  • Like
Likes FactChecker
  • #10
14,074
8,029
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.
 

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

Replies
3
Views
313
Replies
17
Views
590
Replies
0
Views
254
Replies
20
Views
717
Replies
13
Views
1K
Replies
16
Views
483
Replies
5
Views
521
Top