Variables y tipos de datos en C: explicación completa para principiantes, de lo básico a la práctica

1. Introducción

Importancia de las variables y tipos de datos en C

Propósito de este artículo

1. ¿Qué son las variables?– Explicación de métodos de declaración e inicialización, reglas de nomenclatura, etc.
2. Clasificación de tipos de datos– Tipos de datos básicos (int, float, char, etc.) y tipos de datos derivados (estructuras, arrays, punteros, etc.)
3. Conversión de tipos (cast)– Conversión de tipos implícita y explícita
4. Ámbito y vida útil de las variables– Diferencias entre variables locales y globales
5. Selección práctica de tipos de datos– Selección óptima considerando el uso de memoria y la precisión de cálculo

¿En qué situaciones es necesario prestar atención a las variables y tipos de datos?

Optimización de memoria

short num1 = 100;  // 2 bytes (16 bits)
int num2 = 100;    // 4 bytes (32 bits)

Mejora de la precisión de cálculo

float pi = 3.141592;  // Punto flotante de precisión simple (32 bits)
double pi_high = 3.14159265358979;  // Punto flotante de doble precisión (64 bits)

Prevención de errores por conversión de tipos

int a = 10;
float b = 3.5;
int result = a + b;  // Conversión de tipos implícita (el resultado se redondea a int)

float result_correct = (float)a + b;  // Conversión de tipos correcta

Resumen

2. ¿Qué es una variable?

Concepto básico de las variables

Características de las variables

• Área de memoria para almacenar datos
• Se puede cambiar el valor durante la ejecución del programa
• Asigna áreas de memoria según el tipo de datos

Declaración e inicialización de variables

Método básico de declaración de variables

Tipo de datos nombre_variable;

Inicialización de variables

int num = 10;  // Inicializar la variable num de tipo entero a 10
float pi = 3.14;  // Inicializar la variable pi de tipo punto flotante a 3.14
char letter = 'A';  // Inicializar la variable letter de tipo carácter a 'A'

Tipos de variables en C

Reglas de nomenclatura y mejores prácticas para nombres de variables

Reglas para nombres de variables en C

• Alfabeto (A-Z, a-z)
• Números (0-9) *Sin embargo,no se pueden usar al inicio del nombre de la variable
• Guion bajo (_)

• Palabras reservadas (ej.: int, float, return, etc.)
• Caracteres especiales (ej.: @, #, $, etc.)
• Números al inicio del nombre de la variable

int _value = 10;  // OK
int number1 = 20;  // OK
int 1st_number = 30;  // NG (No se pueden usar nombres de variables que comiencen con números)
int return = 100;  // NG (No se pueden usar palabras reservadas)

Nomenclatura considerando la legibilidad (mejores prácticas)

int userAge;  // Edad del usuario
float circleArea;  // Área del círculo
char firstLetter;  // Primera letra

int a;  // Sin significado
float b1;  // No se sabe qué dato es
char x_y_z;  // Demasiado complejo

• Dar nombres significativos a las variables
• Para múltiples palabras, usar camelCase (ej.: userAge) o snake_case (ej.: user_age)
• Evitar abreviaturas tanto como sea posible (ej.: numOfStudents de manera específica)

Uso de variables (programa simple)

Código de muestra

#include 

int main() {
    int a = 5;
    int b = 10;
    int sum = a + b;  // Cálculo usando variables

    printf("a = %d, b = %d, sum = %dn", a, b, sum);
    return 0;
}

Resultado de ejecución

a = 5, b = 10, sum = 15

Resumen

• Las variables son áreas de memoria para almacenar datos temporalmente
• En C, al declarar variables, es necesario especificar el tipo de datos
• Hay reglas para nombrar variables, y se recomienda nombrar considerando la legibilidad
• Usando variables, se facilita la gestión de datos

3. Resumen de los tipos de datos en C

¿Qué es un tipo de datos?

Características de los tipos de datos en C

int age = 25;        // Entero (solo puede almacenar valores enteros)
float pi = 3.14;     // Número de punto flotante (puede manejar decimales)
char letter = 'A';   // Tipo carácter (solo puede almacenar 1 carácter)

Clasificación de los tipos de datos en C

Tipos de datos básicos

Tipo entero (Integer)

int number = 100;
short smallNumber = 10;
unsigned int positiveOnly = 300;

Tipo de punto flotante (Floating Point)

float pi = 3.14f;  // Agregar "f" para indicar tipo float
double precisePi = 3.1415926535;

Tipo carácter (Character)

char letter = 'A';
printf("%c", letter);  // Imprime A

char letter = 'A';
printf("%d", letter);  // 65 (código ASCII de 'A')

Tipos de datos derivados

Criterios para seleccionar tipos de datos

for (unsigned int i = 0; i < 100; i++) {
    printf("%d ", i);
}

Resumen

• Los tipos de datos en C incluyentipos de datos básicos(tipos enteros, punto flotante, carácter) ytipos de datos derivados(arreglos, estructuras, punteros, etc.).
• Seleccionar el tipo de datos adecuado mejora la eficiencia del programa.
• Para tipos enteros, int es común; para punto flotante, double.
• Utilizar tipos de datos derivados facilita el manejo de estructuras de datos complejas.

4. Tipos de datos básicos (tipos primitivos)

¿Qué son los tipos de datos básicos?

1. Tipo entero (Integer)

Tipos de enteros y tamaño de memoria

Ejemplo de uso del tipo entero

#include 

int main() {
    int num = 100;         // Tipo de entero general
    short smallNum = 10;   // Entero pequeño (ahorro de memoria)
    long bigNum = 1000000; // Entero grande
    unsigned int positiveOnly = 300; // Solo enteros positivos

    printf("num: %d, smallNum: %d, bigNum: %ld, positiveOnly: %un", num, smallNum, bigNum, positiveOnly);
    return 0;
}

2. Tipo de punto flotante (Floating Point)

Tipos de punto flotante

Ejemplo de uso del tipo de punto flotante

#include 

int main() {
    float pi = 3.14f;         // Se agrega "f" para tipo float
    double precisePi = 3.1415926535;  // Tipo double con mayor precisión

    printf("pi (float): %.7fn", pi);
    printf("precisePi (double): %.15lfn", precisePi);
    return 0;
}

3. Tipo de carácter (Character)

Características del tipo de carácter

• Utiliza 1 byte (8 bits) de memoria
• char El tipo se maneja internamente como un entero usando códigos ASCII

Ejemplo de uso del tipo de carácter

#include 

int main() {
    char letter = 'A';  // Almacena un carácter
    printf("letter: %cn", letter);
    printf("Código ASCII: %dn", letter);  // 'A' es 65

    return 0;
}

Selección adecuada de tipos de datos básicos

short smallNum = 32767;  // Ahorra memoria

Resumen

• Los tipos de datos básicos son la base de los programas en Cy manejan enteros, decimales y caracteres
• Los tipos enteros (int, short, long) manejan enteros y también se pueden usar sin signo (unsigned)
• Los tipos de punto flotante (float, double) manejan decimales y se eligen según la precisión
• El tipo de carácter (char) maneja 1 carácter y se almacena internamente como un entero
• Al seleccionar el tipo de datos adecuado, se puede mejorar la eficiencia del programa y ahorrar memoria

5. Tipos de datos derivados (Derived Data Types)

¿Qué son los tipos de datos derivados?

1. Arreglo (Array)

Declaración e inicialización de arreglos

tipo de dato nombre_arreglo[numero_de_elementos];

int numbers[5] = {10, 20, 30, 40, 50};

printf("%d\n", numbers[0]);  // Imprime 10
numbers[1] = 25;  // Actualiza el segundo elemento

Arreglos multidimensionales (arreglo 2D)

int matrix[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};

2. Estructura (struct)

Definición y uso de estructuras

struct Person {
    char name[50];
    int age;
    float height;
};

int main() {
    struct Person person1 = {"Taro", 25, 175.5};
    printf("Nombre: %s, Edad: %d, Altura: %.1f cm\n", person1.name, person1.age, person1.height);
    return 0;
}

3. Unión (union)

Definición y uso de uniones

union Data {
    int i;
    float f;
};

int main() {
    union Data data;
    data.i = 10;
    printf("Entero: %d\n", data.i);

    data.f = 3.14;
    printf("Flotante: %.2f\n", data.f);  // Aquí el valor de data.i se vuelve indefinido

    return 0;
}

4. Tipo enumerado (enum)

Definición y uso de tipos enumerados

enum Color { RED, GREEN, BLUE };

int main() {
    enum Color favoriteColor = GREEN;
    printf("Color favorito: %d\n", favoriteColor); // 1 (GREEN tiene números asignados secuencialmente desde 0 por defecto)
    return 0;
}

5. Puntero (Pointer)

Conceptos básicos de punteros

int a = 10;
int *ptr = &a  // Almacena la dirección de 'a' en el puntero

printf("Dirección de a: %p\n", &a);
printf("Valor del puntero: %p\n", ptr);
printf("Valor desreferenciado: %d\n", *ptr); // 10

Usos de punteros

Resumen

• El arreglogestiona datos del mismo tipo de manera agrupada
• La estructuratrata datos de tipos diferentes como una sola unidad
• La uniónes untipo de dato especial que comparte memoria
• El tipo enumeradodefine constantes con significado
• El punteromaneja la dirección de variables

6. Modificadores de tipo (Type Modifiers)

¿Qué son los modificadores de tipo?

1. const (declarar constantes)

Ejemplo de uso de const

#include 

int main() {
    const int MAX_USERS = 100;  // Declarar como constante
    printf("Max Users: %d\n", MAX_USERS);

    // MAX_USERS = 200;  // ¡Error! No se puede cambiar el valor porque es const

    return 0;
}

Aplicar const a los argumentos de una función

void printMessage(const char *message) {
    printf("%s\n", message);
    // message[0] = 'H';  // ¡Error! No se puede cambiar porque es const
}

2. volatile (evitar optimizaciones)

Ejemplo de uso de volatile

#include 

volatile int flag = 0;  // Evitar optimizaciones

int main() {
    while (flag == 0) {
        // Algún procesamiento (bucle hasta que se cambie flag)
    }
    printf("Flag changed!\n");
    return 0;
}

• Detección de cambios en variables en procesamiento multihilo
• Lectura de registros de hardware
• Monitoreo de variables que cambian en procesamiento de interrupciones

3. restrict (optimización de punteros)

Ejemplo de uso de restrict

#include 

void add_arrays(int *restrict a, int *restrict b, int *restrict result, int size) {
    for (int i = 0; i < size; i++) {
        result[i] = a[i] + b[i];
    }
}

• Optimización de operaciones con punteros
• Mejora del rendimiento en cálculos numéricos
• Operaciones vectoriales (optimización SIMD)

4. signed y unsigned (enteros con signo y sin signo)

Ejemplo de uso de signed (entero con signo)

int a = -10;  // Posible almacenar valores negativos
printf("%d\n", a);  // Salida: -10

Ejemplo de uso de unsigned (entero sin signo)

unsigned int b = 250;
printf("%u\n", b);  // Salida: 250

unsigned int c = -10;  // ¡Error! No se puede almacenar valores negativos

• Contadores sin valores negativos (variables de bucle, etc.)
• Procesamiento de datos binarios (operaciones de bits)
• Uso efectivo del tamaño de memoria

int x = -1;
unsigned int y = x;  // Error o resultado no intencionado

Resumen

7. Conversión de tipos (cast)

¿Qué es la conversión de tipos?

1. Conversión implícita (conversión automática)

Reglas de la conversión implícita

• De tipo de datos pequeño → tipo de datos grande se convierte automáticamente
• De tipo entero → tipo de punto flotante se convierte
• char → int (tratado como código ASCII)

Ejemplo de conversión implícita

#include 

int main() {
    int a = 10;
    float b = a;  // conversión automática de int a float
    printf("b: %.2f\n", b);  // Salida: b: 10.00

    char letter = 'A';
    int asciiValue = letter;  // conversión de char a int (código ASCII)
    printf("ASCII value of A: %d\n", asciiValue);  // Salida: ASCII value of A: 65

    return 0;
}

2. Conversión explícita (cast)

Sintaxis básica del cast

(tipo de datos después de la conversión) valor o variable

Ejemplo de uso del cast

#include 

int main() {
    int a = 10, b = 3;
    float result = (float)a / b;  // convertir int a float
    printf("Result: %.2f\n", result);  // Salida: Result: 3.33

    return 0;
}

3. Casos en los que se necesita cast

(1) División entre enteros

int a = 5, b = 2;
float result = a / b;  // el resultado es 2 (permanece como entero)
float correctResult = (float)a / b;  // correctamente se convierte en 2.5

(2) Punto flotante → entero (truncado de la parte decimal)

float pi = 3.14159;
int truncatedPi = (int)pi;  // se convierte en 3 (parte decimal truncada)

(3) char → int (convertir carácter a código ASCII)

char letter = 'B';
int ascii = (int)letter;
printf("ASCII Code: %d\n", ascii);  // Salida: ASCII Code: 66

(4) Cast desde void * (punteros)

void *ptr;
int num = 10;
ptr = #

int *intPtr = (int *)ptr;  // cast de void * a int *
printf("Value: %d\n", *intPtr);  // Salida: Value: 10

4. Puntos de atención en la conversión de tipos

(1) Se pierde precisión en los datos

float num = 3.9;
int rounded = (int)num;  // Resultado: 3 (parte decimal truncada)

#include 
int rounded = round(num);  // se convierte en 4

(2) Atención en la conversión entre unsigned y signed

unsigned int x = -1;
printf("%u\n", x);  // Salida: 4294967295 (entorno de 32 bits)

(3) Conversión de tipo grande a tipo pequeño (peligro de overflow)

long bigNum = 100000;
short smallNum = (short)bigNum;  // Posibilidad de que los datos no se almacenen correctamente

printf("Size of short: %lu bytes\n", sizeof(short));

Resumen

8. Alcance y duración de las variables

¿Qué es el alcance de las variables (rango efectivo)?

Tipos de alcance de variables en C

1. Variables locales (Local Variables)

Ejemplo de uso de variables locales

#include 

void myFunction() {
    int localVar = 10;  // Variable local
    printf("Variable local: %d\n", localVar);
}

int main() {
    myFunction();
    // printf("%d", localVar);  // ¡Error! No se puede acceder a las variables locales desde fuera de la función
    return 0;
}

• Se puede prevenir la influencia entre funciones (alta seguridad)
• Ahorro de memoria (se libera automáticamente al finalizar la función)

• No accesible desde fuera de la función
• Se inicializa cada vez que se llama la función (los datos no se mantienen)

2. Variables globales (Global Variables)

Ejemplo de uso de variables globales

#include 

int globalVar = 100;  // Variable global

void myFunction() {
    printf("Variable global: %d\n", globalVar);
}

int main() {
    myFunction();
    globalVar = 200;  // Se puede modificar desde cualquier lugar
    printf("Variable global actualizada: %d\n", globalVar);
    return 0;
}

• Se puede mantener el valor en todo el programa
• Se pueden compartir datos entre múltiples funciones

• Posibilidad de cambios no intencionales (causa de errores)
• Mantiene ocupada la memoria
• Dificulta la modularización

3. Variables estáticas (Static Variables)

Ejemplo de uso de static (manteniendo variable local)

#include 

void counter() {
    static int count = 0;  // static para mantener el valor
    count++;
    printf("Conteo: %d\n", count);
}

int main() {
    counter();  // Salida: Conteo: 1
    counter();  // Salida: Conteo: 2
    counter();  // Salida: Conteo: 3
    return 0;
}

• Mantiene el valor cada vez que se llama la función
• Gestión de memoria sencilla

• No libera la memoria hasta que termina el programa

Ejemplo de uso de static (restringiendo variable global)

static int fileVar = 100;  // Solo efectiva en este archivo

4. Variables externas (Extern)

Ejemplo de uso de extern

file1.c

#include 

int sharedVar = 50;  // Variable global

void printSharedVar() {
    printf("Variable compartida: %d\n", sharedVar);
}

file2.c

#include 

extern int sharedVar;  // Referenciando la variable de file1.c

int main() {
    printf("Accediendo a sharedVar: %d\n", sharedVar);
    return 0;
}

• Se pueden utilizar variables de otros archivos

• Se fortalece la dependencia, por lo que disminuye la mantenibilidad

5. Duración de las variables (Lifetime)

Resumen

9. Cómo seleccionar tipos de datos de manera práctica

Razón por la que la selección de tipos de datos es importante

1. Cuando se desea ahorrar memoria

Tamaño de memoria de enteros y cómo elegirlos

Ejemplo de ahorro de memoria

short temperature;  // Para ahorrar memoria, usar short

2. Cuando se necesita precisión

Cómo elegir puntos flotantes

Ejemplo para asegurar precisión

double distance = 1234567.1234567;  // Cuando se necesita cálculo de alta precisión

3. Cuando no se manejan valores negativos

Ejemplo cuando no se manejan valores negativos

unsigned int score = 250;

int x = -1;
unsigned int y = x;  // Se produce un error o un resultado no intencionado

4. Tipo de datos adecuado para contadores de bucles

for (unsigned int i = 0; i < 1000; i++) {
    // Procesamiento del bucle
}

5. Cuando se manejan caracteres

char letter = 'A';   // Solo un carácter
char str[] = "Hello";  // Cadena

6. Hacer el código más comprensible con tipos enumerados

enum Color { RED, GREEN, BLUE };

enum Color favoriteColor = GREEN;

7. Gestionar memoria de manera flexible usando punteros

int num = 10;
int *ptr = #
printf("Valor: %d\n", *ptr);  // 10

8. Cómo elegir el tipo de datos óptimo (resumen)

• Si se necesita ahorrar memoria, usar short o char
• Si se necesita precisión, elegir double
• Si no se necesitan valores negativos, aprovechar unsigned
• Para mejorar la legibilidad, aprovechar enum
• Al aprovechar punteros, es posible una gestión flexible de memoria