4.2 Declarations

A declaration can appear anywhere a statement appears, and certain statements permit additional declarations within those statements.

Declarations made in a substatement (of a selection or loop statement) are limited in scope to the substatement, even if the substatement is not a compound statement. For example, the following statement:

while ( test(  ) )
  int x = init(  );

is equivalent to:

while ( test(  ) ) {
  int x = init(  );
}

The first example uses a declaration as the entire loop body, and the second uses a compound statement (enclosing the loop body in curly braces). In both cases, though, the scope of x is limited to the body of the while loop.

4.2.1 Declaration Statements

A simple declaration can appear wherever a statement can be used. You can declare an object, a type, or a namespace alias. You can also write a using declaration or using directive. You can declare a function, but not define a function, although there is rarely any reason to declare a function locally. You cannot define a namespace or declare a template.

In traditional C programming, declarations appear at the start of each block or compound statement. In C++ (and in the C99 standard), declarations can appear anywhere a statement can, which means you can declare variables close to where they are used. Example 4-1 shows examples of how declarations can be mixed with statements.

Example 4-1. Mixing declarations and statements

#include <cctype>
#include <cstddef>
#include <iomanip>
#include <iostream>
#include <ostream>
#include <string>

// Count lines, words, and characters in the standard input.
int main(  )
{
  unsigned long num_lines, num_words, num_chars;

  num_lines = num_words = num_chars = 0;

  using namespace std;
  string line;
  while (getline(cin, line)) {
    ++num_lines;
    num_chars += line.length(  ) + 1;

    bool in_word = false;
    for (size_t i = 0; char c = line[i]; ++i)
     if (isspace(static_cast<unsigned char>(c))) {
       if (in_word)
         ++num_words;
       in_word = false;
     } else if (! in_word)
       in_word = true;
    if (in_word)
      ++num_words;
  }
  cout << right <<
    setw(10) << num_lines <<
    setw(10) << num_words <<
    setw(10) << num_chars << '\n';
}

Sometimes a construct can look like an expression statement or a declaration. These ambiguities are resolved in favor of declarations. Example 4-2 shows some declarations that look like they might be expressions.

Example 4-2. Declarations that seem like expressions

class cls {
public:
  cls(  );
  cls(int x);
};

int x;
int* y = &x;

int main(  )
{
  // The following are unambiguously expressions, constructing instances of cls.
  cls(int(x));
  cls(*static_cast<int*>(y));

  // Without the redundant casts, though, they would look like declarations, not
  // expressions.
  cls(x);   // Declares a variable x
  cls(*y);  // Declares a pointer y
}

4.2.2 Condition Declarations

The for, if, switch, and while statements permit a declaration within each statement's condition:

if (int x = test_this(a, b)) { cout << x; }

If the condition contains a declaration, the scope of the declared name extends to the end of the entire statement. In particular, a name declared in the condition of an if statement is visible in the else part of the statement. In a loop, the condition object is created and destroyed for each iteration of the loop. The name cannot be redeclared in the immediate substatement (but can be redeclared in a nested statement). The name is not visible in subsequent statements. For example:

if (derived* d = dynamic_cast<derived*>(b)) {
  d->derived_only_func(  );
} else {
  assert(d == NULL); // Same d as above
  double d;          // Error: can't redeclare d
  if (d == 0)
    int d;           // Valid: inner block
}
cout << d;           // Invalid: d no longer in scope

Like the if, switch, and while statements, a for loop permits a declaration in its condition. Unlike those other statements, it also allows a declaration to initialize the loop. Both declarations are in the same scope. See Section 4.5.2 for details.

The syntax for a condition declaration is:

type-specifiers declarator = expression

This syntax is similar to the syntax of a simple object declaration. In this case, the initializer is required (without it, the condition would not have a value), and only one declarator is permitted. See Chapter 2 for more information about type specifiers and declarators.