Reglas de alcance en C

Alcance = Vida útil

El área bajo la cual se aplica una variable.

Definición estricta: un bloque o una región donde se declara, define y usa una variable y cuando finaliza un bloque o una región, la variable se destruye automáticamente.

#include <stdio.h>
 
int main()
{
      int var = 34;     // Scope of this variable is within main() function only.
                      // Therefore, called LOCAL to main() function.
   
      printf("%d", var);
   
    return 0;
}

34

El alcance de un identificador es la parte del programa donde se puede acceder directamente al identificador. En C, todos los identificadores tienen un alcance léxico (o estático) . Las reglas de alcance C se pueden cubrir en las siguientes dos categorías.

Hay básicamente 4 reglas de alcance:

Analicemos cada regla de alcance con ejemplos. 

Alcance del archivo: estas variables generalmente se declaran fuera de todas las funciones y bloques, en la parte superior del programa y se puede acceder a ellas desde cualquier parte del programa. Estas también se denominan variables de alcance global, ya que se puede acceder a ellas globalmente. 

Ejemplo 1:

// C program to illustrate the global scope
 
#include <stdio.h>
  
// Global variable
int global = 5;
  
// global variable accessed from
// within a function
void display()
{
    printf("%d\n", global);
}
  
// main function
int main()
{
    printf("Before change within main: ");
    display();
  
    // changing value of global
    // variable from main function
    printf("After change within main: ");
    global = 10;
    display();
}

Before change within main: 5
After change within main: 10

Producción: 

Before change within main: 5
After change within main: 10

Ejemplo 2:

// filename: file1.c
 
int a;
 
int main(void)
{
   a = 2;
}

// filename: file2.c
// When this file is linked with file1.c, functions
// of this file can access a
 
extern int a;
 
int myfun()
{
   a = 2;
}

Nota: Para restringir el acceso solo al archivo actual, las variables globales se pueden marcar como estáticas.

Ámbito de bloque: Un bloque es un conjunto de declaraciones encerradas entre llaves izquierda y derecha, es decir, ‘{‘ y ‘}’ respectivamente. Los bloques se pueden anidar en C (un bloque puede contener otros bloques en su interior). Una variable declarada dentro de un bloque es accesible en el bloque y en todos los bloques internos de ese bloque, pero no accesible fuera del bloque. Básicamente, estos son locales a los bloques en los que se definen las variables y no son accesibles desde el exterior.

#include <stdio.h>
 
// Driver Code
int main()
{
    {
        int x = 10, y = 20;
        {
            // The outer block contains
            // declaration of x and
            // y, so following statement
            // is valid and prints
            // 10 and 20
            printf("x = %d, y = %d\n", x, y);
            {
                // y is declared again,
                // so outer block y is
                // not accessible in this block
                int y = 40;
 
                // Changes the outer block
                // variable x to 11
                x++;
 
                // Changes this block's
                // variable y to 41
                y++;
 
                printf("x = %d, y = %d\n", x, y);
            }
 
            // This statement accesses
            // only outer block's
            // variables
            printf("x = %d, y = %d\n", x, y);
        }
    }
    return 0;
}

x = 10, y = 20
x = 11, y = 41
x = 11, y = 20

Producción: 

x = 10, y = 20
x = 11, y = 41
x = 11, y = 20

Alcance del prototipo de función: el rango de estas variables se incluye dentro de la lista de parámetros de función. El alcance de estas variables comienza justo después de la declaración en el prototipo de función y se extiende hasta el final de la lista de declaraciones. Estos ámbitos no incluyen la definición de la función, sino solo el prototipo de la función. 

Ejemplo: 

// C program to illustrate
// function prototype scope
 
#include <stdio.h>
  
// function prototype scope
//(not part of a function definition)
int Sub(int num1, int num2);
 
// file scope
int num1;
 
// Function to subtract
int Sub(int num1, int num2)
{
    return (num1-num2);
}
 
// Driver method
int main(void)
{
    printf("%d\n", Sub(10,5));
    return 0;
}

5

Alcance de la función: el alcance de una función comienza en la apertura de la función y termina con el cierre de la misma. El alcance de la función solo se aplica a las etiquetas. Una etiqueta declarada se usa como destino para ir a la instrucción y tanto la instrucción goto como la etiqueta deben estar en la misma función. 

Ejemplo: 

void func1()
{
    {
        // label in scope even
        // though declared later
        goto label_exec;
 
    label_exec:;
    }
 
    // label ignores block scope
    goto label_exec;
}
 
void funct2()
{
 
    // throwserror:
    // as label is in func1() not funct2()
    goto label_exec;
}

 
Ahora pueden surgir varias preguntas con respecto al alcance del acceso de las variables: 

¿Qué sucede si el propio bloque interno tiene una variable con el mismo nombre?  
Si un bloque interno declara una variable con el mismo nombre que la variable declarada por el bloque externo, entonces la visibilidad de la variable del bloque externo termina en el punto de declaración del bloque interno.

¿Qué pasa con las funciones y los parámetros pasados ​​a las funciones?  
Una función en sí misma es un bloque. Los parámetros y otras variables locales de una función siguen las mismas reglas de alcance de bloque.

¿Se puede acceder a las variables del bloque en otro bloque posterior?  
No, solo se puede acceder a una variable declarada en un bloque dentro del bloque y todos los bloques internos de este bloque. 

Por ejemplo , el siguiente programa produce un error de compilación. 

int main()
{
  {
      int x = 10;
  }
  {
      // Error: x is not accessible here
      printf("%d", x); 
  }
  return 0;
}

Error:

prog.c: In function 'main':
prog.c:8:15: error: 'x' undeclared (first use in this function)
  printf("%d", x); // Error: x is not accessible here
               ^
prog.c:8:15: note: each undeclared identifier is 
reported only once for each function it appears in

Ejemplo: 

// C program to illustrate scope of variables
 
#include<stdio.h>
 
int main()
{
    // Initialization of local variables
    int x = 1, y = 2, z = 3;
 
    printf("x = %d, y = %d, z = %d\n",
    x, y, z);
    {
 
        // changing the variables x & y
        int x = 10;
        float y = 20;
         
        printf("x = %d, y = %f, z = %d\n",
        x, y, z);
        {
 
            // changing z
            int z = 100;
            printf("x = %d, y = %f, z = %d\n",
            x, y, z);
        }
    }
    return 0;
}

x = 1, y = 2, z = 3
x = 10, y = 20.000000, z = 3
x = 10, y = 20.000000, z = 100

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.