Tema 2: Lenguajes de programación

Tipos de datos y operadores

Todo programa manipula datos almacenados en variables. El tipo de dato determina qué valores puede contener una variable, cuánta memoria ocupa y qué operaciones admite. Los tipos se dividen en primitivos (átomos que proporciona el propio lenguaje) y compuestos o estructurados (arrays/vectores, registros, objetos), que se construyen a partir de los primeros.

Tipos de datos primitivos en Java

Java define exactamente ocho tipos primitivos, identificados por palabras reservadas. Su tamaño es fijo e independiente de la plataforma:

Puntos que conviene fijar: para representar un short se necesitan 16 bits y para un int, 32 bits (es INCORRECTO afirmar lo contrario, es decir, que short use 32 y int 16). Un long requiere 64 bits y un double también 64 bits. Palabras como simple NO son tipos primitivos de Java. Tampoco lo son los arrays (vectores) ni String: son tipos de referencia/compuestos, aunque String reciba soporte especial del lenguaje.

Tipos en Python, PHP y Kotlin

En Python, los números enteros se representan con el tipo integrado int. La función hex() convierte un número decimal en su representación hexadecimal (cadena con prefijo 0x); análogamente bin() da binario y oct() octal. Python sobrecarga operadores sobre cadenas: la multiplicación repite la cadena y el + la concatena. Así, print("Java"*4+"Linux") imprime JavaJavaJavaJavaLinux (cuatro repeticiones de "Java" seguidas de "Linux").

En PHP, todas las variables comienzan con el símbolo $ (por ejemplo $edad = 25;); PHP es de tipado dinámico y no exige declarar el tipo por adelantado.

Kotlin introduce la seguridad de nulos (null safety): el sistema de tipos distingue entre referencias que pueden ser nulas (String?) y las que no (String), evitando en tiempo de compilación los errores de ejecución habituales por referencias nulas (NullPointerException).

Clasificación de operadores

Los operadores combinan valores (operandos) para producir un resultado. Las categorías presentes en la mayoría de lenguajes son:

• Operadores aritméticos: realizan operaciones matemáticas (+, -, *, /, % módulo).

• Operadores relacionales (o de comparación): comparan dos valores y devuelven un booleano (==, !=, <, >, <=, >=).

• Operadores de asignación: asignan un valor a una variable (=, y compuestos +=, -=…).

• Operadores lógicos: && (Y), || (O), ! (NO), con evaluación de cortocircuito.

• Operadores de incremento/decremento: ++ y --.

Operador ternario y precedencia

El operador condicional condición ? valor_si_verdadero : valor_si_falso evalúa una expresión booleana. Por ejemplo, en JavaScript con a = 10, b = 4, c = 4: la expresión (a + b) % 2 == 0 ? c + 4 : c - 2 calcula (14) % 2 == 0, que es verdadero, y devuelve c + 4 = 8.

Expresiones lógicas: evaluación paso a paso

Las expresiones booleanas combinan relacionales y lógicos. Ejemplos resueltos:

• ((a>=b) && !(c>a)) || (!(d>a)) con a=3, b=3, d=5: a>=b es cierto y !(d>a) es falso; la expresión es cierta cuando !(c>a) lo sea, esto es, cuando c NO sea mayor que 3. Con c=1 devuelve true.

• ((a>b) && !(c>a)) || (!(d>a) && (c<d)): la combinación a=2, b=6, c=6, d=2 da false en ambos términos (ni a>b ni c<d), luego NO devuelve true.

• ((a<b) && (c>a)) || (!(d>a) && (c>a)) con b=2, d=8: con a=1, c=2 el primer término (1<2 y 2>1) es cierto y devuelve true.

Incremento y decremento en C: prefijo vs. sufijo

En C (ANSI/ISO C) los operadores ++ y -- tienen dos formas con semántica distinta al usarse dentro de una asignación:

• Prefijo (--x, ++x): primero modifica la variable y luego entrega el valor ya modificado.

• Sufijo (x++, x--): entrega el valor actual y DESPUÉS modifica la variable.

Ejemplos verificados:

Una simple asignación directa copia el valor sin modificarlo: a = 4; b = a; deja ambos a 4; a = 12; b = a; deja ambos a 12. Y el mero y++; como sentencia aislada incrementa y (de 3 a 4) sin alterar x (que sigue en 5).

Secuencias de escape en C

Dentro de literales de cadena, la barra invertida \ inicia una secuencia de escape que representa un carácter de control:

Así, \r hace un retorno de carro, \b realiza un retroceso y \v se usa para la tabulación vertical.

Estructuras de datos compuestas

A partir de los primitivos se forman los vectores (arrays) —colecciones indexadas de elementos del mismo tipo— y los registros (structs) —agrupaciones de campos de tipos posiblemente distintos—. Estos NO son tipos primitivos, sino estructurados.

Fuentes

• Oracle — The Java Tutorials, «Primitive Data Types»: https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

• Microsoft Learn — «Escape Sequences» (C language): https://learn.microsoft.com/en-us/cpp/c-language/escape-sequences

• Python 3 — «Built-in Functions» (hex, bin, int): https://docs.python.org/3/library/functions.html

• Python 3 — «Built-in Types» (str, int): https://docs.python.org/3/library/stdtypes.html

• PHP Manual — «Variables Basics»: https://www.php.net/manual/es/language.variables.basics.php

• Kotlin — «Null safety»: https://kotlinlang.org/docs/null-safety.html

Estructuras de control

Las estructuras de control determinan el flujo de ejecución de un programa. Se clasifican en tres grandes familias: secuenciales (las instrucciones se ejecutan una tras otra), condicionales o de selección (se ejecuta un bloque u otro según una condición) y repetitivas o iterativas (un bloque se repite mientras se cumpla una condición). A partir de estas, junto con la recursividad, se construye cualquier algoritmo.

Estructuras condicionales (selección)

La selección permite ejecutar código solo cuando se cumple una condición lógica.

• En Python, la palabra clave para definir una condición es if; para especificar la acción alternativa cuando la condición no se cumple se usa else (y elif para condiciones encadenadas). Así, if selecciona el bloque cuando la expresión es verdadera y else cuando es falsa.

• La estructura switch-case (en C, C++, Java) compara una expresión contra varios valores (case). Sobre ella conviene precisar: la cláusula default NO es obligatoria; es opcional y solo se ejecuta cuando ningún case coincide. Por tanto, es falso afirmar que "es obligatorio meter siempre la opción default, si no el bucle no funcionaría" (además switch no es un bucle, sino una selección múltiple).

Estructuras repetitivas (bucles)

Un bucle repite un bloque de sentencias mientras su expresión de control sea verdadera. Es imprescindible que dentro del bloque existan sentencias que modifiquen la evaluación de la expresión (por ejemplo, incrementar un contador); de lo contrario, la condición nunca cambia y se produce un bucle infinito. Una solución iterativa termina cuando se incumple la condición de continuación del bucle.

Bucle while

Evalúa la expresión antes de ejecutar el bloque. Por tanto:

• Primero evalúa la expresión; si es verdadera, ejecuta el bloque y vuelve a evaluar.

• Si la expresión es false, se sale del bucle (puede no ejecutarse ninguna vez).

Ejemplo de bucle infinito: integer x=0; while x<100 do (x=x+1; print x; x=x-1;) es un bucle infinito, porque x se incrementa y decrementa en cada iteración y su valor final vuelve a 0, de modo que la condición x<100 nunca deja de cumplirse.

Bucle do-while

Evalúa la expresión después de ejecutar el bloque. Su sintaxis es:

Su característica esencial es que se ejecuta al menos una vez antes de comprobar la condición. Por eso, tanto en Java como en C++, la estructura de control que siempre se ejecuta como mínimo una vez es do... while. La diferencia clave entre do-while y while es que do-while evalúa la expresión después de ejecutar el bloque, mientras que while la evalúa antes.

Bucle for

Se usa para iterar un número fijo de veces. Consta de tres partes: inicialización, condición y actualización. La variable que cuenta las iteraciones se denomina variable de control (o contador). En C, C++ y Java, los tres elementos del for son opcionales: for(;;) es válido y produce un bucle infinito.

Traza de ejemplo (Java):

System.out.println(i);

j++;

}

Se imprime 4 veces y la salida es 10 8 5 1 (10851).

Instrucciones break y continue

Dentro de un bucle: break detiene (termina) el bucle por completo y cede el control a la instrucción siguiente; continue salta a la siguiente iteración, omitiendo el resto del bloque en esa vuelta. En C++, la forma de salir de un bucle es mediante la instrucción break.

Variable centinela

Una variable centinela es una variable que se usa para indicar el final de un proceso o de una secuencia. Permite terminar un bucle cuando se detecta un valor especial (el centinela) en lugar de un contador fijo.

Recursividad

La recursividad es una técnica de programación en la que una función se llama a sí misma en su propia definición. Un problema recursivo se divide en instancias más pequeñas del mismo problema; la inducción en la recursividad consiste en suponer que las instancias más pequeñas quedan resueltas para construir, a partir de ellas, la solución del caso general.

Toda función recursiva necesita:

• Un caso base (o condición de salida): es esencial para evitar un bucle/llamada infinita y detener la recursión.

• Un paso recursivo que reduzca el problema hacia el caso base.

Ejemplo de función recursiva en Java:

else return n + suma(n - 1);

}

Recursividad y pila de llamadas

En cada llamada recursiva se reserva un marco (frame) en la pila, donde se almacena la información imprescindible para continuar la ejecución: los parámetros y variables locales, la dirección de retorno y el estado de la llamada. NO es imprescindible almacenar el número de orden de la iteración (ese es un concepto propio de la iteración, no de la recursión). En la búsqueda binaria, la implementación recursiva es menos eficiente en memoria que la iterativa porque requiere almacenar las variables en cada llamada apiladas.

Recursividad frente a iteración

La principal diferencia es que la recursividad utiliza funciones que se llaman a sí mismas, mientras que la iteración utiliza bucles. La recursividad suele ser preferible en problemas que pueden descomponerse en subproblemas similares y más pequeños; es la base de los algoritmos de divide y vencerás (división y conquista), cuyo objetivo es simplificar un problema complejo en subproblemas más pequeños mediante recursión.

Fuentes

• Oracle, The Java Tutorials — The while and do-while Statements: https://docs.oracle.com/javase/tutorial/java/nutsandbolts/while.html

• Oracle, The Java Tutorials — The for Statement: https://docs.oracle.com/javase/tutorial/java/nutsandbolts/for.html

• Oracle, The Java Tutorials — Branching Statements (break, continue): https://docs.oracle.com/javase/tutorial/java/nutsandbolts/branch.html

• Python Software Foundation, The Python Language Reference — Compound statements (if / elif / else): https://docs.python.org/3/reference/compound_stmts.html

• cppreference, do-while loop (C++): https://en.cppreference.com/w/cpp/language/do

• cppreference, for loop (C++): https://en.cppreference.com/w/cpp/language/for

• cppreference, switch statement (C++): https://en.cppreference.com/w/cpp/language/switch

Procedimientos, funciones y parámetros

La modularidad es un principio básico de la programación estructurada: en lugar de escribir todo el código en un único bloque, se descompone el problema en subrutinas (subprogramas) que resuelven tareas concretas. El principal beneficio de emplear procedimientos y funciones frente a un bloque monolítico es que facilita la comprensión, el mantenimiento y la reutilización del código, además de reducir la duplicación y aislar los errores.

Procedimientos frente a funciones

Un procedimiento es una subrutina que realiza una tarea específica y que puede definirse mediante cero, uno o "n" parámetros. Una función es también una subrutina, pero su rasgo distintivo es el valor de retorno.

• La principal diferencia entre ambos es que las funciones siempre retornan un valor, mientras que los procedimientos no devuelven ningún valor (se ejecutan por sus efectos).

Ambos comparten propiedades esenciales que conviene tener claras para descartar afirmaciones falsas de tipo test:

• Una función puede ser invocada desde módulos distintos de aquel donde se ha definido (según su ámbito y visibilidad). Por tanto, afirmar que "la función solo puede ser invocada desde el módulo donde se ha definido" es una definición INCORRECTA.

Parámetros: formales y reales

Los parámetros son el mecanismo por el que un subprograma se comunica con el código que lo llama. Su propósito es proporcionar valores de entrada a procedimientos y funciones (y, según el modo de paso, también devolver resultados).

• El parámetro formal es el nombre del parámetro tal y como aparece en la cabecera (declaración) de un método, función o constructor. Es una variable local del subprograma.

• El parámetro real (o argumento) es el valor o variable concreta que se pasa en el momento de la llamada.

Paso de parámetros: por valor y por referencia

Existen dos modos fundamentales de paso de parámetros:

Cuando se pasa una variable por valor, la información se almacena en una dirección de memoria distinta que la variable original; el subprograma trabaja sobre la copia. Por ello:

• Los parámetros por referencia se pueden emplear como parámetros de entrada/salida (E/S), ya que permiten tanto recibir un dato como devolver el resultado modificado al llamante.

• Es INCORRECTO afirmar que, al recibir una variable por referencia, la modificación "solo afectará dentro del contexto de dicho procedimiento": precisamente por referencia la modificación trasciende al contexto del llamante (eso es lo propio del paso por valor).

Ámbito de variables y el operador de resolución de ámbito en C++

En C++ conviven variables globales (declaradas fuera de toda función) y variables locales (declaradas dentro de un bloque). Cuando una variable local oculta (shadowing) a una global con el mismo nombre, dentro del bloque el identificador se refiere a la local.

Para mostrar valores por pantalla se usa el flujo de salida std::cout con el operador de inserción <<. Considérese:

/*sentencia*/ return 0;

}

• Para mostrar el valor de la variable local basta con nombrarla directamente: cout << a << endl; (imprime 12).

• Para mostrar el valor de la variable global ocultada se usa el operador de resolución de ámbito :: con prefijo vacío (ámbito global): cout << ::a << endl; (imprime 4). Análogamente, si la global vale 2 y la local 10, cout << ::a << endl; muestra 2 y cout << a << endl; muestra 10.

Sobrecarga de funciones (function overloading)

C++ permite especificar más de una función con el mismo nombre en el mismo ámbito, siempre que difieran en su lista de parámetros (número o tipos). Estas se denominan funciones sobrecargadas. El compilador selecciona la versión adecuada según los argumentos de la llamada (resolución de sobrecarga). La sobrecarga mejora la legibilidad al usar un mismo nombre semántico para operaciones análogas sobre distintos tipos.

Funciones de extensión en Kotlin

Kotlin ofrece las extensiones (extension functions y extension properties), que permiten añadir funcionalidad a clases ya existentes sin necesidad de modificar su código fuente ni recurrir a la herencia o al patrón Decorator. Se declaran anteponiendo el tipo receptor al nombre de la función (por ejemplo fun String.miFuncion()), y a partir de ahí se invocan como si fueran miembros de la clase original.

Su principal beneficio frente a heredar de una clase es que no modifica la jerarquía de clases: las extensiones se resuelven estáticamente y no alteran la estructura ni el árbol de herencia de la clase extendida, lo que las hace idóneas para trabajar con bibliotecas de terceros que no se pueden modificar.

Funciones predefinidas en PHP

PHP incorpora numerosas funciones de biblioteca. Dos habituales en los exámenes:

• strlen() devuelve la longitud (número de bytes) de una cadena. Ejemplo: strlen("hola") retorna 4.

• mysqli_connect() abre una conexión a una base de datos MySQL. Es la función procedimental de la extensión mysqli utilizada en PHP (incluida PHP 8) para conectar con el servidor; devuelve un objeto que representa la conexión, o false en caso de fallo.

Fuentes

• Kotlin. Extensions — Documentación oficial de Kotlin. https://kotlinlang.org/docs/extensions.html

• PHP. strlen — Manual (php.net). https://www.php.net/manual/en/function.strlen.php

• PHP. mysqli_connect — Manual (php.net). https://www.php.net/manual/en/function.mysqli-connect.php

• cppreference / ISO C++. Scope resolution operator (::) y Overload resolution. https://en.cppreference.com/w/cpp/language/scope

• cppreference. std::cout / basic_ostream operator<<. https://en.cppreference.com/w/cpp/io/cout

Estructuras de datos y estructura de un programa

En programación, los datos se organizan mediante estructuras de datos, que se clasifican según cómo se relacionan sus elementos y según si su tamaño puede variar en tiempo de ejecución.

Vectores (arrays) frente a registros

Un vector o array es un tipo de dato estructurado que permite almacenar un conjunto de datos homogéneo (todos los elementos del mismo tipo), donde cada elemento se almacena de forma consecutiva en memoria y se accede a él mediante un índice. En cambio, un registro (record/struct) es una estructura que agrupa datos de diferentes tipos bajo un mismo identificador, cada uno en un campo o atributo con su propio nombre.

• Diferencia clave: un registro agrupa datos de diferentes tipos y un vector de un único tipo. Los arrays solo pueden almacenar datos de un mismo tipo; los registros permiten almacenar tipos distintos.

• El registro es la estructura idónea para representar entidades compuestas por atributos de diferentes tipos (por ejemplo, una persona con nombre, edad y salario).

Los vectores pueden ser estáticos y dinámicos. Un vector estático tiene un número fijo de elementos determinado en su declaración (es incorrecto afirmar que está constituido por un número variable de elementos); un vector dinámico puede ajustar su tamaño en ejecución.

Estructuras lineales y no lineales; estáticas y dinámicas

• Lineales: los elementos se disponen en secuencia (vectores, listas, pilas, colas).

• No lineales: un elemento puede relacionarse con varios (árboles y grafos).

Entre las estructuras dinámicas y no lineales:

• Árbol: estructura jerárquica compuesta por nodos que pueden tener cero o más nodos hijos. Es la estructura habitual para representar jerarquías, como el sistema de archivos de un sistema operativo. Un árbol es un caso particular de grafo (conexo y sin ciclos).

• Grafo: conjunto de nodos conectados por aristas, sin restricción jerárquica; es también un tipo de dato dinámico no lineal.

Lenguajes compilados frente a interpretados

La principal diferencia radica en cómo se traduce el código fuente a instrucciones ejecutables:

• Un lenguaje compilado usa un compilador para traducir todas las instrucciones antes de la ejecución y generar el programa ejecutable. Es incorrecto decir que sus implementaciones son ejecutores paso a paso del código fuente sin traducción previa.

• Un lenguaje interpretado requiere de un intérprete que traduce el código al momento de la ejecución, instrucción a instrucción.

Ejemplos típicamente compilados: C, C++. Interpretados o de ejecución en máquina virtual: Python, PHP, Ruby, Java (compila a bytecode).

Bytecode

El bytecode es un código intermedio, portable, generado por el compilador (por ejemplo, de Java) y ejecutado por una máquina virtual. En bytecode, cada código de operación (opcode) tiene una longitud fija de un byte, de ahí su nombre; a él le pueden seguir cero o más operandos. Al ser un byte, el conjunto no puede superar 256 opcodes distintos.

Paradigmas de programación

• Imperativa: describe cómo resolver el problema mediante secuencias de instrucciones que modifican el estado (C, C++, Java...). Prolog NO es imperativo.

• Declarativa: describe qué se quiere obtener, no el procedimiento. Son declarativos Prolog, Maude, SQL, Erlang, Haskell y Lisp.

• Orientada a objetos (POO): organiza el software en objetos con estado y comportamiento. Son orientados a objetos, entre otros, Ada 95, C#, C++, Eiffel, Vala, Python, Simula, Smalltalk y Visual Basic 6.0. Ruby tiene un enfoque principalmente orientado a objetos, con una sintaxis simple y legible, y gran cantidad de librerías disponibles.

Panorama de lenguajes

Detalles de sintaxis relevantes

Python ofrece estructuras integradas como list (mutable), y construcciones expresivas: list comprehension para generar una lista aplicando una expresión a cada elemento, y dictionary comprehension para crear diccionarios a partir de claves y valores. El método split() divide una cadena en una lista de subcadenas según un delimitador. NumPy es una biblioteca de cálculo numérico, no de procesamiento de imágenes (a diferencia de PIL/Pillow, OpenCV o scikit-image).

Lenguaje C: las directivas de preprocesador se distinguen por el carácter # (p. ej. #include, #define). Un programa en C puede estar formado por varios módulos o fuentes que se compilan de forma separada y luego se enlazan. La función no estándar gotoxy se encuentra en la librería conio.h.

Lenguaje C++: para usar funciones de entrada/salida se incluye la cabecera iostream. C++ no dispone de una instrucción forEach() como tal (sí existe el algoritmo std::for_each y el bucle range-based for).

Java: un array se declara, por ejemplo, como int[] enteros;. Para recorrer una matriz float[] SaldoMensual = new float[12] se usa un bucle como for(int i=0;i<12;i++) System.out.println(SaldoMensual[i]);. (Nota: Drupal es un CMS escrito en PHP, no requiere una máquina virtual Java, por lo que esa afirmación es falsa.)

Fuentes

• ECMA International — Standard ECMA-334 (C# Language Specification): https://ecma-international.org/publications-and-standards/standards/ecma-334/

• Microsoft Learn — Ecma standards for .NET (ECMA-334 / ISO/IEC 23270): https://learn.microsoft.com/en-us/dotnet/fundamentals/standards

• Oracle — The Java Virtual Machine Specification, Chapter 6: The Java Virtual Machine Instruction Set: https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-6.html

• Python Software Foundation — Data Structures / Built-in Types: https://docs.python.org/3/tutorial/datastructures.html

• ISO/IEC — Publicly Available Standards (ISO/IEC 23270 C#): https://standards.iso.org/