4.2 Declarations

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.