What the?

Pues sí, los chicos de Canonical han portado BASH de su Linux a Windows 10 y éste ejecuta el entorno de forma nativa, como si fuera el propio Linux.
Este BASH viene con todo lo que se podría esperar de él: awk, sed, grep, vi, etc. y junto al gestor de paquetes apt así que se pueden descargar paquetes como emacs.

¿Qué os parece este acercamiento?

http://www.hanselman.com/blog/DevelopersCanRunBashShellAndUsermodeUbuntuLinuxBinariesOnWindows10.aspx

Ya va dos veces que intento realizar una respuesta en el foro de C/C++ y el sistema de protección me bloquea. ¿Cuáles son las nuevas reglas que espera el foro?

Es cierto que GeSHi es poco descriptivo y, sobre todo para la gente nueva que entra, no se pondrá a jugar con cada una de las opciones de formato antes de postear su duda así que van a dejar el código en texto llano. Yo también lo he hecho.

Por eso en vez de tener el título GeSHi, la lista desplegable debería titularse 'elige tu lenguaje...' o 'Código en lenguaje...'; o algo que a primera vista ya diera a entender que eso sirve para que el código que va dentro se va a formatear en el lenguaje que se elija.

Ya me había acostumbrado a que la ñ y las letras con tilde en los foros aparecen mal escritas cuándo se muestra código, pero mi sorpresa fue cuándo vi que en los mensajes privados sí se ven bien.
Por tanto esto es una sugerencia.
Por lo visto los mensajes privados y los foros están en codificaciones diferentes. Se podrían arreglar los foros para permitir tildes y la ñ.

Sí, pongo tildes en los comentarios 

Muy buenas.

Pues sigo con mi cruzada de autodescubrimiento de gramáticas extrañas que C acepta.

Supongamos la siguiente función que acepta un array de cadenas y las va imprimiendo hasta encontrar una cadena vacía:

void func(char* str[]) {
    int i = 0;
    while(str[i][0] != '\0')
        printf("%s\n", str[i++]);
}

Ante esto uno piensa que para llamar a dicha función debe crear una variable de esta forma

char *lista[] = {"uno", "dos", "tres", "cuatro", "");

y después llamar a la función

func(lista);

Pues se puede llamar a la función pasando un argumento anónimo, la lista entera directamente, de esta forma

func((char*[]){"uno", "dos", "tres", "cuatro", ""});

Obviamente, como siempre, esto se puede modificar al gusto y necesidades de cada uno.

Un programa de prueba completo es este:

#include <stdio.h>
 
void func(char* str[]) {
    int i = 0;
    while(str[i][0] != '\0')
    printf("%s\n", a[i++]);
}
 
int main()
{
    func((char*[]){"uno", "dos", "tres", "cuatro", ""});
    return 0;
}

Ya me diréis que os parece 

Muy buenas.

Pues la idea es hacer algo parecido a los delegados de C# pero con el C de toda la vida.
Sobre una lista dinámica de diferentes funciones con la misma firma se puede hacer las siguientes operaciones:
· Añadir funciones al final de la lista
· Quitar la primera aparición de una función dada
· Vaciar la lista de una tacada
· Ejecutar todas las funciones de la lista de forma secuencial y con unos parámetros comunes dados en la llamada a la ejecución.

En este programa se trabaja sobre una función que acepta un char* y no devuelve nada, pero se puede modificar fácilmente para trabajar con otras funciones.

#include <stdio.h>
#include <stdlib.h>
 
typedef struct tdelegate {
	void (*func)(char*);
	struct tdelegate *next;
} DELEGATE;
 
int delegate_add(DELEGATE **pdelegate, void (*funcpointer)(char*)) {
	DELEGATE *newdelegate = malloc(sizeof(DELEGATE));
	DELEGATE *aux = NULL;
 
	if(newdelegate == NULL)
		return 0;
 
	newdelegate->func = funcpointer;
	newdelegate->next = NULL;
 
	if(*pdelegate == NULL)
		*pdelegate = newdelegate;
	else {
		aux = *pdelegate;
		while(aux->next != NULL)
			aux = aux->next;
		aux->next = newdelegate;
	}
	return 1;
}
 
void delegate_exec(DELEGATE **pdelegate, char *str) {
	DELEGATE *actualdelegate = *pdelegate;
 
	while(actualdelegate != NULL) {
		actualdelegate->func(str);
		actualdelegate = actualdelegate->next;
	}
}
 
void delegate_del(DELEGATE **pdelegate, void (*funcpointer)(char*)) {
	DELEGATE *actualdelegate = *pdelegate;
	DELEGATE *aux = NULL;
	int found = 0;
 
	if(funcpointer == NULL || actualdelegate == NULL)
		return;
 
	if(actualdelegate->func == funcpointer)
	{
		aux = actualdelegate->next;
		free(actualdelegate);
		actualdelegate = aux;
	}
	else {
		while(actualdelegate->next != NULL && !found) {
			if(actualdelegate->next->func == funcpointer) {		
				found = 1;
				aux = actualdelegate->next->next;
				free(actualdelegate->next);
				actualdelegate->next = aux;
			}
			else actualdelegate = actualdelegate->next;
		}
	}
}
 
void delegate_free(DELEGATE **pdelegate) {
	DELEGATE *aux = NULL;
 
	if(*pdelegate == NULL) return;
	while(*pdelegate != NULL) {
		aux = (*pdelegate)->next;
		free(*pdelegate);
		*pdelegate = aux;
	}
}
 
/* FUNCIONES DE PRUEBA */
void a(char *str) {
	printf("%p: %s\n", &a, str);
}
 
void b(char *str) {
	printf("%p: %s\n", &b, str);
}
 
void c(char *str) {
	printf("%p: %s\n", &c, str);
}
 
/* PROGRAMA DE PRUEBA */
int main() {
 
	DELEGATE *midelegado = NULL;
 
	delegate_add(&midelegado, &a);
	delegate_add(&midelegado, &b);
	delegate_add(&midelegado, &c);
 
	delegate_exec(&midelegado, "hola");
 
	delegate_del(&midelegado, &b);
	delegate_exec(&midelegado, "adios");
 
	delegate_free(&midelegado);
	midelegado = NULL;
 
	return 0;
}
 
 

No es mucha cosa, solo un divertimento; pero sirve para ver en qué parte de la memoria pone el S.O. las funciones, las variables locales, las globales y las dinámicas.
Así se puede ver como el sistema separa la memoria de código, la memoria de pila (stack) y la memoria del montón (heap).

#include <stdio.h>
#include <stdlib.h>
 
char gc;
int gi;
 
int main(int argc, char *argv[])
{
	char c;
	int i;
	int *p = malloc(sizeof(int));	
	printf("printf\t= %p\n", &printf);
	printf("malloc\t= %p\n", &malloc);
	printf("main\t= %p\n", &main);
	printf("\n");
	printf("gi\t= %p\n", &gi);
	printf("gc\t= %p\n", &gc);
	printf("\n");
	printf("argv\t= %p\n", &argv);
	printf("argc\t= %p\n", &argc);
	printf("\n");
	printf("c\t= %p\n", &c);
	printf("i\t= %p\n", &i);
	printf("p\t= %p\n", &p);
	printf("\n");
	for(i = 0; i < argc; ++i)
		printf("argv[%i]\t= %p -- %s$\n", i, argv[i], argv[i]);
	printf("\n");
	printf("p (->)\t= %p\n", p);
	free(p);
	return 0;
}

P. ej.:

$ ./c 1 12 123 1234 12345
printf   = 0x4004f0
malloc   = 0x400520
main   = 0x40061d

gi   = 0x60105c
gc   = 0x601060

argv   = 0x7ffd71212400
argc   = 0x7ffd7121240c

c   = 0x7ffd71212413
i   = 0x7ffd71212414
p   = 0x7ffd71212418

argv[0]   = 0x7ffd71214551 -- ./c$
argv[1]   = 0x7ffd71214555 -- 1$
argv[2]   = 0x7ffd71214557 -- 12$
argv[3]   = 0x7ffd7121455a -- 123$
argv[4]   = 0x7ffd7121455e -- 1234$
argv[5]   = 0x7ffd71214563 -- 12345$

p (->)   = 0x1e36010

Cuándo se usa la función malloc, por ejemplo, y una llamada básica podría ser algo así:

int *p = malloc(sizeof(int) * 5);

Y ahora viene la parte curiosa y mi planteamiento:

int arr[5] es un array de enteros.
int (*p)[5] es un puntero a un array de 5 enteros.
Lo único que tienen en común los dos son el tipo de dato, int, y el tamaño del array, 5. El nombre que le demos no tiene imporancia. Si se obvia dicho nombre nos debería dar un tamaño pero sin declarar nada.

Por tanto el código antes escrito podría codificarse de una forma un poco más intuitiva:

int *p = malloc( sizeof(int[5]) );

Y funciona, al menos con GCC.

>>> Editado porqué estas líneas no tienen un sentido práctico <<<

También funciona:

int *p = malloc( sizeof(int[5][5]) );

y

int **p = malloc( sizeof(int[5][5]) );

>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<

¿Qué os parece?