6.5. Variables and Parameters

No global or static variables [Global variable: 5-30 pts] [Static-variable: 5-30]

These notes have very little to say about global and static variables. A global variable is one that is not created inside a function. A static variable is created inside a function, but marked static.

Do not use global or static variables, with a single exception. You may use a global variable that is used only for debugging. For example, a variable that acts as a switch to turn on or off debugging is normally global.

Global constants are allowed.

Only use operators ++, --, +=, -=, etc. to create a statement. [IncdecExpr: 1-3 points]

You can write statement
or a similar statement using other operators such as --. But do not use n++ or ++n or n-- or --n in an expression.

Do not change the same variable twice in one statement [Double change: 1-3 points]

Do not write a statement that includes two explicit changes of a variable. For example, statement
  x = x++;
tries to change x twice. (This kind of thing has undefined behavior in C++.)

Uninitialized variables [Uninitialized variable: 1-5 points]

Do not use any variable before you have put a value in it.

Always ask the compiler to warn you about this.

Do not make a change that will surely not be seen [Invisible change: 1 point]

Do not use ++x where you really mean x+1. Do not change the value of a local variable when the changed value cannot possibly be looked at again. For example, do not write
  return test(y);
where x is a local variable.

Do not store a value into a local variable just to return it [Return variable: 1 pt]

If y is a local variable, do not write
  return y = x + 1;
which stores the value of x + 1 into variable y, and then immediately returns that value. There is no point to variable y. Just write
  return x + 1;

Avoid duplicate variables without justification [Dup variable: 1-2 points]

Look at the following function definition.
  int f(int x)
    int m = x;
    return m + x + 1;
Variable m is just another name for x. It is never changed. There is no reason to have two names for the same thing, and it only confuses things. A better definition is
  int f(int x)
    return x + x + 1;
There are some cases where having another variable is sensible.
  1. It can help to have a short name for an expression. For example,

      int v = g.info[i].v1;
    allows you to write a much shorter name for an expression. You are allowed to create a reference if you want to treat an awkward variable as a simple one, as in
      int& v = g.info[i].v1;
    Now each use of v, whether to get its value or to put a value in it, uses variable g.info[i].v1.

  2. If you intend to change a variable, so that it is not always identical to another variable, then you do not have a redundant variable. For example,

      int f(int x, int n)
        int m = x;
        while(m < n)
          m = m + 1;
    is reasonable. Variable m is not just another name for x since m changes but x does not.

No shadowing [Shadow: 1 point]

Do not create a variable in a place where another variable or constant of the same name exists. See shadowing. Option -Wshadow of g++ asks the compiler to warn you if you are shadowing something.

Do not create a variable whose name is the same as a function's name. Do not create a variable whose name is the same as the name of the function that it is in. For example, function sum should not have a variable called sum.

Do not change the value of a call-by-value parameter [Change CBV param: 1-5 points]

If a function parameter is passed by value, then do not change the value of that parameter anywhere in the function body. For example, function next defined by
  int next(int n)
    return n;
takes parameter n by value. It changes the value of n in the function body. Do not do that.