Shulou(Shulou.com)06/01 Report--

This article mainly introduces the relevant knowledge of "what are the types of automatic variables in C language and how to use them?" the editor shows you the operation process through actual cases, the operation method is simple and fast, and is practical. I hope this article "what are the types of automatic variables in C language and how to use them" can help you solve the problem.

Keyword auto

To express your intentions more clearly (for example, to indicate an intention to override an external variable definition, or to emphasize that you should not change the variable to another storage category), you can explicitly use the keyword auto, as follows:

Int main (void) {auto int plox

The keyword auto is the storage category storage-class specifier. The use of the auto keyword in C++ is completely different, and it's best not to use auto as the storage class specifier if you are writing programs that are compatible with Cmax Category +.

Block scope and no link mean that the variable can only be accessed through the variable name in the block where the variable definition is located (of course, the parameter is used to pass the value and address of the variable to another function, but this is indirect). Another function can use a variable with the same name, but it is another variable stored in a different memory location.

The automatic storage period of a variable means that the variable exists when the program enters the block in which the variable is declared and disappears when the program exits the block. The memory location occupied by this variable is now available for other use.

Nesting fast situation

Let's take a look at the situation of nested blocks. The variables declared in a block are limited to the block and the blocks it contains.

Int loop (int n) {int m; / / m in scope scanf ("% d", & m); {int I; / / both m and i in scope for (I = m; I < n; iTunes +) puts ("i is local to a sub-blockn");} return m; / / m in scope, I gone}

In the above code, I is only visible in the inner block. If I is used before or after the inner block, the compiler will report an error. In general, this feature is not used when designing a program. However, if this variable is used only by the block, it is also convenient to define the variable nearby in the block. In this way, the meaning of the variable can be recorded close to the use of the variable. In addition, such variables take up memory only when they are used. The variables n and m are defined in the function header and the outer block, respectively, and their scope is the entire function and exists from the time the function is called to the end of the function.

What if the variable declared in the inner block has the same name as the variable in the outer block? The inner block hides the definition of the outer block. But after leaving the inner block, the scope of the outer block variable returns to its original scope. The program hiding.c demonstrates this process.

/ / hiding.c-- variables in blocks#include int main () {int x = 30; / / original x printf ("x in outer block:% d at% pn", x, & x); {int x = 77; / / new x, hides first x printf ("x in inner block:% d at% pn", x, & x);} printf ("x in outer block:% d at% pn", x, & x) While (x in outer block + < 33) / / original x {int x = 100; / / new x, hides first x x clients; printf ("x in while loop:% d at% pn", x, & x);} printf ("x in outer block:% d at% pn", x, & x); return 0;}

Here is the output of the program:

X in outer block: 30 at 0x7fff5fbff8c8x in inner block: 77 at 0x7fff5fbff8c4x in outer block: 30 at 0x7fff5fbff8c8x in while loop: 101 at 0x7fff5fbff8c0x in outer block: 34 at 0x7fff5fbff8c8

First, the program creates the variable x and initializes it to 30, as shown in the first printf () statement. Then, a new variable x is defined and set to 77, as shown in the second printf () statement. According to the address displayed, the new variable hides the original x. The third printf () statement, located after the first inner block, shows the value of the original x, indicating that the original x has neither disappeared nor changed. Perhaps the most difficult thing about the program is the while loop.

The test conditions of the while loop use the original x:

While (Xerox + < 33)

In this loop, the program creates a third x variable, which is defined only in the while loop. So, when you execute xdistinct + in the body of the loop, the new x is incremented to 101, and then the printf () statement displays that value. When each iteration ends, the new x variable disappears. Then the test condition of the loop uses and increments the original x, enters the loop body again, and creates a new x again. In this example, this x is created and destroyed three times. Note that the loop must increment x in the test condition, because if you increment x in the loop body, it is the x created in the loop body, not the original x used in the test condition.

The compiler we use does not reuse the memory occupied by x in the inner block when creating x in the body of the while loop, but some compilers do.

The purpose of the program example is not to encourage readers to write similar code (it is not difficult to come up with other variable names according to C naming conventions), but to explain how variables are defined in the inner block.

A block without curly braces

A C99 feature was mentioned earlier: as part of a loop or if statement, it is a block even without curly braces ({}). To put it more completely, the whole loop is a sub-block of its block, and the loop body is a subblock of the whole loop block. Similarly, the if statement is a block, and the substatements associated with it are subblocks of the if statement. These rules affect the declared variables and the scope of those variables. The program forc99.c demonstrates the use of this feature in the for loop.

/ / forc99.c-- new C99 block rules#include int main () {int n = 8; printf ("Initially, n =% d at% pn", n, & n); for (int n = 1; n < 3; nasty +) printf ("loop 1: n =% d at% pn", n, & n); printf ("After loop 1, n =% d at% pn", n, & n); for (int n = 1; n < 3) ) {printf ("loop 2 index n =% d at% pn", n, & n); int n = 6; printf ("loop 2: n =% d at% pn", n, & n); printf ("After loop 2, n =% d at% pn", n, & n); return 0;}

Assuming that the compiler supports this new feature of the C language, the output of the program is as follows:

Initially, n = 8 at 0x7fff5fbff8c8loop 1: n = 1 at 0x7fff5fbff8c4loop 1: n = 2 at 0x7fff5fbff8c4After loop 1, n = 8 at 0x7fff5fbff8c8loop 2 index n = 1 at 0x7fff5fbff8c0loop 2: n = 6 at 0x7fff5fbff8bcloop 2 index n = 2 at 0x7fff5fbff8c0loop 2: n = 6 at 0x7fff5fbff8bcAfter loop 2, n = 8 at 0x7fff5fbff8c8

One thing to pay attention to:

Some compilers that support C99 and C11 do not support these scope rules of C99/C11 (Microsoft Visual Studio 2012 is one of them). Some compilations provide the option to activate these rules. For example, at the time of writing, gcc supports many of the features of C99 by default, but uses the-std=c99 option to activate the features used in listing 12.2:

Gcc-std=c99 forc99.c

Similarly, both gcc and clang need to use the-std=c1x or-std=c11 option to support the C11 feature.

The n declared in the first for loop header of the program forc99.c is scoped to the end of the loop and hides the original n. However, after leaving the loop, the original n works again.

The n declared in the second for loop header serves as the index of the loop, hiding the original n. Then, another n is declared in the body of the loop, hiding the index n. At the end of an iteration, the n declared in the loop body disappears, and the loop header is tested with index n. When the whole cycle ends, the original n works again. Once again, remind the reader that there is no need to use the same variable name in the program. If used, the variables are as described above.

Initialization of automatic variables

An automatic variable is not initialized unless it is explicitly initialized. Consider the following statement:

Int main (void) {int repid; int tents = 5

The tents variable is initialized to 5, but the value of the repid variable is any value (if any) that previously occupied the space allocated to repid, and don't expect this value to be 0. You can initialize an automatic variable with a non-constant expression (non-constantexpression), provided that the variable used has been defined earlier:

Int main (void) {int repid; int tents = 5; this is the end of the introduction of "what are the types of automatic variables in C language and how to use them?" Thank you for your reading. If you want to know more about the industry, you can follow the industry information channel. The editor will update different knowledge points for you every day.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.