Blame

El efecto Linus Torvals

El pasado 26 de julio, hace casi un mes, Linus Torvals anunció en Google+ que se pasaría definitivamente a XFCE por su poca afinidad con la versión 3 de Gnome. Pues bien, el efecto se ha hecho notar:

Incluso en Google se ha notado la creciente búsqueda de “XFCE” tras las declaraciones. La marca A cuando se lanzó la última versión, la 4.8. La marca B cuando Linus habló.

Afortunada o desgraciadamente, la influencia de estas declaraciones pueden marcar la desvinculación de este escritorio para muchos usuarios. En mi caso, tengo dos opciones, me quedo con las actualizaciones sobre la versión dos o vuelvo al que fue mi primer escritorio, XFCE.

Lo mejor de mi RSS del 15 al 21 de agosto

Reservar memoria dinámica para una matriz en C

Acabamos de hablar hace nada de cómo reservar memoria para un vector unidimensional de forma dinámica con C. Hoy le toca el turno a las matrices o arrays bidimensionales. Los vectores se organizan de forma lineal, secuencial y con todos los elementos en posiciones correlativas en la memoria. Las matrices se almacenan en forma de vector de vectores.

Dimensiones fijas

Si es de dimensiones fijas (declarándolas como matriz[filas][columnas]), el vector de vectores se guardará también uno al lado del otro.

Por lo tanto, en una matriz del tipo:

a00a01a02
a10a11a12
a20a21a22

En memoria (en la que los elementos los direccionamos en una sola dirección) los tendríamos de la siguiente forma (en cada lenguaje este criterio cambia, en Fotran se almacena en forma de vector de columnas):

a00a01a02a10a11a12a20a21a22

Dimensiones variables

Sin embargo, en el caso de la memoria dinámica, las cosas cambian. El mecanismo será el siguiente:

  • Declararemos un doble puntero “matriz” sobre el que reservaremos memoria para tantas filas tengamos.
  • Recorreremos el vector recién creado para reservar memoria para las columnas de cada fila.

Hay dos detalles a tener en cuenta:

  • La variable “matriz” será del tipo doble puntero ya que hará referencia a un vector de punteros.
  • Cada fila sí estará almacenada de forma consecutiva en memoria, pero éstas a su vez no estarán de forma obligada juntas, aunque podremos seguir accediendo de la misma forma.

Veamos un ejemplo con código real (no hace comprobaciones de que el malloc se ejecute correctamente):

#include <stdlib.h>
#include <stdio.h>
int main(void)
{
	int filas = 2;
	int columnas = 3;
	int **x;
	int i;	 // Recorre filas
	int j;	 // Recorre columnas
	// Reserva de Memoria
	x = (int **)malloc(filas*sizeof(int*));
	for (i=0;i<filas;i++)
		x[i] = (int*)malloc(columnas*sizeof(int));
	// Damos Valores a la Matriz
	x[0][0] = 1;
	x[0][1] = 2;
	x[0][2] = 3;
	x[1][0] = 4;
	x[1][1] = 5;
	x[1][2] = 6;
	// Dibujamos la Matriz en pantalla
	for (i=0; i<filas; i++)
	{
		printf("\n");
		for (j=0; j<columnas; j++)
			printf("\t%d", x[i][j] );
	}
	return 0;
}

Ropa

Hay que ver, el otro día haciendo la colada me di cuenta de que la mayor parte de mi ropa tiene algo que ver con el software libre.

[Tips] Google compra Motorola

La noticia (Mashable) me sorprende de dos formas, la primera es que desconozco qué mercado espera cubrir Google con esta compra, no lo tengo demasiado claro.

La segunda la barbaridad que han pagado por esta adquisión, sólo 12.5 billones de dólares, lo que serían en lengua española 12500 millones de dólares. Recordad que un billón anglosajón no equivale a un billón español, ya que aquí (España) se considera que un billón es un millón de millones y en este caso hablamos de miles de millones.

Actualizado: Cuando digo barbaridad recalco mi intención de transmitir que esa cantidad me parece muy pequeña para una compañía de ese volumen.

Reservar memoria dinámica para un vector en C

Puesto que estamos hablando bastante de C en el curso de programación de videojuegos con SDL, voy a publicar una serie de pequeños apuntes sobre programación en C que seguro que os son de utilidad. No van a constituir un curso como tal pero serán una serie de entradas relacionadas sobre este tema.

Memoria dinámica

Cuando trabajamos con variables, el compilador genera código máquina que se encarga de reservar memoria al comienzo de la ejecución y de liberarla al finalizar la misma. Cuando necesitamos trabajar con una serie de datos que no sabemos cuánto van a ocupar, por ejemplo con una estructura que variará con el número de jugadores de nuestro videojuego, no podemos reservar un vector (array o arreglo) para un número indeterminado.

Deberemos declarar un puntero y sobre dicho puntero, pedirle al sistema memoria suficiente conforme a nuestras necesidades. El sistema nos devolverá una dirección de memoria (que se almacenará en el puntero) y junto a la cuál (de forma correlativa) se encontrarán las demás posiciones del vector con el que vamos a trabajar.

malloc

La función que se encarga de efectuar ese trabajo es malloc (del inglés, reserva de memoria, memory allocation). Tras reservar memoria, deberemos hacer uso de free para liberarla cuando no la necesitemos más. Veamos qué parámetros maneja:

Entrada

  • tamaño: del tipo size_t, es decir, número de bytes que queremos reservar. Será número de elementos del vector multiplicado por el tamaño del tipo de dato (lo obtenemos con sizeof).

Salida

  • Dirección de memoria inicial del vector que se almacenará en un puntero. Es del tipo void* por lo que deberemos hacerle una conversión explícita o casting al tipo que queramos. Será NULL si ha habido problemas ejecutando malloc.

Ejemplo

#include <stdio.h>
#include <stdlib.h>
int main ()
{
int numeroElementos;
int* vector;
printf ("¿Cuántos elementos quieres? ");
scanf ("%d", &numeroElementos);
vector = (int*)malloc(numeroElementos*sizeof(int));
if (vector==NULL)
{
perror("Problemas reservando memoria");
exit (1);
}
// trabajamos con el vector
// lo liberamos
free (vector);
return 0;
}

Lo mejor de mi RSS del 8 a 14 de agosto