Ver esquema

Tema 16. Lenguajes de programación. Representación de tipos de datos. Operadores. Instrucciones condicionales. Bucles y recursividad. Procedimientos, funciones y parámetros. Vectores y registros. Estructura de un programa.

Cuerpo de Técnicos Auxiliares de Informática de la Administración del Estado (C1), ingreso libre — Resolución de 9 de julio de 2024, de la Secretaría de Estado de Función Pública (1.879 plazas de ingreso libre) · Índice oficial del BOE núm. 166, de 10 de julio de 2024, páginas 86740 a 86827: Resolución de 9 de julio de 2024, de la Secretaría de Estado de Función Pública, por la que se convocan procesos selectivos para el ingreso y el acceso en Cuerpos de la Administración General del Estado (identificador oficial BOE-A-2024-14098), Anexo V — Cuerpo de Técnicos Auxiliares de Informática de la Administración del Estado (código de cuerpo 1188), ingreso libre, páginas 86775-86776 (requisitos y estructura de la prueba) y 86803-86807 (programa/temario). Verificado por lectura directa del PDF oficial del BOE (el PDF de 2024 lleva texto extraíble, no es un escaneo): los 33 temas y sus títulos literales de este fichero coinciden con el Anexo V real..

Cuerpo de Técnicos Auxiliares de Informática de la Administración del Estado (Grupo C, Subgrupo C1), turno de acceso libre. NO debe confundirse con el temario ya existente en este catálogo bajo el id 'informatica' (Cuerpo Superior de Sistemas y Tecnologías de la Información / Cuerpo de Gestión de Sistemas de Informática, grados A1/A2): son tres cuerpos TIC distintos de la AGE regulados en la misma Resolución de 9 de julio de 2024 (Anexos separados), con temarios propios y no intercambiables — este fichero cubre exclusivamente el cuerpo AUXILIAR (C1). No cubre el turno de promoción interna (temario distinto y más corto, Anexo separado del mismo Cuerpo). La Oferta de Empleo Público 2025 (BOE núm. 170, de 15 de julio de 2025) aprobó 900 plazas adicionales de ingreso libre para este mismo Cuerpo pendientes de una nueva convocatoria a fecha de redacción de este fichero; previsiblemente reutilizará el mismo programa de 34 temas, pero eso debe confirmarse cuando esa convocatoria se publique.

Un lenguaje de programación es el conjunto de reglas sintácticas y semánticas que permite a una persona expresar un algoritmo de forma que pueda ejecutarlo un ordenador. Este tema recorre los elementos comunes a la práctica totalidad de los lenguajes de programación imperativos, con independencia del lenguaje concreto en que se materialicen: la representación de los tipos de datos, los operadores disponibles, las estructuras de control condicionales y repetitivas (incluida la recursividad como alternativa a la iteración), la modularización del código en procedimientos y funciones con paso de parámetros, las estructuras de datos básicas de vectores y registros, y la organización general de un programa.

← Ver el índice completo del temario

Clasificación de los lenguajes de programación

Los lenguajes de programación pueden clasificarse conforme a distintos criterios. Según su cercanía al hardware se distingue entre lenguajes de bajo nivel (el lenguaje máquina, propio de cada procesador, y el ensamblador, que lo representa mediante mnemotécnicos) y lenguajes de alto nivel, más cercanos al lenguaje natural y por tanto independientes del hardware concreto. Según cómo se traduce el código fuente a código ejecutable se distingue entre lenguajes compilados, cuyo código fuente se traduce por completo a código máquina antes de ejecutarse mediante un compilador, y lenguajes interpretados, cuyas instrucciones son leídas y ejecutadas una a una por un intérprete en tiempo de ejecución (existiendo también soluciones intermedias, como la compilación a un código intermedio o bytecode que después ejecuta una máquina virtual, como ocurre en Java, o la compilación en tiempo de ejecución JIT). Según el paradigma de programación que promueven se distingue, entre otros, entre lenguajes imperativos o procedimentales (C, Pascal), orientados a objetos (Java, C#, C++), funcionales (Haskell, Lisp) y declarativos o lógicos (SQL, Prolog); muchos lenguajes actuales son multiparadigma. La programación estructurada, base de los lenguajes imperativos modernos, se apoya en tres estructuras de control: secuencia, selección e iteración, evitando el salto incondicional (goto).

Proceso de traducción de un programa

El compilador traduce el código fuente en varias etapas: el análisis léxico agrupa los caracteres en componentes léxicos o tokens (identificadores, palabras reservadas, literales, operadores); el análisis sintáctico comprueba que la secuencia de tokens respeta la gramática del lenguaje y construye un árbol sintáctico; el análisis semántico verifica la coherencia (por ejemplo, la compatibilidad de tipos y la declaración previa de las variables); y la generación de código produce el código objeto, a menudo tras una fase de optimización. El enlazador (linker) combina uno o varios módulos objeto y bibliotecas en un programa ejecutable, y el cargador lo sitúa en memoria para su ejecución. Los errores se clasifican en errores de compilación (léxicos, sintácticos y semánticos), detectados antes de ejecutar; errores de ejecución, que se producen al ejecutar el programa (por ejemplo, una división por cero); y errores lógicos, en los que el programa se ejecuta pero no hace lo que se pretendía y que solo se detectan mediante pruebas y depuración.

Representación de los tipos de datos

Los tipos de datos determinan el conjunto de valores que puede tomar una variable y las operaciones que se pueden realizar sobre ella. Se distinguen habitualmente los tipos de datos simples o primitivos, que representan un único valor indivisible —numéricos (enteros y de coma flotante), lógicos o booleanos (verdadero/falso) y de carácter—, de los tipos de datos estructurados o compuestos, que agrupan varios valores, simples o a su vez estructurados, bajo un mismo identificador, como los vectores, los registros o las cadenas de caracteres. En cuanto a su representación interna, los enteros sin signo se codifican en binario natural; los enteros con signo suelen emplear el complemento a dos, que permite representar, con n bits, valores desde -2^(n-1) hasta 2^(n-1)-1 y simplifica la suma y la resta; los números reales se almacenan en coma flotante, normalmente según el estándar IEEE 754 (signo, exponente y mantisa), con precisión limitada que provoca errores de redondeo (por ejemplo, 0,1 no tiene representación binaria exacta); los caracteres se codifican mediante tablas como ASCII (7 bits) o Unicode, con codificaciones como UTF-8, de longitud variable; y los booleanos se representan con un bit lógico, aunque se almacenen en un byte o palabra. El desbordamiento (overflow) se produce cuando el resultado de una operación excede el rango representable. Respecto al sistema de tipos, en el tipado estático los tipos de las variables y expresiones se conocen y comprueban en tiempo de compilación (por declaración explícita del programador o por inferencia del compilador), mientras que en el tipado dinámico los tipos están asociados a los valores y se comprueban en tiempo de ejecución, sin necesidad de declararlos; un lenguaje fuertemente tipado limita las conversiones implícitas entre tipos. Las conversiones pueden ser implícitas (coerción) o explícitas (casting).

Operadores y expresiones

Los operadores permiten construir expresiones combinando variables, constantes y llamadas a funciones. Los operadores aritméticos realizan operaciones matemáticas (suma, resta, multiplicación, división, módulo o resto; en muchos lenguajes la división entre enteros devuelve un cociente entero); los operadores relacionales comparan dos valores y devuelven un resultado lógico (igual, distinto, mayor, menor, mayor o igual, menor o igual); los operadores lógicos combinan o niegan valores booleanos (conjunción Y, disyunción O, negación NO); los operadores de asignación asignan el resultado de una expresión a una variable (con variantes compuestas como += en lenguajes de la familia C); y los operadores a nivel de bit (AND, OR, XOR, NOT y desplazamientos) actúan sobre la representación binaria. Cuando una expresión combina varios operadores, su evaluación se rige por reglas de precedencia (qué operador se aplica antes; habitualmente, de mayor a menor: paréntesis, negación, multiplicación/división/módulo, suma/resta, relacionales y, por último, lógicos) y de asociatividad (en qué orden se agrupan operadores de igual precedencia, normalmente de izquierda a derecha), que pueden alterarse explícitamente mediante el uso de paréntesis. Muchos lenguajes emplean evaluación en cortocircuito en los operadores lógicos: en una conjunción, si el primer operando es falso no se evalúa el segundo; en una disyunción, si el primero es verdadero tampoco. Conviene no confundir el operador de asignación (=) con el de igualdad (== en la familia C, o = en Pascal).

Instrucciones condicionales

Las instrucciones condicionales permiten que un programa ejecute distintos bloques de código según se cumpla o no una determinada condición, rompiendo la ejecución puramente secuencial de las instrucciones. La instrucción condicional simple (si... entonces) ejecuta un bloque de código solo cuando la condición evaluada es verdadera; la instrucción condicional doble (si... entonces... si no) añade un bloque alternativo que se ejecuta cuando la condición es falsa; y las estructuras de selección múltiple (según el valor de... caso; switch en la familia C), habituales cuando hay que comparar una misma variable con varios valores posibles, permiten evitar el anidamiento sucesivo de varias instrucciones condicionales simples. Las condiciones pueden anidarse (un condicional dentro de otro) y encadenarse (si... si no, si...). En C, Java y lenguajes similares, la instrucción switch ejecuta a partir de la etiqueta coincidente y continúa en las siguientes si no se interrumpe con break, error muy frecuente. Existe también el operador condicional ternario (condición ? valor1 : valor2), que devuelve un valor u otro según la condición.

Bucles

Las instrucciones repetitivas o bucles permiten ejecutar un mismo bloque de código varias veces mientras se cumpla una condición. El bucle mientras (while) comprueba la condición antes de cada repetición, por lo que puede no llegar a ejecutarse ninguna vez; el bucle repetir... hasta (do-while) la comprueba después de cada repetición, garantizando al menos una ejecución (nótese que en pseudocódigo 'repetir... hasta' termina cuando la condición se hace verdadera, mientras que 'do... while' continúa mientras la condición sea verdadera); y el bucle para (for) se emplea típicamente cuando se conoce de antemano el número de repeticiones, incorporando de forma compacta la inicialización, la condición de continuidad y el incremento de una variable de control. Un bucle sin condición de salida alcanzable es un bucle infinito. Las instrucciones break y continue (en los lenguajes que las ofrecen) permiten abandonar un bucle o saltar a la siguiente iteración. Todo bucle debe tener cuidado con los errores por uno (off-by-one) en los límites y con la correcta actualización de la variable de control. Cualquier bucle puede expresarse con los demás, y también mediante recursividad.

Recursividad

La recursividad es una técnica alternativa a la iteración en la que una función se llama a sí misma para resolver un problema descomponiéndolo en subproblemas más pequeños del mismo tipo; toda función recursiva bien construida necesita un caso base, que detiene las llamadas sucesivas sin realizar una nueva llamada recursiva, y un caso recursivo, que reduce el problema acercándolo al caso base y se apoya en la pila de llamadas del programa para conservar el estado de cada llamada pendiente. Ejemplos clásicos son el factorial (n! = n * (n-1)!, con 0! = 1 como caso base), la sucesión de Fibonacci y las torres de Hanoi. Si falta el caso base o el problema no se reduce, las llamadas se suceden indefinidamente hasta agotar la pila (desbordamiento de pila, stack overflow). La recursividad produce código a menudo más claro para problemas de naturaleza recursiva (recorrido de árboles, divide y vencerás), pero consume más memoria y tiempo que la solución iterativa equivalente, y algunas definiciones ingenuas (como Fibonacci recursivo) repiten cálculos y tienen coste exponencial. Es recursiva de cola (tail recursion) aquella cuya llamada recursiva es la última operación, lo que permite a algunos compiladores optimizarla como un bucle. Cuando una función se llama directamente a sí misma la recursividad es directa, y cuando A llama a B y B a A es indirecta o mutua.

Procedimientos, funciones y paso de parámetros

Los procedimientos y las funciones son bloques de código independientes, identificados por un nombre, que permiten modularizar un programa dividiéndolo en unidades reutilizables y más fáciles de mantener (programación modular y diseño descendente); la diferencia habitual entre ambos es que una función devuelve un valor al código que la invocó, mientras que un procedimiento (o subrutina) no lo hace, aunque en muchos lenguajes modernos la distinción sintáctica entre ambos ha desaparecido (en C, por ejemplo, un procedimiento es una función de tipo void). Los parámetros formales, declarados en la definición de la función o procedimiento, reciben los valores concretos (argumentos o parámetros reales) que se les pasan en cada llamada. El paso de parámetros puede realizarse por valor, en cuyo caso se copia el valor del argumento y las modificaciones dentro de la función no afectan a la variable original, o por referencia, en cuyo caso se pasa una referencia a la variable original y las modificaciones dentro de la función sí se reflejan en ella al finalizar la llamada. Según su sentido pueden ser parámetros de entrada, de salida o de entrada/salida. En muchos lenguajes los objetos y vectores se pasan por valor de la referencia, de modo que la función puede modificar el contenido del objeto pero no reasignar la variable del llamante. El ámbito o alcance (scope) de una variable es la zona del programa en que es visible: las variables locales se crean al invocar la función y se destruyen al terminar, y las globales son visibles en todo el programa (su uso excesivo se desaconseja por los efectos laterales). Cada llamada genera un registro de activación en la pila con sus parámetros, variables locales y dirección de retorno.

Vectores, matrices y registros

Un vector (o array) es una estructura de datos que almacena una colección de elementos del mismo tipo bajo un único identificador, accesibles mediante un índice que indica su posición; sus elementos ocupan posiciones contiguas de memoria, lo que permite un acceso directo en tiempo constante, y en muchos lenguajes (C, Java) el primer índice es el 0, de modo que un vector de n elementos tiene índices de 0 a n-1 (acceder fuera de ese rango es un error clásico). Un vector puede tener varias dimensiones, como la matriz o vector bidimensional, en que cada elemento se identifica con dos índices (fila y columna). Su tamaño es fijo en los vectores estáticos y puede variar en estructuras dinámicas como las listas. Un registro (struct o record, según el lenguaje) es una estructura de datos que agrupa bajo un único identificador varios campos que pueden ser de tipos distintos entre sí, a diferencia del vector; se accede a sus campos por nombre (con notación de punto). Ambas estructuras pueden combinarse (vector de registros, registro con campos que son vectores) y son la base de otras estructuras más complejas como listas, pilas, colas y árboles. Las cadenas de caracteres se tratan en muchos lenguajes como vectores de caracteres o como objetos específicos.

Estructura general de un programa

En cuanto a la estructura general de un programa, la práctica totalidad de los lenguajes de alto nivel distinguen una zona de declaraciones (de tipos, constantes, variables y de las funciones y procedimientos del programa) y un bloque principal de instrucciones que constituye el punto de entrada de la ejecución, habitualmente denominado función principal o main. Suele incluir además la importación de bibliotecas o módulos (por ejemplo, #include en C, import en Java o Python) y comentarios para documentar el código. Una variable es un espacio de memoria con nombre cuyo valor puede cambiar durante la ejecución, mientras que una constante mantiene un valor fijo; ambas se declaran con un identificador y un tipo y deben inicializarse antes de usarse. Las buenas prácticas incluyen nombres descriptivos, la sangría del código, la división en funciones pequeñas con una única responsabilidad, la documentación con comentarios, el tratamiento de errores mediante excepciones o códigos de retorno, y la reutilización mediante bibliotecas o módulos. En el pseudocódigo la estructura típica es: algoritmo, declaraciones (constantes, tipos, variables), inicio, instrucciones, fin.

Ideas clave para el examen — memoriza esto

  • Bajo nivel (máquina, ensamblador) vs alto nivel (independiente del hardware). Paradigmas: imperativo, orientado a objetos, funcional y declarativo/lógico.
  • Compilado: todo el código fuente se traduce antes de ejecutar. Interpretado: se traduce y ejecuta instrucción a instrucción.
  • Bytecode + máquina virtual (Java): solución intermedia entre compilación e interpretación; JIT compila en ejecución.
  • Fases del compilador: análisis léxico (tokens), sintáctico (gramática), semántico (tipos y declaraciones), generación y optimización de código; luego enlazado y carga.
  • Errores: de compilación (léxico, sintáctico, semántico), de ejecución y lógicos (solo se detectan con pruebas).
  • Tipos simples/primitivos (numérico, lógico, carácter) vs tipos estructurados/compuestos (vector, registro, cadena).
  • Enteros con signo en complemento a dos: rango -2^(n-1) a 2^(n-1)-1 con n bits. Reales en coma flotante IEEE 754 (signo, exponente, mantisa): errores de redondeo.
  • Caracteres: ASCII (7 bits) y Unicode (UTF-8 de longitud variable). Overflow: resultado fuera del rango representable.
  • Tipado estático (tipos conocidos y comprobados en compilación, declarados o inferidos) vs tipado dinámico (tipos asociados a los valores, comprobados en ejecución). Inferir tipos no equivale a tipado dinámico.
  • Operadores: aritméticos, relacionales, lógicos, de asignación y de bit; precedencia y asociatividad rigen su evaluación; los paréntesis fuerzan el orden.
  • Evaluación en cortocircuito: en A Y B no se evalúa B si A es falso; en A O B no se evalúa B si A es verdadero.
  • No confundir asignación (=) con igualdad (== en lenguajes tipo C).
  • Condicional simple (si-entonces), doble (si-entonces-si no) y selección múltiple (según-caso / switch). En switch, sin break se continúa con el siguiente caso.
  • Bucle while: comprueba antes (0 o más iteraciones). Bucle do-while: comprueba después (mínimo 1 iteración). Bucle for: nº de iteraciones conocido de antemano.
  • 'Repetir... hasta' termina cuando la condición es verdadera; 'do... while' continúa mientras es verdadera.
  • Recursividad: caso base (detiene la recursión) + caso recursivo (reduce el problema); se apoya en la pila de llamadas. Sin caso base: desbordamiento de pila.
  • Recursividad de cola: la llamada recursiva es la última operación; puede optimizarse como un bucle. Fibonacci recursivo ingenuo: coste exponencial.
  • Función devuelve un valor; procedimiento/subrutina, no (distinción que muchos lenguajes actuales han difuminado).
  • Parámetro formal (en la definición) vs argumento o parámetro real (en la llamada).
  • Paso por valor: se copia, no afecta al original. Paso por referencia: sí afecta al original.
  • Variable local: existe solo durante la ejecución de su función. Variable global: visible en todo el programa (uso desaconsejado: efectos laterales).
  • Vector: elementos del MISMO tipo, contiguos e indexados (primer índice 0 en C y Java; n elementos = índices 0..n-1). Registro: campos de tipos DISTINTOS, agrupados por nombre.
  • Matriz: vector bidimensional (dos índices). Vector de registros y registro con vectores: estructuras combinables.
  • Estructura típica de un programa: importaciones, declaraciones (tipos, constantes, variables, funciones/procedimientos) + bloque principal (main).
Ver el esquema con tus propios subrayados →

Ponte a prueba

11 preguntas sobre este tema, en orden aleatorio. Sin registro, sin límite de intentos.

Pregunta 1 de 110 aciertos

En un lenguaje donde A es falso, la expresión 'A Y B' con evaluación en cortocircuito:

Preguntas frecuentes

¿De qué trata el Tema 16 de Técnico Auxiliar de Informática?

Un lenguaje de programación es el conjunto de reglas sintácticas y semánticas que permite a una persona expresar un algoritmo de forma que pueda ejecutarlo un ordenador. Este tema recorre los elementos comunes a la práctica totalidad de los lenguajes de programación imperativos, con independencia del lenguaje concreto en que se materialicen: la representación de los tipos de datos, los operadores disponibles, las estructuras de control condicionales y repetitivas (incluida la recursividad como alternativa a la iteración), la modularización del código en procedimientos y funciones con paso de parámetros, las estructuras de datos básicas de vectores y registros, y la organización general de un programa.

¿Qué hay que memorizar del Tema 16 para el examen?

Bajo nivel (máquina, ensamblador) vs alto nivel (independiente del hardware). Paradigmas: imperativo, orientado a objetos, funcional y declarativo/lógico. Compilado: todo el código fuente se traduce antes de ejecutar. Interpretado: se traduce y ejecuta instrucción a instrucción. Bytecode + máquina virtual (Java): solución intermedia entre compilación e interpretación; JIT compila en ejecución. Fases del compilador: análisis léxico (tokens), sintáctico (gramática), semántico (tipos y declaraciones), generación y optimización de código; luego enlazado y carga. Errores: de compilación (léxico, sintáctico, semántico), de ejecución y lógicos (solo se detectan con pruebas). Tipos simples/primitivos (numérico, lógico, carácter) vs tipos estructurados/compuestos (vector, registro, cadena). Enteros con signo en complemento a dos: rango -2^(n-1) a 2^(n-1)-1 con n bits. Reales en coma flotante IEEE 754 (signo, exponente, mantisa): errores de redondeo. Caracteres: ASCII (7 bits) y Unicode (UTF-8 de longitud variable). Overflow: resultado fuera del rango representable. Tipado estático (tipos conocidos y comprobados en compilación, declarados o inferidos) vs tipado dinámico (tipos asociados a los valores, comprobados en ejecución). Inferir tipos no equivale a tipado dinámico. Operadores: aritméticos, relacionales, lógicos, de asignación y de bit; precedencia y asociatividad rigen su evaluación; los paréntesis fuerzan el orden. Evaluación en cortocircuito: en A Y B no se evalúa B si A es falso; en A O B no se evalúa B si A es verdadero. No confundir asignación (=) con igualdad (== en lenguajes tipo C). Condicional simple (si-entonces), doble (si-entonces-si no) y selección múltiple (según-caso / switch). En switch, sin break se continúa con el siguiente caso. Bucle while: comprueba antes (0 o más iteraciones). Bucle do-while: comprueba después (mínimo 1 iteración). Bucle for: nº de iteraciones conocido de antemano. 'Repetir... hasta' termina cuando la condición es verdadera; 'do... while' continúa mientras es verdadera. Recursividad: caso base (detiene la recursión) + caso recursivo (reduce el problema); se apoya en la pila de llamadas. Sin caso base: desbordamiento de pila. Recursividad de cola: la llamada recursiva es la última operación; puede optimizarse como un bucle. Fibonacci recursivo ingenuo: coste exponencial. Función devuelve un valor; procedimiento/subrutina, no (distinción que muchos lenguajes actuales han difuminado). Parámetro formal (en la definición) vs argumento o parámetro real (en la llamada). Paso por valor: se copia, no afecta al original. Paso por referencia: sí afecta al original. Variable local: existe solo durante la ejecución de su función. Variable global: visible en todo el programa (uso desaconsejado: efectos laterales). Vector: elementos del MISMO tipo, contiguos e indexados (primer índice 0 en C y Java; n elementos = índices 0..n-1). Registro: campos de tipos DISTINTOS, agrupados por nombre. Matriz: vector bidimensional (dos índices). Vector de registros y registro con vectores: estructuras combinables. Estructura típica de un programa: importaciones, declaraciones (tipos, constantes, variables, funciones/procedimientos) + bloque principal (main).

¿Hay preguntas de test de este tema exacto?

Sí, 11 preguntas tipo test sobre este tema, en el apartado "Ponte a prueba" de esta misma página. Sin registro y sin límite de intentos.

¿De dónde sale el temario de este tema?

Del índice oficial de BOE núm. 166, de 10 de julio de 2024, páginas 86740 a 86827: Resolución de 9 de julio de 2024, de la Secretaría de Estado de Función Pública, por la que se convocan procesos selectivos para el ingreso y el acceso en Cuerpos de la Administración General del Estado (identificador oficial BOE-A-2024-14098), Anexo V — Cuerpo de Técnicos Auxiliares de Informática de la Administración del Estado (código de cuerpo 1188), ingreso libre, páginas 86775-86776 (requisitos y estructura de la prueba) y 86803-86807 (programa/temario). Verificado por lectura directa del PDF oficial del BOE (el PDF de 2024 lleva texto extraíble, no es un escaneo): los 33 temas y sus títulos literales de este fichero coinciden con el Anexo V real. (Cuerpo de Técnicos Auxiliares de Informática de la Administración del Estado (C1), ingreso libre — Resolución de 9 de julio de 2024, de la Secretaría de Estado de Función Pública (1.879 plazas de ingreso libre)).

Fuentes de este desarrollo

  • Estándar IEEE 754 de aritmética en coma flotante
  • Estándar Unicode (UTF-8) y código ASCII
  • Bibliografía general de programación y teoría de compiladores (Aho, Lam, Sethi y Ullman, 'Compiladores: principios, técnicas y herramientas')

Mientras tanto, practica con tests gratis de Técnico Auxiliar de Informática.

Empieza gratis ahora