Mensajes

A ver, ¿qué tal así?

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <math.h>

unsigned p_fraccionaria(double d) {
    unsigned retvalue;
   
    d = fabs(d);
    d -= (unsigned long)d;
    d *= 1000000; // <-- 6 decimales ya es bastante precision
   
    retvalue = d;
   
    if(retvalue < d)        // <-- por si en la conversion ha habido
        ++retvalue;         // <-- perdida de precision
    else if(retvalue > d)   //
        --retvalue;         //
       
    if(retvalue)                // <-- Si no es 0, intentamos
        while(!(retvalue % 10)) // <-- quitar 0 por la derecha
            retvalue /= 10;     //
   
    return retvalue;
}

int main() {
    double num;
   
    num = 12.34;
    printf("%f : %u\n", num, p_fraccionaria(num));
   
    num = 12.34567890123;
    printf("%f : %u\n", num, p_fraccionaria(num));
   
    num = 12.00;
    printf("%f : %u\n", num, p_fraccionaria(num));
   
    num = 12;
    printf("%f : %u\n", num, p_fraccionaria(num));
   
    num = -12.34;
    printf("%f : %u\n", num, p_fraccionaria(num));
   
    return 0;
}

Hay más cosas.

No todo es el sistema operativo y el tipo de máquina en sí.
También están las llamadas máquinas virtuales, como son la de Java, el JIT de .NET, etc. También están los entornos de ejecución como los navegadores con sus plugins (el navegador está compilado para cada plataforma a la que da soporte, pero los plugins son genéricos, eso es todos los navegadores de esa marca aceptarán ese plugin ); o un caso muy famoso el Flash y sus animaciones/banners/contenido activo.

Si hay un bug en estas máquinas virtuales (entiéndase todo lo anterior mencionado) que hace cosas que no debería hacer en el sistema anfitrión, ese bug, por lo general, estará en todas las plataformas a las que se puede instalar esa máquina virtual y un malware escrito para esa máquina virtual que explote ese bug puede comprometer y compromete la seguidad y el buen funcionamiento del sistema anfitrión.



Por cierto, sí se puede compilar desde una plataforma para otra. La técnica se llama cross-compiling. Para ello se utilizan los cross compilers que son capaces de compilar para otras arquitecturas. Hay muchos tipos: Linux a Windows y viceversa, Linux a Arduino, Windows a Arduino, L/W a uPIC, a Android, a iOS, etc. etc. etc.

Tal vez era esto lo que querías. Busca información de cross-compiling de Linux para Windows.

A ver, voy a explicar como hacer una buena interfaz de función.
Una vez pensado un buen nombre, descriptivo de lo que hace, muy importante pensar que datos necesitamos pasarle para que haga su trabajo.
Hay que pasarle solo esos datos. La lista de argumentos no debe servir para crear variables locales, como haces con aux. Esas ya se declararán dentro de la función.
También debemos pensar en si la función nos debe devolver un resultado y qué resultado necesitamos que nos devuelva.
Teniendo claro eso podremos empezar a pensar como debe hacer su trabajo.

Hazlo a mano, sobre un papel y apunta los pasos que vas haciendo.
Después solo tienes que traducirlo a C.
Ten en cuenta varias cosas:
Que ocurre si el numero original es entero
Que ocurre si el tiene infinitos decimales.

Por otra parte, si no es un ejercicio y necesitas esa funcionalidad para un programa mas grande, piensa que ya existe esta función en la librería estándar de C.

A ver, desconozco el algoritmo de esto, pero veo una cosa que no me cuadra:
En la última iteración, cuándo i valga _tamano - 1, en la linea 10, cuando accedes a _datis [i +  1] ¿no estás fuera del array?

Fallas en las llamadas y retornos de las funciones.
Antes de continuar con este programa vuelve a revisar el tema de las funciones:
Cómo llamarlas
Cómo pasarles patámetros y usarlos en la función
Cómo devolver un valor con la función y usarlo en el código llamante
Paso de valores por referencia a argumentos

Cuándo manejes bien estos aspectos, es media horita, vuelve al programa.

Que significado tienen las variables?

He modificado un poco tu programa y en Mint con el MATE Terminal solo me da un problema: cuándo maximizo la ventana no muestra todo el tablero y el menú hasta que se pulsa una tecla, pero eso ya es del funcionamiento del propio terminal.

Ahí va el código:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define alto 25
#define ancho 25

void escribir(int pasos);
void imprimir_tablero();
void imprimir_datos_lapiz();
void pintar_casilla();

typedef enum {
    NORTE,
    ESTE,
    SUR,
    OESTE
} direccion_t;

typedef enum {
    LEVANTADO,
    BAJADO
} estado_t;

struct {
    unsigned x;
    unsigned y;
    direccion_t direccion;
    estado_t estado;
} lapiz;

int plano[alto][ancho];

int main(void) {
    int op = 0;
    int pasos;
   
    while (op != 9) {
        system("clear");
        imprimir_datos_lapiz();
        imprimir_tablero();
        puts("");
        puts("Introduzca una opcion");
        puts("1) Levantar lapiz");
        puts("2) Bajar lapiz");
        puts("3) Girar a la derecha");
        puts("4) Girar a la izquierda");
        puts("5) Desplazar lapiz");
        puts("9) Salir");
        printf("\n>>");
        scanf("%d", &op);
        while(getchar() != '\n');
       
        switch (op) {
            case 1:
                lapiz.estado = LEVANTADO;
                pintar_casilla();
                break;
            case 2:
                lapiz.estado = BAJADO;
                pintar_casilla();
                break;
            case 3:
                if(lapiz.direccion == OESTE)
                    lapiz.direccion = NORTE;
                else
                    lapiz.direccion++;
                break;
            case 4:
                if(lapiz.direccion == NORTE)
                    lapiz.direccion = OESTE;
                else
                    lapiz.direccion--;
                break;
            case 5:
                printf("Introduzca la cantidad de pasos que desea dar: ");
                scanf("%d", &pasos);
                while(getchar() != '\n');
                escribir(pasos);
                break;
            case 9:
                printf("Gracias por usar el programa! \n");
                break;
        }
    }
    return 0;
}

void pintar_casilla() {
    plano[lapiz.y][lapiz.x] = lapiz.estado;
}

void escribir(int pasos) {
    switch(lapiz.direccion) {
        case NORTE:
            for(; pasos > 0; pasos--) {
                if(lapiz.y > 0) {
                    lapiz.y--;
                    pintar_casilla();
                }
            }
            break;
        case ESTE:
            for(; pasos > 0; pasos--) {
                if(lapiz.x < (ancho - 1)) {
                    lapiz.x++;
                    pintar_casilla();
                }
            }
            break;
        case SUR:
            for(; pasos > 0; pasos--) {
                if(lapiz.y < (alto-1)) {
                    lapiz.y++;
                    pintar_casilla();
                }
            }
            break;
        case OESTE:
            for(; pasos > 0; pasos--) {
                if (lapiz.x > 0) {
                    lapiz.x--;
                    pintar_casilla();
                }
            }
            break;
    }
}

void imprimir_datos_lapiz() {
    char direcc[6];
    char est[10];
   
    switch(lapiz.direccion) {
        case 0:
            strcpy(direcc, "NORTE");
            break;
        case 1:
            strcpy(direcc, "ESTE");
            break;
        case 2:
            strcpy(direcc, "SUR");
            break;
        case 3:
            strcpy(direcc, "OESTE");
            break;
    }
   
    if(!lapiz.estado)
        strcpy(est, "LEVANTADO");
    else
        strcpy(est, "BAJADO");
   
    printf("Lapiz: %9s | %5s | x = %i | y = %i\n", est, direcc, lapiz.x, lapiz.y);
}

void imprimir_tablero() {
    int i, j;
   
    for (i = 0; i < alto; i++) {
        for (j = 0; j < ancho; j++) {
            if(lapiz.y == i && lapiz.x == j )
                printf("I");
            else if(plano[i][j] == 0)
                printf(" ");
            else
                printf("x");
        }
        puts("");
    }
}

Bien. Ahora si he entendido bien quieres usar un array de punteros a funciones, y a este array quieres llamarlo area.

Se crea así:
Su nombre es area, por tanto lo definimos

Código (c) [Seleccionar] Expandir

area
area debe ser un puntero a función

Código (c) [Seleccionar] Expandir

(*area)()
area además debe ser un array de dos punteros a función

Código (c) [Seleccionar] Expandir

(*area[2])()
Las firmas de las funciones tomaran un argumento tipo int y devolverán un int

Código (c) [Seleccionar] Expandir

int (*area[2])(int)
Ahí lo tienes.

Para incluir las funciones al array se hace como si fuera un elemento del array normal, pero pasándole el nombre de la función

Código (c) [Seleccionar] Expandir

area[0] = area_cuadrado;
area[1] = area_circulo;

Para llamar a la función usa el elemento del array como si fuera la función a llamar. Por ejemplo con el cuadrado

Código (c) [Seleccionar] Expandir

resp = area[0](lado);

Varias cosas:
Las funciones auxiliares esperan que retornes un entero pero llegan al de su ejecución y no devuelven nada.
Llamas a la función con un argumento pero ese argumento no lo usas ya que lo reescribes dentro de la función.
Reescibe las funciones y/o main para dar coherencia a todo el conjunto. Una vez bien definidos los interfaces y la forma de trabajar se podrá cambiar el programa para hacer un array de punteros a funciones.