69 - Variables globales con el modificador extern

Ver video

Cuando tenemos una aplicación constituida por varios archivos *.c y queremos acceder a una variable global de un archivo en otro archivo debemos declarar la variable global con el modificador extern.

Cuando una variable global se declara como extern, el compilador no crea un espacio para ella en memoria, sino que, tan solo tiene en cuenta que dicha variable ya ha sido declarada en otro archivo del programa.

Problema 1:

Confeccionar una programa que administre una lista tipo pila (se debe poder insertar, extraer e imprimir los datos de la pila).

La estructura del nodo es la siguiente:

struct nodo {
    int info;
    struct nodo *sig;
};

Luego se crea un alias para tipo de dato puntero a nodo:

typedef struct nodo * tnodo;

Crear un proyecto llamado: proyecto003 e implementar todas las funciones para administrar la pila en un archivo separado. En el archivo principal definir una variable global que apunte al primer nodo de la lista. Acceder a dicho puntero desde los dos archivos.

Archivo: pila.h

struct nodo {
    int info;
    struct nodo *sig;
};

typedef struct nodo * tnodo;

void insertar(int x);
void imprimir();
int extraer();
void liberar();

Archivo: main.c

#include<stdio.h>
#include<conio.h>
#include"pila.h"

tnodo raiz=NULL;

int main()
{
    insertar(10);
    insertar(40);
    insertar(3);
    imprimir();
    printf("Extraemos de la pila:%i\n",extraer());
    imprimir();
    liberar();
    getch();
    return 0;
}

En este archivo definimos una variable global llamada raiz de tipo tnodo y se la inicializa con el valor NULL:

tnodo raiz=NULL;

Archivo: pila.c

#include<stdio.h>
#include<stdlib.h>
#include"pila.h"

extern tnodo raiz;

void insertar(int x)
{
    tnodo nuevo;
    nuevo = malloc(sizeof(struct nodo));
    nuevo->info = x;
    if (raiz == NULL)
    {
        raiz = nuevo;
        nuevo->sig = NULL;
    }
    else
    {
        nuevo->sig = raiz;
        raiz = nuevo;
    }
}

void imprimir()
{
    tnodo reco=raiz;
    printf("Lista completa.\n");
    while (reco!=NULL)
    {
        printf("%i ",reco->info);
        reco=reco->sig;
    }
    printf("\n");
}

int extraer()
{
    if (raiz != NULL)
    {
        int informacion = raiz->info;
        struct nodo *bor = raiz;
        raiz = raiz->sig;
        free(bor);
        return informacion;
    }
    else
    {
        return -1;
    }
}

void liberar()
{
    tnodo reco = raiz;
    tnodo bor;
    while (reco != NULL)
    {
        bor = reco;
        reco = reco->sig;
        free(bor);
    }
}

Los algoritmos ya han sido vistos anteriormente, lo nuevo es como accedemos al puntero raiz definido en el otro archivo (main.c)

Mediante la palabra clave extern indicamos al compilador que hay otro archivo que define la variable raiz y queremos acceder a la misma en este archivo:

extern tnodo raiz;

Si consultamos el código fuente del sistema operativo Linux en muchos de sus archivos encontraremos especificación a variables de tipo extern:

Retornar

---