¡Claro! Podrías poner un puntero void * que guarde datos genéricos, e incluso hacer que la función haga una copia de esos datos para que así hacer que el que programa no tenga que preocuparse por liberar o no la memoria almacenada en la pila!

Concedido, pero un par de agentes de negro harán que tengas un "accidente"
Deseo tener conocimiento ilimitado

Hola, muy buenas. Dado un tema reciente decidí implementar en C una estructura que funcione como cola y otra como pila (estructuras FIFO y LIFO respectivamente). Bueno, parece que son muchas líneas, pero entre comentarios, y saltos de líneas "innecesarios", el código no es tan largo. Aquí se los dejo.

NOTA: Ya sé que ya se ha subido la implementación de estas estructuras, pero eso fue en C++, no en C.

#include <stdlib.h>
#include <stdio.h>
 
// Para generalizar, uso un tipo de datos predefinido, así puedo
// cambiar entre int y el tipo de datos que quiera
typedef int tipo;
 
typedef struct ElementoLista{
	tipo dato;
	struct ElementoLista *siguiente;
} Elemento;
 
// En la estructura de una pila, solo necesitamos la referencia al
// último elemento agregado
typedef struct {
	Elemento *ultimo;
	unsigned int num_elementos;
} Pila;
 
// Pero en la estructura de una cola, también necesitaremos la
// referencia del primer elemento
typedef struct {
	Elemento *primero;
	Elemento *ultimo;
	unsigned int num_elementos;
} Cola;
 
// Si alguna de estas dos funciones retorna 0, significa que
// ha ocurrido un error, de lo contrario, retornará un valor
// diferente de 0
int agregar_a_pila(Pila *pila, tipo dato);
int agregar_a_cola(Cola *cola, tipo dato);
 
// Destruye el último elemento y retorna los datos almacenados en el
tipo quitar_a_pila(Pila *pila);
tipo quitar_a_cola(Cola *cola);
 
// Para demostrar el uso de 'quitar_a_pila' y 'quitar_a_cola'
// estas funciones destruyen la pila y la cola respectivamente
// al mostrarlas
void mostrar_pila(Pila *pila);
void mostrar_cola(Cola *cola);
 
int main() {
	// No hay que olvidarse de inicializar, porque si no, 
	// no hay manera de determinar si un puntero a memoria
	// dinámica es válido o no...
	Pila pila = {NULL, 0};
	Cola cola = {NULL, NULL, 0};
	tipo dato;
 
	// Para probar que todo funciona perfectamente, hacemos que el
	// usuario introduzca enteros para almacenarlos tanto en una cola
	// como en una pila.
	fprintf(stdout, "Introduzca una serie de numeros (0 para acabar): ");
	fscanf(stdin, "%d", &dato);
	while(0 != dato) {
		agregar_a_pila(&pila, dato);
		agregar_a_cola(&cola, dato);
		fscanf(stdin, "%d", &dato);
	}
 
	// Mostramos la pila y la cola (destruyendo a su vez los datos
	// de las mismas)
	mostrar_pila(&pila);
	fputc('\n', stdout);
	mostrar_cola(&cola);
 
	return 0;
}
 
int agregar_a_pila(Pila *pila, tipo dato) {
	Elemento *elemento;
 
	// Creamos elemento y guardamos datos...
	elemento = malloc(sizeof(Elemento));
	if(NULL == elemento)
		return 0;
 
	elemento->dato = dato;
 
	// Reconfiguramos pila...
	if(NULL == pila->ultimo) {
		elemento->siguiente = NULL;
		pila->num_elementos = 1;
		pila->ultimo = elemento;
	} else {
		elemento->siguiente = pila->ultimo;
		pila->num_elementos += 1;
		pila->ultimo = elemento;
	}
 
	return 1;
}
 
int agregar_a_cola(Cola *cola, tipo dato) {
	Elemento *elemento;
 
	// Creamos elemento y guardamos datos...
	elemento = malloc(sizeof(Elemento));
	if(NULL == elemento)
		return 0;
 
	elemento->dato = dato;
	elemento->siguiente = NULL;
 
	// Reconfiguramos cola...
	if(NULL == cola->primero) {
		cola->num_elementos = 1;
		cola->primero = elemento;
		cola->ultimo = elemento;
	} else {
		cola->ultimo->siguiente = elemento;
		cola->num_elementos += 1;
		cola->ultimo = elemento;
	}
 
	return 1;
}
 
tipo quitar_a_pila(Pila *pila) {
	Elemento *temp;
	tipo dato;
 
	if(NULL != pila->ultimo) {
		dato = pila->ultimo->dato;
		temp = pila->ultimo;
		pila->ultimo = pila->ultimo->siguiente;
		pila->num_elementos -= 1;
		free(temp);
	} else {
		dato = -1;
	}
 
	return dato;
}
 
tipo quitar_a_cola(Cola *cola) {
	Elemento *temp;
	tipo dato;
 
	// Hacemos esta asignación, porque si el primer elemento de la cola y
	// el último son iguales, destruiremos el primer elemento, dejando al último
	// sin memoria asignada, por lo que directamente al último elemento le
	// asignamos NULL para que no haya errores
	if(cola->primero == cola->ultimo)
		cola->ultimo = NULL;
 
	if(NULL != cola->primero) {
		dato = cola->primero->dato;
		temp = cola->primero;
		cola->primero = cola->primero->siguiente;
		cola->num_elementos -= 1;
		free(temp);
	} else {
		dato = -1;
	}
 
	return dato;
}
 
void mostrar_pila(Pila *pila) {
	tipo dato;
 
	while(NULL != pila->ultimo) {
		dato = quitar_a_pila(pila);
		fprintf(stdout, "%d ", dato);
	}
}
 
void mostrar_cola(Cola *cola) {
	tipo dato;
 
	while(NULL != cola->primero) {
		dato = quitar_a_cola(cola);
		fprintf(stdout, "%d ", dato);
	}
}

Para liberar la memoria, no basta con asignarle un NULL, primero tienes que liberar la memoria con la función free, donde su único parámetro es el puntero que apunta a un bloque de memoria dinámica (un bloque creado con malloc, calloc o realloc).

Además, si solo hay un elemento, al liberar la memoria, tendrías que hacer que tanto 'inicio' como 'final' también sean nulos.

En el caso de que haya más de un elemento, yo haría esto:

Elemento *temp = inicio;
inicio = inicio->siguiente;
free(temp);

ATENCIÓN, RESPUESTA LARGA

Primero, para que entiendas mejor, voy a explicar algo necesario. Para entender lo que voy a explicar, tendrás que dominar un poco la base binaria y cómo pasar entre decimal y binario.

Procedo a explicar cómo se puede almacenar un entero con signo

Imaginemos que queremos guardar el número -123 como un entero sin signo. Para hacerlo lo que tenemos que hacer es restar a 2^31 - 1 (2 elevado a 31 menos 1) con 123 (he puesto 31 porque un entero suele ocupar 32 bits, y hay que restar 1 porque el último bit se usa para "saber si el número es positivo o negativo"). El resultado de esa operación es 2147483524. Ahora convertimos ese número a binario:

1111111111111111111111110000100

Aquí hay 31 bits. Por último, tenemos que poner el último bit como 1, para indicar que el número es negativo (lo ponemos a la derecha):

11111111111111111111111110000100

CONCLUSIONES IMPORTANTES DE ESTE PROCESO:

• Si el último bit vale 1, entonces seguro que el número es negativo, de lo contrario, el número es positivo

(En realidad, la CPU hace otro proceso más simple, pero que es un poco más difícil de ver a simple vista, por eso lo expliqué así).
_____________________________________________________________________

Una vez sabido esto, procedamos a explicar tu duda:

Vamos a enumerar lo que hace la función scanf:

scanf lee el entero, y lo convierte a binario hasta que se acaben los dígitos introducidos. Una vez obtenido el número, guarda los primeros 32 bits en la variable.

Ahora imagina que has introducido 2147483650 (que es INT_MAX + 1). Vamos a convertir ese número a binario:

10000000000000000000000000000001

Aquí, scanf ya tiene directamente los 32 bits, por lo que los copia sin fijarse en la variable y dice que todo ha ido bien. Entonces, una vez que la variable tiene esos bits, vamos a convertir ese número binario a entero con signo.

• Primero, el bit número 32 es 1, por lo que el número va a ser negativo.
• Segundo, teniendo en cuenta lo que expliqué al principio de esta respuesta, convertimos los 31 primeros bits a decimal. Resultado: 1.
• Tercero, realizamos la operación inversa a lo del principio de la respuesta: 2^31 - 1 - valor = 1. Despejamos la ecuación... valor = 2^31 - 2 = 2147483646

Por lo tanto, si por la consola introducimos INT_MAX + 1, lo que en realidad almacenaremos en la variable entera con signo es -2147483646.
____________
Ahora bien, ¿por qué a veces si que da como resultado un número positivo?

Eso es sencillo, lo que pasa es que el número resultante tenía como último bit un 0, por lo que como ya hemos dicho, eso significa que la variable será positiva.

EJEMPLO RÁPIDO:
Introducimos por consola 4294967336 (mayor a INT_MAX)
Este número en binario es 100000000000000000000000000101000
Copiamos los 32 primeros bits a la variable: 00000000000000000000000000101000
El bit número 32 de la variable vale 0 (puedes contarlo tu mismo).

Como el bit nº 32 vale 0, entonces la variable será positiva, pero valdrá 40 (esto lo sacas de convertir 00000000000000000000000000101000 a binario).

Lo que digo es 100% verdad, y te lo demuestro. Un entero, en informática, se almacena en binario con una cierta cantidad de bits. En C, con ordenadores actuales, se suelen almacenar con 32 bits. Entonces, dado que hay un espacio limitado en la que poder almacenar el entero, es imposible pasar ese límite, porque el tamaño de un entero en C es fijo.

Entonces, ¿por qué no sale del bucle? Imaginemos que introduces el valor INT_MAX + 1. ¿Qué es lo que va a pasar? Que scanf va a transformar lo introducido a binario, por lo que obtendremos lo siguiente:

1000000000000000000000000000000

Aquí hay un 1 y 31 0s. Eso, interpretado para un entero con signo, da como resultado un número negativo, por lo que 'ok' valdrá 0 (ya que no se cumple que sea mayor que 0). Entonces, el while se ejecuta de nuevo, y por lo tanto, te pide otro número, entonces por eso parece que si introduces un número superior a INT_MAX, entonces el bucle se repite hasta que introduzcas otro número. A modo de experimento, mira qué pasa si introduces el 4294967298, un número claramente superior a INT_MAX

A ver, si, técnicamente yo lo veo bien, pero en mi opinión, está mal estructurado. Lo que yo haría es la siguiente estructura:

typedef struct ElementoLista{
    int dato;
    struct ElementoLista *siguiente;
} Elemento;
 
typedef struct {
    Elemento *ultimo;
    unsigned int num_elementos;
} Pila;
 
typedef struct {
    Elemento *primero;
    unsigned int num_elementos;
} Cola;
 
// Si se retorna 0 por alguna de las dos funciones siguientes, ha habido error. De lo contrario, todo ha ido correctamente
int agregar_a_pila(pila *pila);
int agregar_a_cola(cola *cola);
 
int quitar_a_pila(pila *pila);
int quitar_a_cola(cola *cola);
 
void mostrar_pila(const pila *pila);
void mostrar_cola(const cola *cola);

Pequeño detalle a tener en cuenta:

ok = scanf( "%d", &dto ) == 1 && dto >0 && dto <= INT_MAX;

Un entero JAMÁS va a ser mayor que INT_MAX (si eso sucediera, sería un bug del compilador), así que es una tontería poner la condición 'dto <= INT_MAX'

Lo que se emplea para almacenar la información en base binaria es usar un código. Lo que se hace es codificar un audio. Por ejemplo, para codificar los caracteres comúnmente se usa el código ASCII. Aquí tienes una página con una codificación ASCII extendida:

http://www.elcodigoascii.com.ar/

Como ves, a cada carácter se le asigna un número, donde cada número puede convertirse fácilmente a código binario. Por ejemplo, el 0 en binario es 0, el 1 es 1, el 2 es 10, el tres es 11, el cuatro es 100... Si quieres saber cómo convertir un número en base decimal a binario, puedes mirar el siguiente enlace:

http://recursostic.educacion.es/secundaria/edad/4esotecnologia/quincena5/4q2_contenidos_2c.htm#

LWJGL no es un motor gráfico como tal, simplemente te da acceso al aceleramiento por hardware mediante OpenGL y otros hardware (internamente usa GLFW para crear el sistema de ventanas, OpenAL para el audio...)

Concedido, pero tu no arderás junto a el y tendrás que vivir sin comida (estará quemada)
Deseo energía infinita