En C, la biblioteca estándar proporciona varias funciones para la entrada y salida de datos. Las más comunes son printf y scanf para la entrada y salida formateada, y getchar y putchar para la entrada y salida de caracteres individuales.
#include <stdio.h>
int main() {
// Declaración de variables
int edad;
float altura;
char inicial;
char nombre[50];
// Uso de printf para mostrar un mensaje
printf("Introduce tu edad: ");
// Uso de scanf para leer un entero desde la entrada estándar
scanf("%d", &edad);
// Uso de printf para mostrar otro mensaje
printf("Introduce tu altura en metros (ejemplo: 1.75): ");
// Uso de scanf para leer un número flotante desde la entrada estándar
scanf("%f", &altura);
// Uso de printf para solicitar un solo carácter
printf("Introduce la inicial de tu primer nombre: ");
// Uso de getchar para capturar el carácter de nueva línea
getchar(); // Consumir el carácter de nueva línea restante
// Uso de getchar para leer un carácter desde la entrada estándar
inicial = getchar();
// Uso de printf para solicitar una cadena
printf("Introduce tu nombre completo: ");
// Uso de scanf para leer una cadena desde la entrada estándar
scanf("%s", nombre);
// Mostrar los valores leídos usando printf
printf("\nEdad: %d años\n", edad);
printf("Altura: %.2f metros\n", altura);
printf("Inicial del nombre: %c\n", inicial);
printf("Nombre completo: %s\n", nombre);
// Uso de putchar para imprimir un carácter
putchar('\n');
putchar('F');
putchar('i');
putchar('n');
putchar('a');
putchar('l');
putchar('\n');
return 0;
}
printf:
printf es una función de salida que permite mostrar datos en la pantalla. Puedes usar diferentes especificadores de formato como %d para enteros, %f para números flotantes, %c para caracteres y %s para cadenas de caracteres.printf se utiliza para mostrar mensajes y datos leídos.scanf:
scanf es una función de entrada que permite leer datos desde la entrada estándar (normalmente el teclado). Utiliza especificadores de formato similares a printf para determinar el tipo de datos a leer.scanf se utiliza para leer un entero (%d), un número flotante (%f), y una cadena (%s).getchar:
getchar es una función de entrada que lee un solo carácter desde la entrada estándar.getchar para leer un carácter después de scanf para capturar la inicial del nombre. También se utiliza una llamada a getchar para consumir el carácter de nueva línea restante en el buffer de entrada.putchar:
putchar es una función de salida que imprime un solo carácter en la salida estándar.putchar se utiliza para imprimir los caracteres individuales de la palabra «Final».printf y scanfEstas funciones son extremadamente útiles para la interacción con el usuario en programas de consola. Usando printf, puedes proporcionar información y pedir datos al usuario, mientras que scanf te permite capturar esos datos.
getchar y putcharAunque getchar y putchar son más básicos y menos utilizados que scanf y printf, son útiles cuando se trabaja con caracteres individuales. Son esenciales para tareas de bajo nivel y en sistemas embebidos donde el control fino sobre la entrada y salida es crucial.
Entender y utilizar correctamente estas funciones te permitirá desarrollar programas en C que interactúan eficazmente con los usuarios, proporcionando una base sólida para construir aplicaciones más complejas.
El manejo de archivos en C es necesario para leer y escribir datos persistentes. La biblioteca estándar de C proporciona varias funciones para trabajar con archivos, incluidas fopen, fclose, fread, fwrite, fprintf y fscanf.
#include <stdio.h>
#include <stdlib.h>
int main() {
FILE *file;
char filename[] = "example.txt";
char text[100];
int num;
float fnum;
// Abrir archivo para escritura
file = fopen(filename, "w");
if (file == NULL) {
perror("Error al abrir el archivo para escritura");
return 1;
}
// Escribir datos en el archivo usando fprintf
fprintf(file, "Escribir en archivo.\n");
fprintf(file, "%d\n", 123);
fprintf(file, "%f\n", 456.789);
// Cerrar archivo
fclose(file);
// Abrir archivo para lectura
file = fopen(filename, "r");
if (file == NULL) {
perror("Error al abrir el archivo para lectura");
return 1;
}
// Leer datos del archivo usando fscanf
fscanf(file, "%s", text);
fscanf(file, "%d", &num);
fscanf(file, "%f", &fnum);
// Mostrar los datos leídos
printf("Texto: %s\n", text);
printf("Número entero: %d\n", num);
printf("Número flotante: %.3f\n", fnum);
// Cerrar archivo
fclose(file);
// Abrir archivo para lectura/escritura binaria
file = fopen("binaryfile.bin", "wb+");
if (file == NULL) {
perror("Error al abrir el archivo binario");
return 1;
}
// Escribir datos en el archivo binario usando fwrite
fwrite(text, sizeof(char), sizeof(text)/sizeof(char), file);
fwrite(&num, sizeof(int), 1, file);
fwrite(&fnum, sizeof(float), 1, file);
// Volver al inicio del archivo para leer los datos
fseek(file, 0, SEEK_SET);
// Leer datos del archivo binario usando fread
fread(text, sizeof(char), sizeof(text)/sizeof(char), file);
fread(&num, sizeof(int), 1, file);
fread(&fnum, sizeof(float), 1, file);
// Mostrar los datos leídos del archivo binario
printf("Texto binario: %s\n", text);
printf("Número entero binario: %d\n", num);
printf("Número flotante binario: %.3f\n", fnum);
// Cerrar archivo binario
fclose(file);
return 0;
}
fopen:
fopen se utiliza para abrir un archivo. Toma dos argumentos: el nombre del archivo y el modo de apertura ("r" para lectura, "w" para escritura, "a" para añadir, "rb" para lectura binaria, "wb" para escritura binaria, etc.).example.txt para escritura y luego para lectura.fclose:
fclose se utiliza para cerrar un archivo que ha sido abierto con fopen. Es importante cerrar un archivo para liberar los recursos asociados.fclose se usa después de escribir y leer el archivo.fread y fwrite:
fread y fwrite se utilizan para leer y escribir datos binarios. fread lee desde un archivo a un bloque de memoria, mientras que fwrite escribe desde un bloque de memoria a un archivo.binaryfile.bin.fprintf:
fprintf es similar a printf, pero escribe datos formateados en un archivo en lugar de la salida estándar.fprintf se utiliza para escribir texto y números en example.txt.fscanf:
fscanf es similar a scanf, pero lee datos formateados desde un archivo en lugar de la entrada estándar.fscanf se utiliza para leer texto y números desde example.txt.Abrir y Cerrar Archivos: fopen abre el archivo y retorna un puntero al archivo. Es crucial verificar si fopen devuelve NULL, lo que indica un error al abrir el archivo. fclose se usa para cerrar el archivo y liberar los recursos.
Lectura y Escritura Formateada: fprintf y fscanf permiten trabajar con datos formateados. fprintf escribe texto formateado en el archivo, mientras que fscanf lee texto formateado del archivo.
Lectura y Escritura Binaria: fwrite y fread son útiles para leer y escribir datos binarios. Son especialmente útiles cuando se trabaja con estructuras de datos complejas o archivos que no están en formato de texto.
Manejo de Errores: Siempre es importante verificar los errores al abrir archivos y realizar operaciones de lectura/escritura para asegurar que el programa maneje adecuadamente las situaciones inesperadas.
Comprender y utilizar estas funciones te permitirá trabajar eficientemente con archivos en C, una habilidad esencial para muchos programas que necesitan manejar datos persistentes.
En C, la lectura y escritura de archivos se puede hacer en dos modos: texto y binario. La diferencia principal radica en cómo se interpretan los datos. Los archivos de texto son interpretados como caracteres legibles por humanos, mientras que los archivos binarios son interpretados como datos en bruto.
#include <stdio.h>
#include <stdlib.h>
int main() {
FILE *file;
char textFilename[] = "example.txt";
char binaryFilename[] = "example.bin";
char text[100];
int number = 42;
float fnumber = 3.14;
// Abrir archivo de texto para escritura
file = fopen(textFilename, "w");
if (file == NULL) {
perror("Error al abrir el archivo de texto para escritura");
return 1;
}
// Escribir datos en el archivo de texto
fprintf(file, "Esto es una línea de texto.\n");
fprintf(file, "Número: %d\n", number);
fprintf(file, "Número flotante: %.2f\n", fnumber);
// Cerrar archivo de texto
fclose(file);
// Abrir archivo de texto para lectura
file = fopen(textFilename, "r");
if (file == NULL) {
perror("Error al abrir el archivo de texto para lectura");
return 1;
}
// Leer datos del archivo de texto
while (fgets(text, sizeof(text), file) != NULL) {
printf("%s", text);
}
// Cerrar archivo de texto
fclose(file);
// Abrir archivo binario para escritura
file = fopen(binaryFilename, "wb");
if (file == NULL) {
perror("Error al abrir el archivo binario para escritura");
return 1;
}
// Escribir datos en el archivo binario
fwrite(&number, sizeof(int), 1, file);
fwrite(&fnumber, sizeof(float), 1, file);
// Cerrar archivo binario
fclose(file);
// Abrir archivo binario para lectura
file = fopen(binaryFilename, "rb");
if (file == NULL) {
perror("Error al abrir el archivo binario para lectura");
return 1;
}
// Leer datos del archivo binario
fread(&number, sizeof(int), 1, file);
fread(&fnumber, sizeof(float), 1, file);
// Mostrar los datos leídos del archivo binario
printf("Número leído del archivo binario: %d\n", number);
printf("Número flotante leído del archivo binario: %.2f\n", fnumber);
// Cerrar archivo binario
fclose(file);
return 0;
}
Abrir Archivos para Escritura:
fopen con los modos "w" (escritura de texto) y "wb" (escritura binaria). En modo texto, los datos son interpretados como caracteres legibles. En modo binario, los datos son interpretados en su forma binaria cruda.example.txt y example.bin para escritura.Escribir en Archivos:
fprintf se usa para escribir datos formateados en el archivo.fwrite se usa para escribir datos en su forma binaria.example.txt. Para example.bin, se escriben los mismos datos en formato binario.Cerrar Archivos:
fclose se usa para cerrar el archivo después de las operaciones de lectura o escritura, liberando los recursos asociados.Abrir Archivos para Lectura:
fopen con los modos "r" (lectura de texto) y "rb" (lectura binaria). En modo texto, los datos se leen como caracteres legibles. En modo binario, los datos se leen en su forma binaria cruda.example.txt y example.bin para lectura.Leer desde Archivos:
fgets se usa para leer una línea de texto a la vez.fread se usa para leer datos en su forma binaria.example.txt. Para example.bin, se leen y muestran el número entero y el número flotante.Modos de Apertura:
"w": Abre un archivo para escritura (borra el contenido existente)."r": Abre un archivo para lectura."wb": Abre un archivo para escritura en modo binario."rb": Abre un archivo para lectura en modo binario.Lectura y Escritura de Texto:
fprintf y fgets se usan para manipular archivos de texto.fprintf escribe datos formateados en el archivo.fgets lee una línea de texto del archivo.Lectura y Escritura Binaria:
fwrite y fread se usan para manipular archivos binarios.fwrite escribe datos binarios en el archivo.fread lee datos binarios del archivo.Errores y Manejo de Archivos:
fopen para asegurarte de que el archivo se abrió correctamente.