Antes que nada quiero aclarar que este truco es una mala practica, en la mayoría de los lugares donde lo he visto (mientras me documentaba para escribir este post) aconsejan no hacerlo. La razón, aunque el truco funciona (y como veremos adelante tiene un fundamento solido) es confuso. Es decir según los IS la ganancia en performance es muy poca comparada con la complicación en entender el código escrito. Además de que en computadoras modernas este truco puede ser mas lento que la solución estándar (estúpidos optimizadores de memoria).

Así que solo ocuparlo en código que quieran usar con fin de hacer faramalla, show e impresionar chicas. O en caso de que algún entrevistador para alguna chamba se pase de listo y les pregunte como hacerlo.

Entendiendo el problema

En muchos algoritmos (por ejemplo en ordenación) es necesario intercambiar los valores de dos variables. Para simplificar el resto de la explicación asumiré sin perdida de generalidad (como me gusta usar esa frase ) que se tienen valores numéricos y enteros.

Es decir al principio tenemos algo como.

A = 2
B = 4

Queremos llevar a cabo la operación de intercambio y obtener una situación como:

A = 4
B = 2

Como lo haría una persona normal

Pues como nos enseñaron en la escuela XD. En todos los lenguajes de programación al asignación es una operación destructiva. Es decir al momento de asignar un valor a una variable se pierde el contenido anterior. (¡Estúpidas limitantes físicas del computo!).

Por lo que la gente que no sabe el truco haría algo así:

TEMP = A
A = B
B = TEMP

De esta manera tenemos un espacio de memoria extra donde guardar el valor de A, por lo tanto podemos destruir el contenido de A sin tentarnos nuestro corazoncillo. Y recuperarlo después del buffer temporal.

Ahora lo interesante: ¿Cómo se hace sin usar ninguna variable TEMP?

La solución del matemático.

Ahora si ustedes son de esas personas que saben un montón de matemáticas, pero jamas han programado de a de veras (¡Como los hombres!) podrían sugerir esta solución. (No se hagan se que por ahí hay muchísimos).

A = A + B
B = A – B
A = A – B

Ahora sabemos que ésta es un caso particular de una solución mas general.

1. Combina los dos valores en la variable A por medio de una operación binaria bien portada (Es decir que sea invertible). En este momento en A están guardados de alguna manera los dos valores.
2. Usa la operación inversa de la operación binaria para extraer en la variable B el valor original de A a partir del valor actual de A. Recuerda que no hemos modificado B.
3. Usa la operación inversa para extraer ahora el viejo valor de B en A. Recordando que tenemos guardado en B el valor original de A.

El fallo de la solución anterior es que trabajamos con maquinas de memoria finita, es decir podría pasar que la operación bien portada que es la suma produzca un número tan grande que no quepa en la localidad de memoria que le guardamos. ¿No se acuerdan del molesto carry cuando nos enseñaron la suma en binario y  hacer circuitos sumadores? Pues es aquí donde nos vino a fastidiar la vida.

La solución del computólogo

Tan simple, tan elegante, tan parecida a la solución del matemático XD (Por ahí dicen que es la misma por que los computologos y los matemáticos son casi lo mismo ). Pues resulta que hay mas de una operación bien portada y una que tiene todo lo que necesitamos es el XOR.

x	y	xy
0	0	0
0	1	1
1	0	1
1	1	0

¡Muérete de envidia suma! ¡El XOR es una suma sin carry vean la tabla!. ¿Suficiente? El XOR (conocido también en los bajos mundos de la lógica como disyunción exclusiva) es una de las operaciones que pueden construir toda la lógica de primer orden, además es conmutativo, asociativo y es su propio inverso. Pueden ver aquí la lista de todo lo bello que es el XOR. Es mas: ¡XOR soy tu fan!

Es decir podemos usar el XOR que como no tiene carry y nunca se desborda para hacer

A = A B
B = B A
A = A B

¿Mencione que es conmutativo y que es su propio inverso? Además que en todo lenguaje decente como en C y C++ y en algunos no decentes (Java ) Tenemos un operador de XOR y tenemos una forma abreviada de hacer la asignación. ¿No me creen? Miren con sus propios ojos:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <iostream>
using namespace std;
 
int main (int argc, char* argv[]) {
 
	int a = 4, b = 2;
 
	cout << "Los valores son: a = " << a << " b = " << b << endl;
 
	swap(a, b);
 
	cout << "Después del swap:" << endl;
	cout << "Los valores son: a = " << a << " b = " << b << endl;
 
	return 0;
}
 
void swap (int &a, int &b) {
	a ^= b;
	b ^= a;
	a ^= b;
}

Y para que no digan que no pelo a la banda Javera, tomen no se vallan a enojar.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class TestSwaping {
 
	public static void main(String[] args) {
		int a = 4, b = 2;
 
		System.out.println("Los valores son: a = " + a + " b = " + b);
 
		a ^= b;
		b ^= a;
		a ^= b;
 
		System.out.println("Después del swap");
		System.out.println("Los valores son: a = " + a + " b = " + b);
	}
 
}

Mas información sobre la correctez y demás cosas de este truco esta en su pagina wikipedia.


Instalar Geany, no debe de dar mayor problema, pues se encuentra en los repositorios oficiales de Ubuntu, lo podemos hacer via apt-get, o synaptic, o incluso se encuentra disponible en agregar o quitar programas bajo la categoría de desarrollo, si su sistema esta en español (el Ubuntu), geany también vendrá en español.

Bueno, por que querría yo usar un editor de texto aparte de gedit? Pues por que geany me da ciertas ventajas que no me da por ejemplo gedit, al escribir código, estoy hablando a que nos da mas ventajas que el simple sintax highlight

Pues aquí viene lo bonito del asunto, si queremos usar Geany para escribir código de OpenGL y glut en Ubuntu, y ya sabemos hacer nuestros propios makefiles, como lo explique en el post anterior.

Ahora podemos usar todo esto a nuestro favor para tener un entorno de desarrollo muy amigable, para empezar guardemos todos nuestros archivos fuentes y makefile en una sola carpeta luego iniciamos geany.

Ahora suponemos que en nuestro makefile, define cierto nombre para el ejecutable por ejemplo “Modelo3D”, y que definimos un make all, de defualt, y que también pusimos un “make destroy”, que elimina los objetos y el ejecutable.

Pues abrimos Geany, de ahí abrimos todos nuestros archivos fuentes, Archivo -> abrir y luego nos vamos al menú que dice: construir

En la ultima opción se encuentra Selecciona Inclusiones y Argumentos, al entrar a esta opción vemos una ventana como esta:

Ahora vemos que Geany ya ha dado valores de default, pues sabe que estamos escribiendo código en C, por que abrimos un archivo .c, sin embargo como nosotros ya hicimos nuestro propio makefile, la vamos a cambiar esas opciones, para que llame a nuestro make.

Lo que tenga escrito en la primer caja de de compilar es lo que se va a ejecutar, cuando apretemos el botón de compilar, ahora nosotros queremos que antes de compilar elimine todos los objetos y el ejecutable, y luego intente compilar todo, es decir queremos que ejecute “make destroy” y luego “make all”, y como esta instrucción se va a mandar al shell tal como la escribimos podemos escribir:
make destroy; make
Ahora lo que escribamos en argumentso para el programa, es lo que ejecuta cuando presionamos el boton de ejecutar, así que podemos poner ahi ./nombre_de_ejecutable o para nuestro ejemplo:
./modelo3D

Y listo, ahora podemos programar cómodamente en Geany, usando glut y OpenGL, cada que queramos compilar, solo presionamos el botón de compilar y al ejecutar el botón de ejecutar.

Algunas observaciones

• Geany es muy ligero y tiene la enorme ventaja que no hace archivos de proyecto, o de configuración, esto es una ventaja para programas pequeños.
• La ventaja de tener total control de los argumentos con nuestro propio makefile.
• También se puede importar código muy fácil, ya que geany, nos da lo mínimo, para poder escribir entre Windows y GNU/Linux, es decir nos deja cambiar el carácter de terminación de linea de los archivos fuentes y la codificación de caracteres, la codificación de GNU/Linux y en particular de Ubuntu es UTF8, la codificación en Windows es depende del idioma en que lo tengamos, pero seguro aparece en el menú de geany. La terminación de linea en Windows es CRLF y en GNU/Linux es LF.
• Tenemos las opciones que mas comúnmente se usan al programar en un Editor muy ligero y que no para instalar no necesitamos traer montones de librerías como en los casos de editores mas poderosos.

El makefile es un archivo de texto plano, que usa la herramienta make, dicho archivo debe ser escrito por el desarrollador y dice como se compila el programa que escribió. Usualmente los makefiles son complejos y contienen un montón de reglas, sin embargo nosotros nos vamos a limitar a tres: una para compilar, una para limpiar y otra para reconstruir.

Así que abrimos nuestro editor de texto plano favoritos y construimos un archivo que tenga por nombre makefile (el nombre es muy importante).

Si nuestro programa solo va tener un archivo fuente esta sera nuestra plantilla:

1
2
3
4
5
6
7
8
9
10

LIBDIR = -L/usr/X11R6/lib
CC = gcc
CFLAGS = -Wall
LIBRARIES = -lglut -lGL -lGLU -lm
ejecutable: fuente.c
	$(CC) $(CFLAGS) -o $@ $(LIBDIR) $? $(LIBRARIES)
destroy:
	rm -f *.o ejecutable
clean:
	rm -f *.o

En donde ejecutable es el nombre que queremos que tenga nuestro archivo ejecutable y fuente es el nombre de nuestro único archivo fuente.

Analizando un poco vemos que el makefile define unas variables en las primeras lineas, y luego define unas reglas, las reglas siempre son de la forma:

[objetivo]: [dependencia]
[comandos]

Donde objetivo es el nombre de la operación que queremos hacer, dependencia es todo lo que necesitamos para llevarla a acabo y comandos es lo que debemos hacer para llevar a cabo la operación.

Las reglas que defino son ejecutable que sirve para hacer el ejecutable, clean que sirve para borrar todos los los archivos intermedios que hace el compilador (por ejemplo los .o) y destroy que borra todo lo que hace el compilador y nos deja listos para intentar compilar de nuevo (por ejemplo en nuestro periodo de ensayo error).

Se observa que uso gcc como compilador, por que el lenguaje C es usualmente nuestro default, si piensan programar en c++, cambien gcc por g++. Tambien fijense que entra las librerías mando a GL a GLU y a glut, que es por que queremos hacer un programa de OpenGL con glut, pero además mando un misterioso -lm, estas son as demás librerías de default de C, por ejemplo si en nuestro programa queremos usar funciones definidas en math.h.

Si queremos hacer un programa con mas de un código fuente esta es otra plantilla:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

LIBDIR = -L/usr/X11R6/lib
CC = gcc
CFLAGS = $(COMPILERFLAGS)
LIBRARIES = -lglut -lGL -lGLU -lm
OBJ = fuente1.o fuente2.o fuente3.o fuente4.o
BIN = ejecutable
 
all: $(BIN)
$(BIN) : $(OBJ)
	$(CC) $(CFLAGS) -o $@ $(LIBDIR) $? $(LIBRARIES)
 
fuente1.o: fuente1.c
	$(CC) -c fuente1.c -o fuente1.o $(CFLAGS)
 
fuente2.o: fuente2.c
	$(CC) -c fuente2.c -o fuente2.o $(CFLAGS)
 
fuente3.o: fuente3.c
	$(CC) -c fuente3.c -o fuente3.o $(CFLAGS)
 
fuente4.o: fuente4.c
	$(CC) -c fuente4.c -o fuente4.o $(CFLAGS)
 
destroy:
	rm -f $(OBJ) $(BIN)
clean:
	rm -f $(OBJ)

En donde fuente1, … fuentei, son todos los archivos fuentes que componen el programa y ejecutable es el nombre del ejecutable.

Ahora lo importante:

Es ampliamente recomendado tener una carpeta donde guardar todo lo referente a nuestro programa y solo eso, es decir mi fuente y mi makefile deben estar en una carpeta para ellos solos (esto para facilitar su transporte) y que no se vayan a volar algo sin querer al escribir una regla mal del make XD
Para compilar nuestro programa simplemente escribimos en la linea de comandos “make”: (obviamente debemos estar parados en el directorio donde esta todo):

$make

Si nuestro programa compilo correctamente genero el archio ejecutable, pero si tuvimos errores, veremos los errores y warnings en la shell y debemos de hacer los siguiente:
ejecutar make destroy, para limpiar toda al basura generada por la compilación fallida, corregir nuestro fuente y luego volver a intentar compilar.

$make destroy 

Algunas observaciones:

• Estos makefiles son solo recomendaciones y de hecho no siguen las reglas GNU de los makefiles, para aprender mas de eso pueden visitar: http://www.gnu.org/software/make/
• Para escribir este post me base en la guia publicada por el area de linux de la fesa, quizas si le dan un ojo les quede mas claro http://www.acatlan.unam.mx/linux/graficacion/compilalinux.html
• Si nuestro fuente tiene cabeceras por ejemplo cabecera.h, estas no necesitan ser compiladas y por lo tanto no se ponen en el make, basta que en el fuente sean usadas #include, Siempre que la cabecera no tenga código en C, si no mas bien declaraciones de estructuras y variables globales (que es como debe ser).