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_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)


       in_word = false;

     } else if (! in_word)

       in_word = true;

    if (in_word)



  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 {


  cls(  );

  cls(int x);


int x;

int* y = &x;

int main(  )


  // The following are unambiguously expressions, constructing instances of cls.



  // 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.