UAX Programaci N Presentaci N

UAX - Programación 1º
Introducción a la programación con C
Fernando Rodrı́guez Sela
Escuela Politécnica Superior

Universidad Alfonso X el Sabio
Septiembre 2022
Fernando Rodrı́guez Sela (UAX) UAX - Programación 1º Septiembre 2022 1 / 106

Índice del curso
1 Introducción
2 Programación Estructurada
3 Programación Orientada a Objetos - OOPS

Versiones
Revision Date Author(s) Description

1.0 16/09/2022 FRS Introducción y tipos de datos
1.1 21/09/2022 FRS Punteros y lectura de teclado
1.2 23/09/2022 FRS Funciones
1.2 25/09/2022 FRS Estructuras de control

Introducción
Índice del curso (Introducción)
1 Introducción
Palabras reservadas
Tipos primitivos en C
Imprimir en la consola

Introducción
Codificación
Cuando escribimos un programa buscamos que se cumpla:
Legibilidad > Corrección > Eficiencia
Legibilidad: Un programa debe ser fácil de leer y entender, incluso

para lectores externos al proyecto.
Corrección: Un programa debe hacer únicamente lo que debe hacer,
ni más, ni menos.
Eficiencia: Un programa debe ejecutarse lo más rápido que sea
posible usando la menor cantidad de memoria (y/o otros recursos)
posible.

Introducción
Compilador / Enlazador
Cuando escribimos un programa en un lenguaje de alto nivel, como C, éste

debe ser traducido a código máquina:
PRECOMPILADOR: C dispone de esta funcionalidad, la cual analiza

nuestro código en busca de MACROS (lı́neas que empiezan con ’#’)
y nos permiten insertar bloques de código incluidos en otros ficheros
(#include) o definir constantes (#define), ...
COMPILADOR: Traduce el código C en código máquina (por fichero)
ENLAZADOR: Une todos los ficheros ’objeto’ con posibles bibliotecas
usadas y genera un ejecutable (binario)
Durante este proceso se hace un análisis sintáctico del código (en busca de
errores) y semántico (que ’cuadren’ los tipos de datos, por ejemplo)

Introducción
IDE
Un IDE es un ”Entorno integrado de desarrollo”.

Para poder programar nos sirve un simple editor de texto, pero el IDE nos
ofrece muchas ventajas para ser más productivos en nuestro trabajo diario.
Existen muchos IDEs (y editores de texto con funcionalidades extendidas)
Netbeans
Eclipse
Visual Studio Code
Jetbrains CLion
...
Nosotros trabajaremos con la suite de Jetbrains
https://www.jetbrains.com/community/education/#students

Introducción
Comentarios
Comentarios de bloque:
Comentarios de bloque
Empieza por /*
Termina por */
Comentarios de lı́nea:
Comentarios de lı́nea
Empieza por //
Termina en el final de la lı́nea
Comentarios de documentación (JAVA):
Comentarios de documentación
Empieza por /**
Termina por */
Introducción
Convenio identificadores
Variables, funciones y métodos: (’camelCase’)

Empiezan con minúscula. Si se trata de nombres compuestos, cada
palabra se empieza por mayúscula
Clases: (’PascalCase’)
Empiezan por mayúscula. Si se trata de nombres compuestos, cada
palabra empieza por mayúscula
Constantes: (’ALL CAPS’)
Se escribe todo en mayúscula. Si se trata de un nombre compuesto,
se utiliza el carácter subrayado ( ) para separar una de otras.

Introducción Palabras reservadas
Introducción: Palabras reservadas
Introducción
Palabras reservadas

Introducción Palabras reservadas
Palabras reservadas
Todo lenguaje de programación dispone de una serie de palabras

reservadas que no podremos usar como nombres de funciones, variables, ...
pues tienen otros significados en el lenguaje.
En el caso de ANSI C, disponemos de las siguientes:
auto break case char const continue default do
double else enum extern float for goto if
int long register return short signed sizeof static
struct switch typedef union unsigned void volatile while

Introducción Tipos primitivos en C
Introducción: Tipos primitivos en C
Introducción
Tipos primitivos en C

Modificadores
Modificador Descripción
signed Con signo (por defecto)
unsigned Sin signo
long Largo
short Corto
const Valor constante
volatile Variable cuyo valor se modifica externamente

Tipos primitivos (Especiales)
Tipo Bytes Uso Lı́mites

char 1 ASCII -128 / 127
signed char
unsigned char 1 ASCII 0 / 255

Tipos primitivos (Enteros)

short 2 Entero con signo -32768 / 32767
short int
signed short
signed short int
unsigned short 2 Entero sin signo 0 / 65535
unsigned short int
int 4 Entero con signo -2147483648
signed 2147483647
signed int
unsigned 4 Entero sin signo 0 / 4294967295
unsigned int

Tipos primitivos (Enteros largos)

long 8 Entero con signo -9223372036854775808
long int 9223372036854775807
signed long
signed long int
unsigned long 8 Entero sin signo 0
unsigned long int 18446744073709551615
long long 8 Entero con signo -9223372036854775808
long long int 9223372036854775807
signed long long
signed long long int
unsigned long long 8 Entero sin signo 0
unsigned long long int 18446744073709551615
En arquitecturas de 32 bits, los long son de 4 bytes

Tipos primitivos (Reales)

float 4 Real de simple precisión ±3.4e 38
±1.4e −45
double 8 Real de doble precisión ±1.7e +308
±4.9e −324
IEEE-754:
https://en.wikipedia.org/wiki/Double-precision_
floating-point_format

Tipo booleano
En C99, usa la librerı́a stdboolean.h
#include <stdbool.h> // El tipo es _Bool que se redefine como bool

int main() {
bool esVerdadero = true;
bool esFalso = false;
}
En C89/90, el booleano se implementa con el entero:
typedef int bool;

#define TRUE 1
#define FALSE 0
bool f = FALSE;
if (f) { ... }

Introducción Imprimir en la consola
Introducción: Imprimir en la consola
Introducción
Imprimir en la consola

Impresión en la consola. printf

Cuando queremos escribir información en la consola, utilizaremos la
función del sistema printf:
#include <stdio.h>
void main() {
printf("Hola Mundo !\n");
}
El código anterior, es uno de los programas más pequeños que puedes

hacer. En este caso, nos imprimirá el texto
Hola Mundo !
y cambiará de lı́nea.
printf - Formatos
La función anterior también puede servirnos para formatear cadenas más
complejas, ya que la función acepta un número indeterminado de opciones:
#include <stdio.h>
#include <limits.h>
int main() {
printf("El tipo long ocupa %d bytes y tiene un rango de valores
,→ entre %ld y %ld\n", sizeof(long), LONG_MIN, LONG_MAX);
}
Fı́jate en los formatos que introducimos con el sı́mbolo %
El tipo long ocupa 8 bytes y tiene un rango de valores

entre -9223372036854775808 y 9223372036854775807
printf - Formatos
Formato Salida
%d o %i Entero en base 10 con signo
%u Entero en base 10 sin signo
%o Entero en base 8 (octal) sin signo
%x Entero en base 16 (hexadecimal) en minúsculas
%X Entero en base 16 (hexadecimal) en MAYÚSCULAS
%ld Entero de 32 bits (long)
%lu Entero de 32 bits sin signo (unsigned long)
%f Real de precisión simple (float)
%lf Real de precisión doble (double)
%e Real con notación cientı́fica1 en minúsculas
%E Real con notación cientı́fica en MAYÚSCULAS
%c Caracter ASCII (char)
%s Cadena de caracteres (char*)
1
mantisa / exponente
Caracteres especiales
Carácter Significado
\t Tabulador
\n Salto de lı́nea
\r Inicio de lı́nea
\” Comillas dobles
\’ Comillas simples
\\ Carácter barra hacia atrás (\)

Programación Estructurada
Índice del curso (Programación Estructurada)
1 Introducción
Estructura de un programa
Identificadores, variables, Operaciones y expresiones
Punteros
Lectura de datos por teclado
Funciones
Separando el código en múltiples ficheros
Estructuras de control
Recursividad
Arrays
Estructuras de datos
TAD - Tipo Abstracto de Datos

Programación Estructurada Estructura de un programa
Programación Estructurada: Estructura de un programa
Estructura de un programa

Estructura de un programa en C
// Incluimos librerı́a estándar de IO (para usar printf)

#include <stdio.h>
// Todo programa en C empezará en la función main

int main() { // Las llaves delimitan el ámbito ('scope') de main
/* Llamamos a la función printf que imprimirá

en la consola el texto que pasamos */
printf("Hola Mundo !\n");
return 0; // Devolvemos 0 al Sistema Operativo (Sin errores)

} // Fin del bloque de la función main

Proceso de generación (comandos para Linux)
# Compila y enlaza. Genera el binario 'miPrimerPrograma'

gcc -o miPrimerPrograma main.c
# Preprocesador (mostrará en consola el resultado)

gcc -E main.c
# Compilar (dejará el fichero main.s con código ensamblador)
gcc -S main.c
# Preprocesador, compilador y ensamblador (genera código "objeto")
gcc -c main.c
# Enlazar (Incluimos librerı́as externas)

ld /usr/lib/x86_64-linux-gnu/crti.o /usr/lib/x86_64-linux-gnu/crtn.o
,→ /usr/lib/x86_64-linux-gnu/crt1.o -lc main.o -dynamic-linker
,→ /lib64/ld-linux-x86-64.so.2 -o miEjecutable

Programación Estructurada Identificadores, variables, Operaciones y expresiones
Programación Estructurada: Identificadores, variables,

Operaciones y expresiones
Identificadores, variables, Operaciones y expresiones

Tipos de datos
Ya vimos los tipos primitivos2 , ahora vamos a estudiar cómo usarlos.
2
Ir a las transparencias de lso tipos primitivos: 2
Números enteros
Representa: Números enteros
#include <stdio.h>
int main() {
int entero = 625;
long enteroLargo = 387482;
}

Números enteros: Operaciones
unarias: Cambio de signo

binarias:
Multiplicativas3 : ∗, /, %
Aditivas: +, −
Incremento y decremento: ++, −−
Relación: >, <, >=, <=
Igualdad: ==, ! =
Asignación: =, + =, − =, ∗ =, / =
Desplazamiento: >>, <<
3
La operación módulo nos devuelve el resto de la división entera
Números reales
Representa: Números reales
#include <stdio.h>
int main() {
float real = 625.43;
double realDoblePrecision = 3.1e21;
}
Nota
En la entrada de números reales podemos usar notación cientı́fica

Números reales: Operaciones
unarias: Cambio de signo

binarias:
Multiplicativas4 : ∗, /
Aditivas: +, −
Incremento y decremento: ++, −−
Relación: >, <, >=, <=
Igualdad: ==, ! =
Asignación: =, + =, − =, ∗ =, / =
Desplazamiento: >>, <<
4
Fijarse que en números reales no hay operación módulo
Caracteres
Representa: Un único caracter (byte). Se interpreta como ASCII

Se expresan entre comillas simples (’)
También se puede definir con un valor numérico
#include <stdio.h>
int main() {
char caracter1 = 'F';
char caracter2 = 70;
}

Textos
Representa: Cadenas de caracteres

Se expresan entre comillas dobles (”)
En C se almacenan como una secuencia de caracteres terminados con
el caracter nulo (0x00)
Usaremos un puntero 5 a un tipo char6
#include <stdio.h>
int main() {
char *cadena = "Mi cadena de texto";
}
5
Estudiaremos los punteros en breve
6
El * representa ’puntero a . . . ’
Operadores booleanos
Toda operación entre booleanos es un booleano

Negación: !
Y lógico: &&
O lógico: ||

Precedencia de operaciones
El orden es el siguiente:
1 Operadores unarios
2 Operadores multiplicativos (izquierda a derecha)
3 Operadores aditivos (izquierda a derecha)
4 Operadores de relación
5 Operadores de asignación

Conversión de tipos
C nos realiza conversión de tipos ’ascendente’ de forma automática (pues

se considera que no se pierde información / precisión.
La conversión descendente debe ser especificada por el programador ya
que se puede perder información.
Para la conversión utilizamos lo que se denomina cast, que consiste en
encerrar entre paréntesis el tipo de datos destino:
int a = 3;
int b = 5;
printf("División entera %d\n", a/b); // Da 0
printf("División real %f\n", a/(float)b); // Da 0.6

Ejercicio
Ejercicio
Implementar un programa que dadas dos variables enteras y otras dos
reales:
Imprima los cuatro números
Mostrar los resultados de operaciones aditivas, multiplicativas, ...

Programación Estructurada Punteros
Programación Estructurada: Punteros
Punteros

Punteros
ATENCIÓN
Aviso a navegantes: lo que vamos a ver a continuación son conceptos
avanzados de cómo usar la memoria de un ordenador.
Si bien no es difı́cil, si tienes que prestar mucha atención.
Al final, entender bien esta parte es lo que diferencia a los buenos y malos
programadores.
Sea el lenguaje que sea (que no te engañen), hay punteros (algunos lo
ocultan, pero están allı́) pues es como funciona el procesador y el lenguaje
máquina que, al fin y al cabo, es lo que generamos en última instancia.
¿Estás preparado? ¿alguien dijo miedo? ¡ Vamos a ello ! :)

Punteros
Como ya comentamos, en la memoria almacenamos los datos y para

acceder a los mismos, debemos saber la “dirección” de memoria dónde
están almacenados.
En lenguajes de alto nivel usamos el nombre de la variable que definimos
en nuestro código.
Sin embargo, hay veces que necesitamos utilizar la dirección que
referencia a una zona de memoria.
Conozcamos a los punteros.

Qué es un puntero
Un puntero es una variable que almacena la dirección de memoria de otra
variable.
Figure: Punteros - Fuente: Wikipedia
Obviamente un puntero ocupará más o menos en función de la

arquitectura, en máquinas de 64bits son 8 bytes.
Uso de punteros en C
En C, los punteros los declaramos con el uso del sı́mbolo * delante del
nombre de la variable.
Usando el * Nos referimos a “La dirección referida en ...”
Si necesitamos saber la dirección en memoria de una variable cualquiera,
usamos el sı́mbolo & delante del nombre de la variable.
Esto nos permitirá tener acceso a variables de otras funciones o disponer
de estructuras de datos más “complejas” como iremos viendo en los
próximos cursos.

Ejemplos de código con punteros
Una imagen vale más que 1000 palabras:
#include <stdio.h>
int main() {
int numero = 3;
int *refANumero = &numero;
// refANumero es un puntero a la variable numero

printf("El número almacenado el la posición de memoria 0x%p tiene
,→ el valor %d\n", refANumero, *refANumero);
}

Aritmética de punteros
Los punteros no dejan de ser una variable más, por lo que podremos usar
operaciones aritméticas con ellos (suma, resta, ...) permitiéndonos
movernos por la memoria a nuestro antojo (y ası́ recorrer secuencias de
datos).
Atención
Hay que tener mucho cuidado cuando jugamos con la aritmética de
punteros pues es muy fácil salirse de las zonas de memoria que nos asignó
el sistema operativo, provocando un error tipo “Buffer Overflow”.
También, programas que controlan poco estas situaciones son propensos a
ser vı́ctimas de ataques.

Ejemplos de código con punteros

Si recuerdas, las cadenas las estábamos definiendo con char *, ¡anda, si
era un puntero!. Efectivamente, en C no hay cadenas como tal, sino que
tenemos un puntero a la primera letra de la cadena.
#include <stdio.h>
int main() {
char *cadena = "Hola Mundo cruel";
char *caracter = cadena;
printf("%c\n", *caracter); // H
caracter += 5;
printf("%c\n", *caracter); // M
}

Punteros void
En ocasiones, necesitamos usar punteros pero no sabemos a que tipo de

datos vamos a referenciar.
En estas situaciones, definiremos el puntero de tipo void y cuando
vayamos a usarlo, haremos uso del casting 7
7
Si recuerdas, indicar entre paréntesis el tipo de dato: (float)miVariableEntera
Punteros
Al final no fue tan complicado, ¿verdad?

No obstante, no te confı́es, repasa estos conceptos, juega con ellos,
prueba, experimenta... No tengas miedo a equivocarte, ası́ se aprende.
A continuación iremos viendo distintos usos de los punteros, ası́ que ten
bien claro todo lo que hemos visto hasta ahora.
¡ Sigamos !

Programación Estructurada Lectura de datos por teclado
Programación Estructurada: Lectura de datos por teclado

Será muy habitual que necesites solicitar información al usuario, para ello
deberás esperar a que introduzca la información por el teclado y pulse
ENTER.
En C, haremos uso de la función scanf, cuyo funcionamiento es muy
similar a la que ya conocemos, printf.
Importante
Fı́jate que tenemos que darle una variable para que nos escriba la
información que el usuario ha tecleado; para que esto funcionea , scanf
espera recibir un puntero a una variable dónde escribir, por eso le pasamos
&miVariable (La dirección de memoria dónde se aloja miVariable.
a
Responderemos al ¿por qué? cuando hablemos de las funciones.

Uso de scanf
#include <stdio.h>
#define MAX_NOMBRE 40
int main() {
int entero;
printf("Dime un numero: ");
scanf("%d", &entero);
float decimal;
printf("Dime un numero real: ");
scanf("%f", &decimal);

Uso de scanf
char nombre[MAX_NOMBRE];
printf("Dime tu nombre: ");
scanf("%s", nombre);
printf("%s, tu entero es %d y tu real %f%n", nombre, entero,

,→ decimal);
int entero2;
printf("Ahora dime 2 numeros enteros separados por un espacio: ");
scanf("%d %d", &entero, &entero2);
printf("Me has dicho %d y %d%n", entero, entero2);
}

Ejercicio
Ejercicio
Implementar un programa calcule la ecuación de segundo grado usando 3
variables.
Solicitar los datos al usuario
√
−b ± b 2 − 4ac
x= (1)
2a
Cuidado
Cuidado con resultados complejos; Evita meter valores que hagan que la
raı́z sea negativa, es decir, debe cumplirse que: 4ac <= b 2

Programación Estructurada Funciones
Programación Estructurada: Funciones
Funciones

Funciones y Procedimientos
Hasta ahora hemos estado escribiendo nuestros programas bajo una única
función, la principal (main).
Si bien esto funciona, no es un método viable para implementar programas
de gran envergadura8 , además que nos obliga a repetir código cuando
requerimos hacer una misma tarea una y otra vez a lo largo de nuestro
programa.
Todo lenguaje de programación dispone de mecanismos para organizar
nuestro código y poder agrupar funcionalidades de manera lógica.
Vamos a estudiar como se utilizan las funciones en C.
8
Por ejemplo, el Kernel 5.12 de Linux tiene 28.8 millones de lı́neas de código
Función o Procedimiento
Esta distinción es más teórica que otra cosa, básicamente una función
debe devolver un valor mientras que un procedimiento simplemente
ejecuta comandos pero no devuelve nada.
Con el tipo void podemos indicar que NO devolvemos absolutamente
nada (vacı́o) y por tanto estaremos definiendo un procedimiento.

Tamaño de una función/procedimiento
¿Qué tamaño deberı́a tener una función? ¿cuándo debo crear una nueva?
Si bien no hay una respuesta “oficial” a estas preguntas, el sentido común
nos dice que una función no deberı́a superar el tamaño de una pantalla, es
decir, que podamos verla entera sin tener que hacer scroll.
Por otro lado, a la segunda pregunta, debemos crear una nueva función
cuando lo implementado en ella sea un “concepto” propio o tenga entidad
propia y podamos darle un nombre.
La experiencia y los años programando te irán diciendo dónde hacer
nuevas funciones.

Estructura de una función/procedimiento en C
// Definimos una función

int nombreFuncion(int parametro1, float parametro2) {
// Código de la función
return 3; // Devolvemos un entero

}
// Definimos un procedimiento
void nombreProcedimiento(int parametro1, float parametro2) {
// Código del procedimiento
// No se devuelve NADA
}

Dónde debo declarar mis funciones/procedimientos
En C, toda función y/o procedimiento, deben declararse antes de ser

usadas.
Si, por la razón que sea, la quieres declarar después, podrás indicarle al
compilador de la existencia de esa función/procedimiento y que en algún
momento se la encontrará para compilarlo.
Para indicarlo, lo hacemos con lo que se denomina (en inglés) “function
signature”, o lo que es lo mismo, la “firma” de la función.
Básicamente es declarar la función sin implementarla, como veremos en
la siguiente página.

Uso de una función/procedimiento en C
// Incluimos las funciones definidas en algún lugar

// Nota: Esto es lo que se conoce como 'function signature'
// y define únicamente el nombre, los parámetros aceptados
// con sus tipos y tipo de devolución
int nombreFuncion(int parametro1, float parametro2);
void nombreProcedimiento(int parametro1, float parametro2);
int main() {
int a = nombreFuncion(3, 2.8);
nombreProcedimiento(3, 2.8);
return 0;
}

Ejemplos
Veamos éste código, podemos observar que repetimos una y otra vez lo
mismo, es un ejemplo claro de que nos hace falta una función:
#include <math.h> // M_PI, pow()
void main() {
// ...
double areaCirculo1 = 2 * M_PI * pow(radioCirculo1, 2);
// ...
double areaCirculo2 = 2 * M_PI * pow(radioCirculo2, 2);
// ...
}

Ejemplos
Separada en funciones:
double areaCirculo(double radio) {

return 2 * M_PI * pow(radio, 2);
}
void main() {
// ...
double areaCirculo1 = areaCirculo(radioCirculo1);
// ...
// ...
}

El paso de parámetros
Como hemos visto, podemos definir un número variable de parámetros que
se pueden pasar a una función en C, pero ¿qué pasa realmente entre
“bambalinas”?
Lo que sucede es que se copian los datos a la pila y al entrar en la
función, se asigna el valor a la variable local.
Figure: Pila LIFO

El paso de parámetros
Aquı́ el valor de radioCirculo1 es COPIADO a la pila
Luego, se EXTRAE de la pila y se asigna a la variable local radio
IMPORTANTE
Grábatelo a fuego: todo dato que se pasa a una función es una COPIA

Devolución de resultados
En el return, el resultado se copia a la pila
Y finalmente, se EXTRAE de la pila para usar este valor y asignárselo a

areaCirculo1

Paso por valor / paso por referencia

Como ya comentamos anteriormente, todos los datos que se pasan a una
función, son una copia de los mismos, es lo que se conoce como paso por
valor. Como consecuencia directa, No podemos modificar su valor:
void sumaDos(int numero) {

printf("numero antes vale: %d", numero); // 1
numero += 2;
printf("numero después vale: %d", numero); // 3
}
void main() {
int miNumero = 1;
printf("miNumero antes vale: %d", miNumero); // 1
sumaDos(miNumero);
printf("miNumero después vale: %d", miNumero); // 1
}

Paso por valor / paso por referencia
¿Y si necesitamos que nuestra variable se modifique? ¿qué podemos

hacer?
Aquı́ entra lo que se conoce como “paso por referencia” (pasar la
referencia a dónde se encuentra la variable) ¿te suena?: scanf... .
No obstante, ANSI C no permite el paso por referencia.
NOTA
Otros lenguajes, como C++, si ponemos & en la llamada a la función, le
estamos indicando que el paso es por referencia
void sumaDos(int &numero)
Y podemos usarlo “transparentemene”.
En JAVA, no hay distinción, según el tipo de dato que se pasa, se hará de
una u otra forma; ya lo veremos a su debido tiempo.

Paso por valor con punteros

Básicamente, en vez de pasar la variable, le pasamos la dirección de
memoria de la variable; ¿recuerdas a los punteros?, los volvemos a ver.
void sumaDos(int *numero) {

printf("numero antes vale: %d", *numero); // 1
*numero += 2;
printf("numero después vale: %d", *numero); // 3
}
void main() {
int miNumero = 1;
printf("miNumero antes vale: %d", miNumero); // 1
sumaDos(&miNumero);
printf("miNumero después vale: %d", miNumero); // 3
}

Paso por valor con punteros
Aquı́ el valor de &miNumero es, si recuerdas, la dirección de memoria

dónde está miNumero; ası́ que lo que copiamos a la pila, es el valor de la
dirección, no el valor de la variable
sumaDos(&miNumero);
Luego, se EXTRAE de la pila la dirección y se asigna al puntero local

*numero
void sumaDos(int *numero) {
Toda modificación que hacemos, no es al puntero, sino a lo que referencia,

por lo que estamos modificando el valor original de miNumero

Función main
Ya hemos hablado de la función main como punto de entrada de nuestra
aplicación. Todo programa en C empieza en main.
También vimos que main devolvı́a int o nada void.
Esto nos permitı́a informar al Sistema Operativo acerca de posibles fallos
de nuestra aplicación (0 =¿ Todo Ok).
Y parámetros, ¿puede main recibir parámetros?
La respuesta es SÍ, más aún, si algún dı́a usaste algún programa desde una
consola, seguramente habrás llamado al ejecutable y le habrás pasado
algún parámetro.
# cat (UNIX) nos muestra el contenido de un fichero

# le pasamos como parámetro el nombre del fichero a mirar
cat main.c
# en Windows, el comando equivalente es type

Función main / Parámetros de entrada
Pues bien, para poder acceder a esos parámetros desde nuestro programa
en C, lo haremos de la siguiente forma:
int main(int argc, char *argv[]) {

// En argc recibimos el número de parámetros que nos pasaron
// En argv disponemos de un array (lista) de cadenas
// de texto; en cada posición tenemos un parámetro
return 0; // Al S.O. le devolvemos un número entero

}
Nota
Los arrays los veremos más adelante

Ejercicio
Ejercicio
Implementa una función que devuelva si un número es par o no.
Implementa un procedimiento, que reciba un número, llame a la función
anterior y escriba en pantalla el resultado.
Desde main, simplemente llamaremos al procedimiento.
Observa con el depurador cómo se van copiando los valores a las distintas
variables locales pero están en distintos sitios de la memoria
Ejercicio
Modifica el programa de la ecuación de segundo grado y usa funciones o
procedimientos (según consideres).
Recuerda, que devolverás dos resultados ... ¿cómo se te ocurre que puedes
hacerlo?

Programación Estructurada Separando el código en múltiples ficheros
Programación Estructurada: Separando el código en

múltiples ficheros
Separando el código en múltiples ficheros

Separando nuestro código en ficheros
Cuando tenemos programas muy grandes es bueno no tenerlo todo en el

mismo fichero .c.
Una buena costumbre es separar nuestro código en varios ficheros y que en
cada fichero alojemos el código que tenga relación entre sı́.
No obstante, si desde nuestra función principal (o cualquier otra)
requerimos acceder a ese código, debemos indicarle al compilador de la
existencia de los mismos.
En primer lugar, ¿recuerdas que cuando definı́amos una función después
de dónde la usamos tenı́amos antes que indicarle la ‘signatura’ de la
misma?
Para eso usaremos los ficheros de cabecera o .h

main.c
Dónde vayamos a usar las nuevas funciones, debemos incluir su cabecera.
#include "circulo.h"
void main() {
// ...
// ...
// ...
}
Fı́jate que ahora lo hacemos con las comillas y no con los sı́mbolos ¡ y ¿.
Esto es porque con ¡ ¿ va a buscar la cabecera en las carpetas
predefinidas, y con comillas, en la carpeta del proyecto.
circulo.c
En un fichero independiente implementamos el cálculo del área de un

cı́rculo.

}

circulo.h
Y la cabecera simplemente incluye la “firma” de nuestra función para que

el compilador sepa de su existencia cuando se usa.
#ifndef _CIRCULO_H_
#define _CIRCULO_H_
double areaCirculo(double radio);
#endif
Las condiciones del PREPROCESADOR son para evitar incluir el mismo

fichero múltiples veces; si ya está incluido, la lı́nea 1 evitará que se vuelva
a re-declarar todo de nuevo.

Construcción
Finalmente queda indicar al compilador que compile nuestro nuevo fichero
y los enlace.
En el caso de CLion, trabaja con CMake, una herramienta para facilitar
las labores de construcción.
Únicamente nos queda indicarle que considere nuestro nuevo fichero
modificando el fichero ‘CMakeLists.txt’ y añadiéndolo a la lista de
add executable(...):
cmake_minimum_required(VERSION 3.23)
project(programaCirculos C)
set(CMAKE_C_STANDARD 99)
add_executable(programaCirculos main.c circulo.c)

Programación Estructurada Estructuras de control
Programación Estructurada: Estructuras de control

Hasta ahora todos nuestros programas seguı́an un flujo lineal: Ejecutamos

las instrucciones en orden y terminamos.
Sin embargo, normalmente nos interesará modificar ese flujo lineal, por
ejemplo, ejecutar una parte sólo si se cumple alguna condición, o repetir lo
mismo una y otra vez mientras se cumplan ciertas condiciones.
Es por ello que los lenguajes de programación disponen de las estructuras
de control o secuencias de control de flujo para poder modificar el flujo de
nuestras aplicaciones a nuestras necesidades:
Condicionales: Ejecutar un código si se cumple alguna condición
Bucles: Repetir el mismo bloque de código mientras se cumpla alguna
condición

Control de flujo: Condicionales
Las sentencias de control de flujo condicionales nos permiten ejecutar o no

ciertas partes del código en función de si se cumple o no ciertas
condiciones.
En C disponemos de dos:
if
switch

Control de flujo: Condicionales / if
Ejecuta el código delimitado por las llaves ... sólo si se cumple la

condición entre paréntesis:
if (/* Condición */ ) {
// Código a ejecutar si Condición es verdadera (!= 0)
}
if (/* Condición */ )
// Una única lı́nea (instrucción) a ejecutar si Condición es
,→ verdadera
Si no se ponen las llaves, sólo la siguiente instrucción será ejecutada de

manera condicional. Se recomienda poner siempre las llaves para evitar
errores difı́ciles de encontrar.

Control de flujo: Condicionales / if ... else

Si necesitamos ejecutar un código si se cumple una condición u otro
distinto sino se cumple, usaremos la estructura if ... else:
if (/* Condición */ ) {
// Código a ejecutar si Condición es verdadera (!= 0)
} else {
// Código a ejecutar si Condición es falsa (== 0)
}
if (/* Condición */ )
// Una única lı́nea (instrucción) a ejecutar si Condición es
,→ verdadera
else
// Una única lı́nea (instrucción) a ejcutar si Condición es falsa

Control de flujo: Condicionales / if ... else if ... else

Si necesitamos encadenar varias condicionales, podemos añadirlas de la
siguiente forma::
if (/* Condición 1 */ ) {
// Código a ejecutar si Condición 1 es verdadera (!= 0)
} else if (/* Condición 2 */ ) {
// Código a ejecutar si Condición 1 es falsa (== 0) y Condición 2
,→ es verdadera (!= 0)
} else if (/* Condición 3 */ ) {
// Código a ejecutar si Condición 1 y 2 son falsas (== 0) y
,→ Condición 3 es verdadera (!= 0)
} else {
// Código a ejecutar si todas las condiciones son falsas
}

Control de flujo: Condicionales / switch

Hay veces que tenemos múltiples casos a cubrir en base al valor de una
variable; podrı́amos usar if ... else if ... usando siempre la misma variable
miVariable == 1, miVariable == 2, ...
Para simplificar esta situación, disponemos del condicional switch:
switch(/* Variable */ ) {
case /* Valor 1*/ :
// Código a ejecutar si Variable == Valor 1
break;
case /* Valor 2*/ :
break;
default:
// Código a ejecutar si Variable no se cubre en ningún case
}

Se puede observar que en el caso del switch no se usan llaves en cada

case, en su lugar usamos la instrucción break, que interrumpe la ejecución
del condicional en ese momento.
Sino ponemos el break, ejecutará el código de todos los case hasta
encontrar el break.

switch(/* Variable */ ) {
case /* Valor 1*/ :
case /* Valor 2*/ :
// Código a ejecutar si Variable == Valor 2 o == Valor1
break;
default:
// Código a ejecutar si Variable no se cubre en ningún case
}
NOTA
Hay lenguajes que OBLIGAN a poner los break en todos los case, como
C#

Control de flujo: if inline
Si necesitamos una condicional en una única lı́nea, por ejemplo, porque

queremos ponerla dentro de un printf, o dentro de la llamada a una
función, C nos ofrece esta forma de escribir una condicional en una única
lı́nea:
( Condición ? Sentencia Si Verdadero : Sentencia Si Falso)
printf("El número es %s\n", ( numero % 2 == 0 ? "Par" : "Impar" ) );

Ejercicio
Ejercicio
Implementar un programa que dada una variable entera nos indique:
Si es par
Si es impar
Si es múltiplo de 3
Si es múltiplo de 5
Si es múltiplo de 3 y 5

Ejercicio
Ejercicio
Implementar un programa que pregunte al usuario su edad y a
continuación escriba en pantalla el precio de la cuota del club de Golf:
10€ menores de 18
20€ menores de 25
30€ menores de 65
15€ mayores de 65

Ejercicio
Ejercicio
Preguntar al usuario la fecha (dı́a, mes y año).
A continuación escribirla como:
Hoy es 25 del Septiembre del 2022

Ejercicio
Ejercicio
Preguntar al usuario la fecha (dı́a, mes y año).
A continuación indicar cuántos dı́as quedan del mes:
Hoy es 25/9/2022. Quedan 5 dı́as para terminar el mes.
Bisiestos
Un año es bisiesto si es múltiplo de 4, salvo que sea a su vez múltiplo de
100.
Si es múltiplo de 100, entonces también deberá ser múltiplo de 400.
Implementa una función boolean esBisiesto(int anio); que haga esta
comprobación.

Control de flujo: Bucles
Los bucles nos permiten ejecutar una parte de nuestro código múltiples
veces.
En C disponemos de tres:
for
while
do ... while

Control de flujo: goto
La instrucción goto nos permite saltar a cualquier punto del programa

(identificado con una etiqueta) sin usar bucles, no obstante su uso
produce programas más difı́ciles de mantener y de leer, por esa razón no
está recomendado su uso.
Usar goto tiene que estar suficientemente justificado si el algoritmo no se
puede hacer legible con un bucle o condicional de las que vimos.
void main() {
printf("Antes del goto\n");
goto salir;
// ... código que no se ejecutará
salir: printf("Última lı́nea\n");
}

Programación Estructurada Recursividad
Programación Estructurada: Recursividad
Recursividad

Programación Estructurada Arrays
Programación Estructurada: Arrays
Arrays

Programación Estructurada Estructuras de datos
Programación Estructurada: Estructuras de datos
Estructuras de datos

Programación Estructurada TAD - Tipo Abstracto de Datos
Programación Estructurada: TAD - Tipo Abstracto de

Datos
TAD - Tipo Abstracto de Datos

Programación Orientada a Objetos - OOPS
Índice del curso (Programación Orientada a Objetos -

OOPS)
1 Introducción

Del TAD a la Clase
Introducción a JAVA
Lectura de teclado. Clases de Utilidad
Clases y Objetos
Control de Errores. Excepciones
Entrada/Salida. Ficheros
Programación Orientada a Objetos - OOPS Del TAD a la Clase
Programación Orientada a Objetos - OOPS: Del TAD a la

Clase
Del TAD a la Clase
Programación Orientada a Objetos - OOPS Introducción a JAVA
Programación Orientada a Objetos - OOPS: Introducción

a JAVA
Introducción a JAVA
Programación Orientada a Objetos - OOPS Lectura de teclado. Clases de Utilidad
Programación Orientada a Objetos - OOPS: Lectura de

teclado. Clases de Utilidad
Lectura de teclado. Clases de Utilidad
Programación Orientada a Objetos - OOPS Clases y Objetos
Programación Orientada a Objetos - OOPS: Clases y

Objetos
Clases y Objetos
Programación Orientada a Objetos - OOPS Control de Errores. Excepciones
Programación Orientada a Objetos - OOPS: Control de

Errores. Excepciones
Control de Errores. Excepciones
Programación Orientada a Objetos - OOPS Entrada/Salida. Ficheros
Programación Orientada a Objetos - OOPS:


UAX Programaci N Presentaci N

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

UAX Programaci N Presentaci N

Cargado por

Copyright:

Formatos disponibles

UAX - Programación 1º

Introducción a la programación con C

Fernando Rodrı́guez Sela

Escuela Politécnica Superior

Fernando Rodrı́guez Sela (UAX) UAX - Programación 1º Septiembre 2022 1 / 106

3 Programación Orientada a Objetos - OOPS

Fernando Rodrı́guez Sela (UAX) UAX - Programación 1º Septiembre 2022 2 / 106

Revision Date Author(s) Description

Fernando Rodrı́guez Sela (UAX) UAX - Programación 1º Septiembre 2022 3 / 106

Índice del curso (Introducción)

3 Programación Orientada a Objetos - OOPS

Fernando Rodrı́guez Sela (UAX) UAX - Programación 1º Septiembre 2022 4 / 106

Cuando escribimos un programa buscamos que se cumpla:

Legibilidad > Corrección > Eficiencia

Legibilidad: Un programa debe ser fácil de leer y entender, incluso

Fernando Rodrı́guez Sela (UAX) UAX - Programación 1º Septiembre 2022 5 / 106

Cuando escribimos un programa en un lenguaje de alto nivel, como C, éste

PRECOMPILADOR: C dispone de esta funcionalidad, la cual analiza

Fernando Rodrı́guez Sela (UAX) UAX - Programación 1º Septiembre 2022 6 / 106

Un IDE es un ”Entorno integrado de desarrollo”.

Fernando Rodrı́guez Sela (UAX) UAX - Programación 1º Septiembre 2022 7 / 106

Variables, funciones y métodos: (’camelCase’)

Fernando Rodrı́guez Sela (UAX) UAX - Programación 1º Septiembre 2022 9 / 106

Introducción: Palabras reservadas

Fernando Rodrı́guez Sela (UAX) UAX - Programación 1º Septiembre 2022 10 / 106

Todo lenguaje de programación dispone de una serie de palabras

Fernando Rodrı́guez Sela (UAX) UAX - Programación 1º Septiembre 2022 11 / 106

Introducción: Tipos primitivos en C

Fernando Rodrı́guez Sela (UAX) UAX - Programación 1º Septiembre 2022 12 / 106

Fernando Rodrı́guez Sela (UAX) UAX - Programación 1º Septiembre 2022 13 / 106

Tipos primitivos (Especiales)

Tipo Bytes Uso Lı́mites

Fernando Rodrı́guez Sela (UAX) UAX - Programación 1º Septiembre 2022 14 / 106

Tipos primitivos (Enteros)

Tipo Bytes Uso Lı́mites

Fernando Rodrı́guez Sela (UAX) UAX - Programación 1º Septiembre 2022 15 / 106

Tipos primitivos (Enteros largos)

Tipo Bytes Uso Lı́mites

En arquitecturas de 32 bits, los long son de 4 bytes

Fernando Rodrı́guez Sela (UAX) UAX - Programación 1º Septiembre 2022 16 / 106

Tipos primitivos (Reales)

Tipo Bytes Uso Lı́mites

Fernando Rodrı́guez Sela (UAX) UAX - Programación 1º Septiembre 2022 17 / 106

#include <stdbool.h> // El tipo es _Bool que se redefine como bool

En C89/90, el booleano se implementa con el entero:

typedef int bool;

Fernando Rodrı́guez Sela (UAX) UAX - Programación 1º Septiembre 2022 18 / 106

Introducción: Imprimir en la consola

Fernando Rodrı́guez Sela (UAX) UAX - Programación 1º Septiembre 2022 19 / 106

Impresión en la consola. printf

El código anterior, es uno de los programas más pequeños que puedes

Fı́jate en los formatos que introducimos con el sı́mbolo %

El tipo long ocupa 8 bytes y tiene un rango de valores

Fernando Rodrı́guez Sela (UAX) UAX - Programación 1º Septiembre 2022 23 / 106

Índice del curso (Programación Estructurada)

Fernando Rodrı́guez Sela (UAX) UAX - Programación 1º Septiembre 2022 24 / 106

Programación Estructurada: Estructura de un programa

Fernando Rodrı́guez Sela (UAX) UAX - Programación 1º Septiembre 2022 25 / 106

// Incluimos librerı́a estándar de IO (para usar printf)

// Todo programa en C empezará en la función main

/* Llamamos a la función printf que imprimirá

return 0; // Devolvemos 0 al Sistema Operativo (Sin errores)