int para números enteros

En C, el tipo de dato int se utiliza para almacenar números enteros, es decir, números sin parte decimal. Este tipo de dato es uno de los más fundamentales y frecuentemente utilizados en la programación.

Para declarar una variable de tipo entero, utilizamos la siguiente sintaxis:

int nombre_variable;

Donde nombre_variable es el identificador que elegimos para referirnos a ese espacio de memoria. Una vez declarada, podemos asignarle un valor utilizando el operador de asignación (=):

int edad;
edad = 25;

También es posible combinar la declaración y la asignación en una sola línea, lo que se conoce como inicialización:

int edad = 25;

Rango de valores

El tipo int tiene un rango limitado de valores que puede almacenar. En la mayoría de los sistemas modernos, un int ocupa 4 bytes (32 bits) de memoria, lo que permite representar números entre -2,147,483,648 y 2,147,483,647.

#include <stdio.h>
#include <limits.h>

int main() {
    printf("Valor mínimo de int: %d\n", INT_MIN);
    printf("Valor máximo de int: %d\n", INT_MAX);
    return 0;
}

Operaciones con enteros

Con las variables de tipo int podemos realizar diversas operaciones aritméticas:

int a = 10;
int b = 3;
int suma = a + b;      // 13
int resta = a - b;     // 7
int multiplicacion = a * b;  // 30
int division = a / b;  // 3 (la división entre enteros trunca el resultado)
int modulo = a % b;    // 1 (el resto de la división)

Es importante destacar que la división entre enteros siempre produce un resultado entero, truncando cualquier parte decimal. En el ejemplo anterior, 10 ÷ 3 = 3.33..., pero al ser una división entre enteros, el resultado es simplemente 3.

Ejemplos prácticos

Veamos algunos ejemplos de uso de variables enteras en situaciones cotidianas:

#include <stdio.h>

int main() {
    // Declaración e inicialización de variables enteras
    int edad = 25;
    int anioNacimiento = 1998;
    int anioActual = 2023;
    
    // Cálculo de la edad
    int edadCalculada = anioActual - anioNacimiento;
    
    printf("Edad declarada: %d años\n", edad);
    printf("Edad calculada: %d años\n", edadCalculada);
    
    // Ejemplo con cantidad de elementos
    int numeroEstudiantes = 35;
    int capacidadAula = 40;
    int asientosDisponibles = capacidadAula - numeroEstudiantes;
    
    printf("Asientos disponibles en el aula: %d\n", asientosDisponibles);
    
    return 0;
}

Conversión entre tipos

Cuando mezclamos int con otros tipos numéricos en operaciones, C realiza conversiones automáticas siguiendo ciertas reglas. Por ejemplo, si operamos un int con un tipo de mayor precisión, el resultado se adaptará al tipo más preciso:

int entero = 5;
// La siguiente línea muestra cómo el entero se convierte automáticamente
// al operar con otros tipos (esto se verá con más detalle en otras secciones)
double resultado = entero / 2.0;  // resultado será 2.5, no 2

Constantes enteras

Podemos definir constantes enteras de varias formas:

int decimal = 42;      // Base 10 (sistema decimal)
int octal = 052;       // Base 8 (sistema octal, comienza con 0)
int hexadecimal = 0x2A; // Base 16 (sistema hexadecimal, comienza con 0x)

Uso de modificadores (solo mención)

El tipo int puede combinarse con modificadores que alteran su tamaño y comportamiento, pero estos se estudiarán en lecciones más avanzadas.

Buenas prácticas

• Inicializa siempre tus variables enteras al declararlas para evitar comportamientos impredecibles.
• Verifica los límites cuando realices operaciones que puedan exceder el rango de un int.
• Usa nombres descriptivos para tus variables que indiquen claramente su propósito.

// Mal ejemplo
int x = 25;

// Buen ejemplo
int edadEstudiante = 25;

El tipo int es perfecto para representar cantidades enteras como edades, contadores, índices o cualquier valor numérico que no requiera decimales. En las siguientes secciones exploraremos otros tipos de datos para manejar números con decimales y caracteres individuales.

float/double para decimales

En C, cuando necesitamos trabajar con números decimales (también llamados números de punto flotante), disponemos de dos tipos de datos principales: float y double. Estos tipos nos permiten representar valores que contienen una parte fraccionaria, como precios, medidas o cálculos científicos.

Tipo float

El tipo float (abreviatura de "floating point") es el tipo básico para representar números con decimales. Para declarar una variable de este tipo usamos:

float precio;
precio = 19.99;

O de forma más directa mediante inicialización:

float temperatura = 36.5;

El tipo float típicamente ocupa 4 bytes de memoria y proporciona una precisión de aproximadamente 7 dígitos decimales. Esto es suficiente para muchas aplicaciones cotidianas, pero puede resultar limitado para cálculos científicos o financieros de alta precisión.

Tipo double

Cuando necesitamos mayor precisión en nuestros cálculos, utilizamos el tipo double (doble precisión):

double pi = 3.14159265358979323846;

Un double generalmente ocupa 8 bytes de memoria y ofrece aproximadamente 15-16 dígitos de precisión, lo que lo hace mucho más adecuado para cálculos que requieren exactitud.

Declaración y asignación

La sintaxis para declarar y asignar valores a variables de punto flotante es similar a la de los enteros:

// Declaración y asignación separadas
float distancia;
distancia = 42.195;

// Declaración con inicialización
double masa = 0.000000000000000000000000000000000167;

Notación científica

Para representar números muy grandes o muy pequeños, podemos utilizar la notación científica:

float electrones = 6.022e23;  // 6.022 × 10^23
double atomRadius = 5.29e-11; // 5.29 × 10^-11

La letra e (o E) indica "multiplicado por 10 elevado a", lo que facilita la representación de valores extremadamente grandes o pequeños.

Precisión y limitaciones

Es importante entender que los números de punto flotante tienen limitaciones de precisión:

#include <stdio.h>
#include <float.h>

int main() {
    printf("Precisión float: ~%d dígitos\n", FLT_DIG);
    printf("Precisión double: ~%d dígitos\n", DBL_DIG);
    
    float f = 0.1 + 0.2;
    printf("0.1 + 0.2 = %.20f\n", f);  // Mostrará un valor cercano pero no exactamente 0.3
    
    return 0;
}

Esta imprecisión se debe a que los números de punto flotante se almacenan en formato binario, y algunos decimales que son exactos en base 10 no pueden representarse exactamente en base 2.

Operaciones con números decimales

Podemos realizar las mismas operaciones aritméticas que con enteros:

float a = 9.5;
float b = 2.5;

float suma = a + b;        // 12.0
float resta = a - b;       // 7.0
float multiplicacion = a * b;  // 23.75
float division = a / b;    // 3.8

A diferencia de la división entre enteros, la división entre flotantes conserva la parte decimal del resultado.

Conversión entre tipos numéricos

C realiza conversiones automáticas entre tipos numéricos siguiendo estas reglas:

1. Si operamos un int con un float, el resultado será float
2. Si operamos un float con un double, el resultado será double

int entero = 5;
float decimal = 2.5;
double resultado;

resultado = entero + decimal;  // El entero se convierte a float, luego el resultado a double

También podemos realizar conversiones explícitas (casting):

float precio = 29.99;
int precioRedondeado = (int)precio;  // precioRedondeado será 29 (trunca, no redondea)

Ejemplos prácticos

Veamos algunos ejemplos de uso cotidiano:

#include <stdio.h>

int main() {
    // Cálculo del área de un círculo
    float radio = 5.0;
    float pi = 3.14159;
    float area = pi * radio * radio;
    
    printf("El área del círculo es: %.2f unidades cuadradas\n", area);
    
    // Conversión de temperatura
    float celsius = 25.0;
    float fahrenheit = (celsius * 9.0 / 5.0) + 32.0;
    
    printf("%.1f grados Celsius equivalen a %.1f grados Fahrenheit\n", 
           celsius, fahrenheit);
    
    // Cálculo de promedio
    double nota1 = 8.5;
    double nota2 = 7.0;
    double nota3 = 9.25;
    double promedio = (nota1 + nota2 + nota3) / 3.0;
    
    printf("El promedio de las notas es: %.2f\n", promedio);
    
    return 0;
}

Formato de impresión

Para imprimir valores de punto flotante con printf, utilizamos los especificadores %f, %e (notación científica) o %g (elige el formato más adecuado):

float valor = 123.456789;
printf("Valor normal: %f\n", valor);          // 123.456787
printf("Con precisión: %.2f\n", valor);       // 123.46 (2 decimales)
printf("Notación científica: %e\n", valor);   // 1.234568e+02
printf("Formato automático: %g\n", valor);    // 123.457

El .2 en %.2f indica que queremos mostrar exactamente 2 decimales.

¿Cuándo usar float y cuándo double?

• Usa float cuando:

• Necesites ahorrar memoria

• La precisión no sea crítica

• Trabajes con gráficos o cálculos simples

• Usa double cuando:

• Requieras cálculos precisos

• Trabajes con valores científicos

• Realices operaciones financieras

• Hagas muchas operaciones en cadena donde los errores podrían acumularse

Buenas prácticas

• Inicializa siempre tus variables de punto flotante.
• Evita comparar directamente valores de punto flotante con == debido a problemas de precisión.
• Usa constantes con punto decimal (como 2.0 en lugar de 2) cuando quieras asegurar operaciones en punto flotante.

// Incorrecto (puede dar resultados inesperados por problemas de precisión)
if (resultado == 0.3) { ... }

// Correcto (comprueba si la diferencia es menor que una tolerancia pequeña)
if (fabs(resultado - 0.3) < 0.0001) { ... }

Los tipos float y double son fundamentales para cualquier programa que requiera cálculos con decimales, desde simples conversiones de unidades hasta complejas simulaciones científicas.

char para caracteres individuales

En C, el tipo de dato char se utiliza para representar caracteres individuales como letras, dígitos, símbolos de puntuación y caracteres especiales. Este tipo de dato es fundamental para el manejo de texto y procesamiento de caracteres.

Para declarar una variable de tipo char, utilizamos la siguiente sintaxis:

char letra;

Una vez declarada, podemos asignarle un valor utilizando comillas simples para encerrar el carácter:

char letra;
letra = 'A';

También podemos combinar la declaración y asignación en una sola línea:

char inicial = 'J';

Representación interna

Internamente, un char ocupa 1 byte (8 bits) de memoria y almacena el valor numérico correspondiente al carácter según la tabla ASCII. Esto significa que cada carácter tiene un código numérico asociado:

#include <stdio.h>

int main() {
    char letra = 'A';
    printf("El carácter '%c' tiene el valor numérico %d\n", letra, letra);
    // Mostrará: El carácter 'A' tiene el valor numérico 65
    
    return 0;
}

Esta dualidad permite tratar los caracteres como valores numéricos cuando sea necesario:

char letra = 'A';
char siguiente = letra + 1;  // 'B', porque 'A' + 1 = 'B' en ASCII

Caracteres especiales

Para representar caracteres que no pueden escribirse directamente, C proporciona secuencias de escape que comienzan con una barra invertida:

char nuevaLinea = '\n';      // Salto de línea
char tabulador = '\t';       // Tabulación horizontal
char comillaSimple = '\'';   // Comilla simple
char barraInvertida = '\\';  // Barra invertida
char alerta = '\a';          // Carácter de alerta (produce un pitido)

Estas secuencias son útiles para formatear texto o representar caracteres de control:

#include <stdio.h>

int main() {
    printf("Primera línea\nSegunda línea\n");
    printf("Nombre:\tJuan\nEdad:\t25\n");
    
    return 0;
}

Entrada y salida de caracteres

Para leer y mostrar caracteres, podemos usar las funciones de la biblioteca estándar:

#include <stdio.h>

int main() {
    char inicial;
    
    printf("Introduce la inicial de tu nombre: ");
    scanf(" %c", &inicial);  // Nota el espacio antes de %c para ignorar espacios en blanco
    
    printf("Tu inicial es: %c\n", inicial);
    
    return 0;
}

También existen funciones específicas para caracteres:

#include <stdio.h>

int main() {
    char c;
    
    printf("Presiona una tecla: ");
    c = getchar();  // Lee un carácter de la entrada estándar
    
    printf("Has presionado: ");
    putchar(c);     // Escribe un carácter en la salida estándar
    printf("\n");
    
    return 0;
}

Operaciones con caracteres

Podemos realizar varias operaciones con caracteres, aprovechando su representación numérica:

#include <stdio.h>
#include <ctype.h>  // Biblioteca para funciones de manejo de caracteres

int main() {
    char minuscula = 'a';
    char mayuscula = minuscula - 32;  // Convertir a mayúscula usando aritmética
    
    printf("Minúscula: %c, Mayúscula: %c\n", minuscula, mayuscula);
    
    // Usando funciones de la biblioteca ctype.h
    char letra = 'x';
    char letraMayuscula = toupper(letra);  // Convierte a mayúscula
    
    printf("Original: %c, En mayúscula: %c\n", letra, letraMayuscula);
    
    return 0;
}

La biblioteca ctype.h proporciona funciones útiles para trabajar con caracteres:

#include <stdio.h>
#include <ctype.h>

int main() {
    char c = 'A';
    
    if (isalpha(c)) {
        printf("%c es una letra\n", c);
    }
    
    if (isdigit('5')) {
        printf("5 es un dígito\n");
    }
    
    if (islower('a')) {
        printf("a está en minúscula\n");
    }
    
    if (isupper('B')) {
        printf("B está en mayúscula\n");
    }
    
    return 0;
}

Ejemplos prácticos

Veamos algunos ejemplos de uso de caracteres en situaciones cotidianas:

#include <stdio.h>
#include <ctype.h>

int main() {
    // Verificar si una letra es vocal
    char letra;
    
    printf("Introduce una letra: ");
    scanf(" %c", &letra);
    
    // Convertimos a minúscula para simplificar la comparación
    letra = tolower(letra);
    
    if (letra == 'a' || letra == 'e' || letra == 'i' || letra == 'o' || letra == 'u') {
        printf("La letra %c es una vocal\n", letra);
    } else if (isalpha(letra)) {
        printf("La letra %c es una consonante\n", letra);
    } else {
        printf("El carácter %c no es una letra\n", letra);
    }
    
    return 0;
}

Otro ejemplo que muestra cómo recorrer el alfabeto:

#include <stdio.h>

int main() {
    printf("El alfabeto en mayúsculas:\n");
    
    for (char letra = 'A'; letra <= 'Z'; letra++) {
        printf("%c ", letra);
    }
    printf("\n");
    
    printf("El alfabeto en minúsculas:\n");
    
    for (char letra = 'a'; letra <= 'z'; letra++) {
        printf("%c ", letra);
    }
    printf("\n");
    
    return 0;
}

Caracteres y códigos ASCII

Podemos trabajar directamente con los códigos ASCII cuando sea necesario:

#include <stdio.h>

int main() {
    // Imprimir tabla ASCII básica (caracteres imprimibles)
    printf("Tabla ASCII básica:\n");
    printf("Código\tCarácter\n");
    
    for (int i = 32; i < 127; i++) {
        printf("%d\t%c\n", i, (char)i);
    }
    
    return 0;
}

Buenas prácticas

• Usa comillas simples para caracteres individuales y comillas dobles para cadenas.
• Inicializa siempre tus variables de tipo char al declararlas.
• Utiliza las funciones de ctype.h en lugar de manipular manualmente los códigos ASCII.
• Recuerda que char puede ser con o sin signo dependiendo del compilador, lo que afecta su rango.

// Incorrecto
char letra = "A";  // Error: "A" es una cadena, no un carácter

// Correcto
char letra = 'A';  // 'A' es un carácter individual

El tipo char es esencial para el procesamiento de texto, validación de entrada de usuario y cualquier operación que involucre caracteres individuales. Aunque parece simple, su versatilidad lo convierte en uno de los tipos de datos fundamentales en C.