Mensajes

Más fácil:
Incluir el

Código [Seleccionar] Expandir

#include <locales.h>

Y como primera instrucción ejecutable del main:

Código [Seleccionar] Expandir

setlocale(LC_ALL, "spanish");

Así todo lo referente a conversiones, representaciones, monedas, etc. pasará al formato español. Eso incluye ñ, tildes, etc.

El goto sí, bien usado simplifica las cosas. Pero el bicho este nunca.

Posiblemente las dos funciones más extrañas de C y con menor uso, según he visto. Por eso: a parte de simular excepciones ¿Qué uso se les podría dar a ese par de funciones? Por mi parte todavía no se me ha ocurrido ni presentado la ocasión de usarlas.

En código de producción debes comprobar que malloc no ha devuelto NULL, que es su comportamiento cuándo no encuentra memoria suficiente, y resolver esa novedad. Pero para lo demás, ok. Incluso puedes eliminar eso de llevar a NULL los punteros si no los vas a usar más, pero es buena práctica eso de marcarlos con NULL.

Muy bien.

No tengo linux para probar el código, pero debería ser una cosa así:

Código (c) [Seleccionar] Expandir

#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <termios.h>

// Sacado de https://stackoverflow.com/questions/7469139/what-is-equivalent-to-getch-getche-in-linux
static struct termios old, new;

/* Initialize new terminal i/o settings */
void initTermios(int echo)  {
    tcgetattr(0, &old); /* grab old terminal i/o settings */
    new = old; /* make new settings same as old settings */
    new.c_lflag &= ~ICANON; /* disable buffered i/o */
    if (echo) {
        new.c_lflag |= ECHO; /* set echo mode */
    } else {
        new.c_lflag &= ~ECHO; /* set no echo mode */
    }
    tcsetattr(0, TCSANOW, &new); /* use these new terminal i/o settings now */
}

/* Restore old terminal i/o settings */
void resetTermios(void) {
    tcsetattr(0, TCSANOW, &old);
}

/* Read 1 character - echo defines echo mode */
char getch_(int echo) {
    char ch;
    initTermios(echo);
    ch = getchar();
    resetTermios();
    return ch;
}

/* Read 1 character without echo */
char getch(void) {
    return getch_(0);
}

/* Read 1 character with echo */
char getche(void) {
    return getch_(1);
}

void SetTermNoCanon( struct termios *SavedTM) {
    struct termios tm;

    tcgetattr(0, &tm);
    tcgetattr(0, SavedTM);
    tm.c_lflag &= ~(ICANON|ECHO);
    tm.c_cc[VMIN]= 1;
    tm.c_cc[VTIME]= 0;
    tcsetattr(0, TCSANOW, &tm);
}

int main(int argc, const char * argv[]) {
    char c;
    int f;
    long file_end;
    long file_pos;
    char buff[BUFFER_TAMAINA];
    FILE *f1;
    struct stat stat1;

    // Voy a sustituir todos los write a stdout por printf o puts

    // Número de argumentos diferente al esperado
    if (argc != 3) {
        printf("Uso: %s [fichero] [posicion]", argv[0]);
        return EXIT_FAILURE;
    }

    file_pos = atol(argv[2]);

    // No se pueden los metadatos del archivo
    if(stat(argv[1], &statl) == -1) {
        puts("error, no se pueden recuperar datos del archivo");
        return EXIT_FAILURE;
    }

    // El argumento posición no es un número o es 0
    if(file_pos < 1) {
        puts("error, posicion debe ser un entero igual o mayor a 1");
        return EXIT_FAILURE;
    }

    f1 = fopen(argv[1], "r+");

    // El archivo no existe o no se puede abrir
    if(!f1) {
        puts("error, el fichero no existe");
        return EXIT_FAILURE;
    }

    //- Sustituyo todo esto
    //   while(fgetc(f1)!=EOF) {
    //       k++;
    //   }
    //   fclose(f1);
    //- Por lo siguiente

    fflush(f1);
    fseek(f1, 0, SEEK_END);
    file_end = ftell(f1);

    // La posición entregada está fuera del archivo
    if(file_pos>file_end) {
        puts("error, la position es demasiado alta");
        fclose(f1);
        return EXIT_FAILURE;
    }
    fseek(f1, file_pos, SEEK_SET);

    SetTermNoCanon( &saved_tm );

    while(c=getche()!=27) {
        putc(c, f1);
    }

    printf("Información: %s\n", argv[1]);
    printf("---------------------------\n");
    printf("Tamaño: \t \t %d bytes\n", stat1->st_size);
    printf("Links: \t%d\n", stat1->st_nlink);
    printf("inode: \t \t %d\n", stat1->st_ino);

    fclose(f1);
   
    return EXIT_SUCCESS;
}


Código [Seleccionar] Expandir

int *pi;
pi=malloc(sizeof(int));
*pi=5;
printf("%d\n",*pi);
Muy bien. Un puntero en memoria dinámica para un entero.

Código [Seleccionar] Expandir

pi=5;
Aquí pierdes sizeof(int) bytes de memoria dinámica para el resto del programa. Has perdido el puntero antes de liberarlo y ahora apunta a la dirección de memoria 5.
¿Por qué funciona el programa? Porqué un puntero es un caso especial de dato entero sin signo así que le puedes dar cualquier número de esta clase que quieras.

Código [Seleccionar] Expandir

printf("%d\n",pi);
Funciona porque le pides a pi que te dé su contenido como entero y eso es 5. Si le pidieras que te diera el contenido a la que apunta su puntero con *pi el S.O. te lo prohibiría por estar fuera del marco de memoria del programa.

Código [Seleccionar] Expandir

char *cadena;
cadena=malloc(5*sizeof(char));
Muy bien. Un puntero en memoria dinámica para un entero.

Código [Seleccionar] Expandir

cadena="hola";
Acabas de perder 5*sizeof(char) bytes de memoria dinámica al hacer que cadena apunte  a otro sitio sin haber liberado la memoria anterior. Ahora cadena apunta a la zona de sólo lectura donde el programa ha guardado la cadena 'hola'. No has copia 'hola' a cadena si eso es lo que pretendías; has modificado el puntero.

Repasa este par de stackoverflow. Lo explica.
https://stackoverflow.com/questions/7469139/what-is-equivalent-to-getch-getche-in-linux

Eso depende del terminal, no hay una forma estándar para todo el mundo. Si tienes *nix se hace de una forma, en Windows de otra...

La llamada está bien. A lo mejor te fallara la implementación.