ADMINISTRACION

DE
SISTEMAS
INFORMATICOS

RESUMEN
DE
APUNTES
DE
FUNDAMENTOS
DE
PROGRAMACION
TEMA 1: METODOLOGIA DE LA PROGRAMACION

1.3 METODOLOGIA DE LA PROGRAMACION

Para resolver un problema de programación debemos seguir una serie de pasos:
- Definir el problema a resolver y analizarlo.
- Diseñar el algoritmo (secuencia de pasos para resolver el problema).
- Traducir el algoritmo a un lenguaje de programación.
- Ejecutar y validar el programa.

A. Algoritmos

Un algoritmo debe ser preciso, definido (debe dar el mismo resultado si se dan las
mismas condiciones) y finito.

B. Representación de los algoritmos

Se usan representaciones intermedias entre el lenguaje natural y los lenguajes de

programación.

- Diagramas de flujo (organigramas)

Son un conjunto de figuras geométricas unidas por flechas (líneas de flujo).
Los símbolos más utilizados son:

INICIO
Inicio de programa:

Salida (ej: escribir en pantalla): “La suma es: “ a+b

Entrada (ej: leer desde teclado): num1, cadena$

cuadrado = num * num

Proceso (operaciones): minicadena$ = SUBCADENA(cadena$,0,5)

procesar(num1,num2,num3)
Subprograma:

Decisión: (a >= 5 y b < > 4) o c = 3

Conector a la misma página:

Conector a distinta página:

2

Líneas de flujo:


Fin de programa: FIN

- Pseudocódigo
Es una serie de instrucciones en español que se aproxima a la codificación final sin
utilizar ningún lenguaje de programación:

Inicio de programa: INICIO

Fin de programa: FIN

Estructuras o instrucciones secuenciales: se ejecutan todas las instrucciones una a

continuación de otra sin saltarse ninguna.

Salida (ej: escribir en pantalla): ESCRIBIR “La suma es: “, a+b

Entrada (ej: leer desde teclado): LEER num1, cadena$

Proceso (operaciones): cuadrado = num * num

minicadena$ = SUBCADENA(cadena$,0,5)

Subprograma: procesar(num1,num2,num3)

Estructuras alternativas o condicionales: las instrucciones sólo se ejecutan si se

cumple la condición.

- Simple: SI condición ENTONCES

instrucciones
FIN-SI

- Doble: SI condición ENTONCES

instruccionesSI
SINO
instruccionesNO
FIN-SI

-Compuesta o múltiple: CASO expresión

valor1:
instruccionesA
valor2:
instruccionesB
 valorN:
instruccionesZ
ENOTROCASO:
instrucciones_por_defecto
FIN-CASO

Estructuras repetitivas o iterativas: las instrucciones pueden ejecutarse varias veces,

si se cumple la condición.

Bucle Para: PARA variable DESDE valorinicial HASTA valorfinal DE incremento

Instrucciones
FIN-PARA

Bucle Mientras: MIENTRAS condición

Instrucciones
FIN-MIENTRAS

Bucle Hasta: HACER

Instrucciones
HASTA condición

C. Programación estructurada

Es una metodología de programación, establece que un programa bien estructurado debe

tener las siguientes características:

- debe contener en su código información suficiente para ser comprendido.

- se pueden modificar las distintas partes del programa sin que afecte al resto del
programa.
- el programa se podrá realizar en partes fácilmente ensamblables.
- se usarán los siguientes elementos: estructuras básicas (secuencial, alternativa y
repetitiva), recursos abstractos (dividir el problema en partes hasta llegar a instrucciones
de programación) y razonamiento top-down (diseño descendente, de lo general a lo
particular).

D. Programación modular

El programa se divide en una serie de módulos que funcionan de forma independiente.

Estos módulos son más sencillos que el programa global y se enlazan mediante el paso
de parámetros.

Tiene ventajas como:

- permitir el trabajo en equipo
- facilita la depuración, reutilización y mantenimiento
E. Subrutinas

Son módulos o partes en que dividimos el programa bien para llamarlas desde distintos
puntos del programa sin tener que repetir el código; bien para hacer más legible el
programa principal (separándolo en partes bien diferenciadas); o bien para su
reutilización en futuros programas.

Hay dos tipos de subrutinas:

- Funciones: devuelven un valor. Se definen como:

SUBRUTINA nombreFuncion(parametro1, parametro2, …): tipo de valor de retorno
Instrucciones
RETORNAR valor
FIN-SUBRUTINA
En tipo de valor de retorno pondremos ‘Numerico’ o ‘Alfanumerico’

- Procedimientos: no devuelven ningún valor.

SUBRUTINA nombreProcedimiento(parametro1, parametro2, …)
Instrucciones
FIN-SUBRUTINA

F. Ejercicios

1. Diseñar el organigrama y pseudocódigo de los siguientes problemas:

a) Leer un número y escribir su cuadrado.

b) Leer dos números y decir cual es el mayor, si el primero, el segundo o si son iguales.

c) Leer tres números y escribirlos ordenados de menor a mayor.

d) Leer tres números y escribirlos ordenados de mayor a menor.

e) Leer cuatro números y escribir el mayor y el menor.

f) Leer tres cadenas: nombre, apellido1 y apellido2. Escribir el nombre completo y sus
tres iniciales.

g) Leer los tres coeficientes de una ecuación de segundo grado y escribir su solución:
ax^2+bx+c; x=-b ±RAIZ((b^2-4ac)/2a).

h) Leer tres números (longitud de los lados) y escribir si pueden formar un triángulo.

i) Leer el número del día de la semana (1-7) y escribir si ese día hay o no hay clase.

j) Leer el número del día de la semana (1-7) y escribir si ese día hay clase de FPR.

k) Leer el número del día de la semana (1-7) y escribir el nombre del día.
 l) Mostrar el menú: 1. Alta//2. Baja//3. Modificación//0. Salir//Elegir opción (0-3).
Gestionar este menú suponiendo que tenemos las instrucciones instrAlta, instrBaja, e
instrModificacion.

2. Diseñar el pseudocódigo de los siguientes problemas:

a) Escribir el cuadrado y el cubo de los 10 primeros números.

b) Escribir los 50 primeros números pares y su suma.

c) Leer un número y escribir su factorial (n!=n*(n-1)!; 0! = 1); ej: 5! = 5*4*3*2=120).

d) Generar 100 números aleatorios entre 0 y 1000 (incluidos) y escribir su suma.

e) Escribir los 20 primeros números de la serie 3, 6, 9, 12, …

f) Escribir los 25 primeros números de la serie 1, 1, 2, 3, 5, 8, … (F(n)=F(n-1)+F(n-2)).

g) Escribir los números de la serie: 4, 8, 11, 16, 20, 23, 28 menores de 1000 (+4+3+5).

h) Escribir los números de la serie: 3, 5, 8, 10, … (+2+3) cuya suma no pase de 1000.

i) Leer números hasta que se introduzca el 0. Escribir la suma de los introducidos antes
del primero mayor de 200 (excluido y puede no introducirse). Escribir la suma de los
introducidos después del primero mayor de 200 (excluido). Escribir el número de
valores introducidos (sin contar el 0 ni el primero mayor de 200).

j) Leer números hasta que se introduzca el 0. Escribir el número de valores introducidos

y la mayor secuencia de números consecutivos iguales indicando el número repetido.

k) Leer un número entero N y otro K y escribir el K_ésimo dígito de N empezando por

la derecha.

l) Escribir los tres primeros números perfectos (número natural igual a la suma de todos
sus divisores. Ej: 6=1+2+3).

m) Leer 100 números. Para cada 10 números escribir la decena actual y el mayor de la
decena. Escribir el mayor de todos y su decena.
TEMA 2: FUNDAMENTOS DE PROGRAMACION EN C

2.1 ELEMENTOS DE C
- Palabras reservadas: tiene un significado en lenguaje C, se escriben en minúsculas y
no pueden usarse como nombre de variables:
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

- Variables y constantes: se usan para manejar los datos, se declaran indicando el tipo
de datos que almacenan (las constantes van precedidas de ‘const’, ej: const float g=9.8).
Podemos definir una constante simbólica con #define: #define IVA 0.16;

Si una variable se declara ‘volatile’ indicamos que puede modificarse desde fuera del
programa: volatile int ticsreloj;.
Puede haber variables globales (comunes a todo el programa) y variables locales (se
definen dentro de una subrutina y sólo tienen sentido dentro de ella).

- Tipos de datos: se usan para crear las variables:

Tipos alfanuméricos:
Tipo Descripción Ejemplos
char Carácter char letra=´A´; char digito=´8´;
char[n] Cadena de caracteres de longitud máxima n-1 char diasemana[10]=”Martes”;
char[] Cadena de caracteres de longitud automática char nombre[]=”Lucas Pérez”;
char* Puntero a cadena de caracteres char* nombre=”Lucas Pérez”;

Tipos numéricos (algunos admiten modificadores: signed, unsigned, short y long):

Tipo Bytes Valor mínimo Valor máximo Ejemplo
char 1 -128 127 char minimo=-15;
unsigned char 1 0 255 unsigned char meses=12;
int 4 -2147483648 2147483647 int balance=-420000;
unsigned int 4 0 4294967295 unsigned int sueldo=3000;
short int 2 -32768 32767 short int saldo=-2000;
unsigned short int 2 0 65536 unsigned short int dias=365;
float 4 -3.4e38 3.4e38 float valorpi=3.14;
double 8 -1.7e308 1.7e308 double valorpi=3.1416;
long double 12 -3,4e4932 3.4e4932 long double valorpi= 3.1415926;

Array (Vector): es una colección de datos del mismo tipo, pueden tener varias
dimensiones (matrices), ej: char diasmes[12]={31,28,31,30,31,30,31,31,30,31,30,31};
int frutassemana[2][7]={{0,0,2,0,0,1,0},{0,0,0,0,3,0,0}};

Puntero: es una variable en la que se almacena una dirección de memoria.

- Se declaran añadiendo un ‘*’ al tipo de variable: double *puntPera;
- Se inicializan usando ‘&’ (dirección de): double pera; puntPera=&pera;
- Para acceder al contenido de la variable apuntada se usa * o ->.

Enumeración: asigna valores secuenciales enteros a una lista de objetos:

enum dias{lunes=1,martes,miercoles,jueves,viernes,sabado,domingo};

Estructura de datos (registro): es una agrupación de datos de igual o distinto tipo:

struct persona{
int dni;
char nombre[20];
char ape1[15];
char ape2[15];
char edad;
} persona1, persona2, persona3;
También podemos declarar variables una vez declarada la estructura:
struct persona persona4, persona5;
Para acceder a sus miembros se usa el punto ‘.’:
persona2.dni=12345678; persona4.edad=25;

Definición de nuevos tipos: podemos crear tipos de datos a medida y usarlos en el

programa: typedef tipoantiguo tiponuevo;
typedef double REAL;
REAL precio;
Typedef struct persona PERSONA;
PERSONA persona6;

- Tipos de operadores:

Aritméticos:
+ (suma)
- (resta)
* (multiplicación)
/ (división)
% (módulo)
- (signo)
++ (incremento)
-- (decremento)
+= (sumar al destino)
-= (restar al destino)
*= (multiplicar al destino)
/= (dividir el destino)
%= (dividir destino y dar resto)

Relacionales:
> (mayor)
>= (mayor o igual)
< (menor)
<= (menor o igual)
== (igual)
!= (distinto)
Lógicos:
|| (O)
&& (Y)
! (NO)

De manejo de bits:
| (O)
& (Y)
~ (NO)
^ (O exclusivo)
|= y &= y ^= (manejo de bits con el destino)
<< (desplazamiento a la izquierda)
>> (desplazamiento a la derecha)
>>= y <<= (desplazar el destino)

Condicional: evalúa expresión1, si es cierta devuelve expresión2 y si no expresión3:

expresion1? expresion2: expresion3; nota=(teoria >=5)? teor+pract: teoria;

Orden de precedencia: orden en que se evalúan los operadores de mayor a menor:

Operador Asociatividad
() [] -> .
! ~ - ++ -- (tipo) * & sizeof De derecha a izquierda
*/%
+-
<< >>
== !=
&
^
|
&&
||
?: De derecha a izquierda
= += -= *= /* %= >>= <<= &= ^= |= De derecha a izquierda
,

- Expresiones: combinan operandos y operadores, ej: bx+c*(3/2)

b<7

- Sentencias: especifican y controlan el flujo de ejecución del programa, son una

mezcla de palabras reservadas y expresiones, siempre acaban con ‘;’, ej: linea = bx+c;
Puede haber sentencias compuestas (bloque de sentencias {}): if(dia==7)
{
semana++;
dia =1;
}

- Comentarios: sirven de ayuda para entender el código, se delimitan por /* y */

2.2 NUESTRO PRIMER PROGRAMA C
Nuestro primer programa va a ser:

#include <stdio.h> /* incluir librería */

#include <stdlib.h> /* incluir librería */

int main(int argc, char *argv[]) /* función principal */

{ /* inicio del cuerpo de la función */
printf(“Hola mundo\n”); /* muestra un mensaje */
system("PAUSE"); /* comando MSDOS de pausa */
return 0; /* valor de retorno */
} /* fin del cuerpo de la función */

2.3 ESTRUCTURA DE UN PROGRAMA EN C

Encabezamiento: encabezan el programa.
- Directivas del preprocesador: empiezan por #, incluyen librerías y definiciones.
- Bloque del programador: declaraciones globales de variables y funciones.
Función main: función principal.
- Sentencias: cuerpo de la función.
Otras funciones: funciones definidas por el programador.

2.4 CONVERSION DE TIPOS

C realiza operaciones enteras si trabajamos con enteros y operaciones en punto flotante
si trabajamos con reales. Si realizamos operaciones entre distintos tipos de datos realiza
una conversión implícita de tipos:
- se convierte la variable menor en mayor (promoción) siguiendo el orden: char, int,
float, double, long double.
- el resultado se convierte al tipo de la variable destino pudiendo perderse información.
Ej: char a=99; int b=35; char c=a-b;

Se pueden evitar las conversiones implícitas realizando conversiones explícitas

poniendo el tipo deseado entre paréntesis antes de la operación (casting), ej:
int resultado = 2.5+2.8; /* vale 5 */
int resultado = (int) 2.5+ (int) 2.8; /* vale 4 */

2.5 ESPECIFICADORES DE FORMATO Y SECUENCIAS ESCAPE

Las funciones printf y scanf usan especificadores de formato para indicar el formato de
los datos, los principales son:
%d Entero con signo
%c Carácter
%s Cadena de caracteres
%e Real en notación científica
%f Real
%.2f Real con dos decimales
%g El real más corto de %e o %f
%o Entero con signo en octal
%u Entero sin signo
%x Entero con signo en hexadecimal

Las funciones printf y scanf usan secuencias escape para mostrar caracteres especiales,
los principales son:
CODIGO SIGNIFICADO CODIGO SIGNIFICADO
\0 Nulo, fin de cadena \a Alarma
\n Nueva línea \´ Comilla simple
\r Retorno de carro \” Comilla doble
\f Nueva página \\ Barra
\t Tabulador horizontal \? Interrogación
\v Tabulador vertical \N Valor octal N
\b Retroceso \xN Valor hexadecimal N

2.6 EQUIVALENCIAS ENTRE PSEUDOCODIGO Y C

INICIO int main(int argc, char *argv[]){
FIN }
ESCRIBIR “La suma es: “, a+b printf(“La suma es: %d”, a+b);
LEER num1, num2 scanf(“%d %d”, &num1, &num2);
LEER cadena$ gets(cadena);
resto = dividendo MOD divisor resto= dividendo%divisor;

cad$ = cad1$+cad2$ strcpy(cad, cad1);

strcat(cad, cad2);

minicadena$=SUBCADENA(cadena$,2,5) strncpy(minicadena, cadena + 2, 5);

SI condición ENTONCES if(condición){

Instrucciones instrucciones;
FIN-SI }

SI condición ENTONCES if(condición){

instruccionesSI instruccionesSI;
SINO } else {
instruccionesNO instruccionesNO;
FIN-SI }
CASO expresión switch (variable){
valor1: case valor1:
instruccionesA instruccionesA; break;
valor2: case valor2:
instruccionesB instruccionesB; break;

valorN: case valorN:

instruccionesN instruccionesN; break;
ENOTROCASO: default:
Instrucciones_por_defecto Instrucciones_por_defecto;
FIN-CASO }

PARA var DESDE vini HASTA vfin DE incr for(var=vini; var <= vfin; var += incr){
Instrucciones Instrucciones;
FIN-PARA }

MIENTRAS condición while(condición){

Instrucciones Instrucciones;
FIN-MIENTRAS }

HACER do{
Instrucciones Instrucciones;
HASTA condición while(!condición);

SUBRUTINA nomFunc(num, cad$): tipo tipo nomFunc(int num, char *cad){

Instrucciones Instrucciones;
RETORNAR valor return valor;
FIN-SUBRUTINA }

SUBRUTINA nomProc(num, cad$, …) void nomProc(int num, char *cad){

Instrucciones Instrucciones;
FIN-SUBRUTINA }

2.7 EJERCICIOS
1. Evalúa las siguientes expresiones (a mano) y realiza un programa que las codifique y
muestre los resultados: bx=1; b=3*2; c=(3/2)*5; a=bx+c*(3/2); b<7;
2. Codifica las variables: char c=’a’; int i=1; float f=2.01; short s=32767; int a=32767 y
evalúa (a mano) y calcula: c=c+f; f=f+i; i=i+f; s=a+s;.
3. Dado a=5.0; b=6.0; c=8.0; d=10 evalúa (a mano) y calcula a+b/c+d;.
4. Cuantas veces se ejecuta el bucle: for(i=1; i<1; i++){printf(“se ejecuta”);}.
5. Codificar en C todos los ejercicios del tema 1 y probarlos.
6. Suma 2.5 + 2.8 como reales y como enteros y muestra el resultado.
7. Queremos mostrar las manzanas que hemos comprado cada día de la semana (3 el
lunes, 6 el jueves y 9 el domingo).
8. Mostrar el valor de la variable g = 9.8 y su dirección de memoria.
9. Crea la estructura libro con título, autor, editorial, año y páginas; rellena los datos de
‘El Quijote’ muéstralos. Crea un nuevo tipo LIBRO.
10. Evalúa las siguientes expresiones (a mano) y realiza un programa que las codifique
y muestre los resultados: x=5; y=2; (x!=y)||(x<y); (x!=y)&&(x<y); (x!=y)||(x>y);
!(x<y);
11. Evalúa las siguientes expresiones (a mano) y realiza un programa que las codifique
y muestre los resultados: x=9; y=9; x++; ++y; x+=y; x/=y;
12. Evalúa las siguientes expresiones (a mano) y realiza un programa que las codifique
y muestre los resultados: unsigned int x=65; int y=114; x&y; x|y; x^y; x>>1; ~x;.
13. Imprimir la nota literal de un alumno dependiendo de su nota numérica.
14. Leer dos números y una operación (+,-,*,/,%) y muestra el resultado de la operación.
15. Escribir 100 veces “Prometo prestar atención en las clases”.
16. Calcular la pendiente de la recta que pasa por dos puntos leídos: m=(y2-y1)/(x2-x1).
17. Leer un número y decir si es par o impar y si es primo o no.
18. Leer un carácter e indicar si es un valor alfabético, numérico o especial (usar el
código ASCII o la fuente System).
19. Leer un número natural e indicar qué dígitos presenta y cuantas veces aparecen.

Funciones necesarias para realizar algunos ejercicios:

ALEATORIO(n) rand() % n Devuelve un nº aleatorio entre 0 y n-1.
RAIZ(n) sqrt(n) Devuelve la raíz cuadrada positiva de n.
TEMA 3: FUNCIONES EN C

3.1 DECLARACION DEFINICION Y ACCESO A FUNCIONES

Las funciones se declaran antes de la función ‘main’ indicando el tipo de valor de
retorno, el nombre de la función y sus argumentos. La declaración también se conoce
como prototipo de la función.
Formato de declaración: tipo nomFunc(tipo1 var1, tipo2 var2,…);
Ejemplo de declaración: int cubo(char num);
La declaración no es necesaria si definimos la función antes de utilizarla.

La definición consiste en la implementación de la función, codificando las instrucciones

de la función entre llaves, dentro de estas instrucciones habrá una o más instrucciones
return para devolver el valor de la función.
Formato de definición: tipo nomFunc(tipo1 var1, tipo2 var2,…){
Instrucciones;
return valor;
}
Ejemplo de definición: int cubo(char num){
return num * num * num;
}

El acceso a la función consiste en llamar a esa función pasándole valores para que nos
devuelva el resultado de la función. Al llamar a una función se pasa el control a dicha
función y se devolverá el control al punto donde se le llamó cuando se ejecute la
sentencia return.
Formato de llamada: nomFunc(var1, var2, …)
Ejemplo de llamada: printf(“el cubo de 99 es: %d”, cubo(99));

También se pueden utilizar variables globales, aunque no se recomienda, en vez de

pasar argumentos a las funciones, se pueden utilizar como un mecanismo de paso de
información o paso de datos complejos entre variables.

3.2 AMBITO DE LAS VARIABLES

Puede haber variables globales (comunes a todo el programa) y variables locales (se
definen dentro de una subrutina y sólo tienen sentido dentro de ella).

Si deseamos utilizar una variable global que aún no está definida, dentro de una función,
debemos indicar que es una variable externa: ‘extern tipo variable;’.

Las variables locales son automáticas por defecto (auto), se les asigna espacio en
memoria cada vez que se llama a su función.
Para que una variable local conserve su valor entre sucesivas llamadas a la función
debemos definirla como estática: ‘static int numveces;’. También podemos declarar
funciones y variables globales como estáticas (la función o variable, sería local a ese
fichero fuente).
Podemos indicar al compilador que almacene el valor de una variable en un registro de
la CPU: register int contador;.

3.3 PASO DE ARGUMENTOS

En C los argumentos se pasan por valor (paso por copia), se pasa una copia del valor
del argumento (el argumento original no se altera).
Si queremos alterar el valor de una variable pasada como argumento debemos pasar su
dirección usando punteros (paso por referencia).

Ejemplo de paso por valor:

void nomodifica( int v){
v=5; /* no modificará la variable de la función main */
}
void main(){
int var=0;
nomodifica(var);
}

Ejemplo de paso por referencia:

void simodifica( int *pv){
*pv=5; /* modificará la variable de la función main */
}
void main(){
int var=0;
simodifica(&var);
}

Los tipos de datos compuestos (arrays, estructuras, etc) deben pasarse por referencia.
Para acceder al contenido de una variable pasada por referencia usamos ‘*’, [] o ‘->’:

int entero=5;
char cadena[25]=”Hola”;
struct persona{
int dni;
char nombre[20];
char ape1[15];
char ape2[15];
char edad;
} persona1, persona2, persona3;

void mostrarentero(int *punt_int){

printf(“%d\n”, *punt_int);
}

void mostrarcaracter3(char punt_cadena[]){

printf(“%c\n”, punt_cadena[2]);
}

void mostrarape1(struct persona *punt_persona){

 printf(“%s\n”, punt_persona->ape1);
}

main(){
mostrarentero(&entero);
mostrarcaracter3(cadena);
strcpy(persona1.ape1, “Lopez”);
mostrarape1(persona1);
}

3.4 RECURSIVIDAD
Una función recursiva se caracteriza porque se llama a si misma.
Recursividad directa: la función se llama a si misma desde dentro de la función.
Recursividad indirecta: la función llama a una o más funciones y alguna de ellas, o
varias llaman a la función original.

Una función recursiva debe tener una condición de finalización.

Una función recursiva debe tener un caso general para hacer la llamada recursiva, en
cada llamada nos iremos acercando a la condición de finalización.

Las funciones recursivas disminuyen la memoria disponible en cada llamada, y pueden

llegar a agotarla.

3.5 FUNCIONES INCORPORADAS

C incluye multitud de funciones predefinidas agrupadas en categorías (E/S,
matemáticas, cadenas, …) que podemos usar en nuestros programas mediante la
directiva: #include <fichero.h>

Funciones de E/S <stdio.h>:

printf(“formato”, …) escribe con formato.
scanf(“formato”, …) lee con formato.
int getchar() lee un carácter (debemos pulsar Intro).
putchar(int) escribe un carácter.
int getch() lee un carácter sin que aparezca en pantalla.
putch(int) escribe un carácter (no trata \t, \n, etc).
int getche() lee un carácter y lo escribe.
gets(char *) lee una cadena.
puts(char *) escribe una cadena.

Funciones de conversión de datos <stdlib.h>:

int abs(int) valor absoluto.
float atof(char *) pasa de cadena a real.
int atoi(char *) pasa de cadena a entero.
char *itoa(int, char*, int base) pasa de entero a cadena en una base dada.
double strtod(char *nptr, char **endptr) pasa de cadena a real de doble precisión.
int tolower(int) pasa a minúsculas.
int toupper(int) pasa a mayúsculas.
3.6 EJERCICIOS
1. Escribe una función ‘cubo’ y otra ‘esprimo’ y crea un programa que muestre el cubo
de los 22 primeros números primos.
2. Crea dos variables globales char *meses[12] y char *dias[7]; crea las funciones ‘mes’
y ‘dia’ que acepten un valor numérico y muestren el mes y el día y haz un programa que
muestre cuales son los meses del año y los días de la semana.
3. Crea un procedimiento que muestre un texto adecuado si el número de veces que se
ha ejecutado es múltiplo de diez. Crea un programa que llame 100 veces al
procedimiento.
4. Crear una función para resolver una ecuación de segundo grado, ejercicio 1.g del
tema 1. La función tendrá cinco argumentos: los tres coeficientes, pasados por valor y
las dos posibles soluciones pasadas por referencia y devolverá el número de soluciones
encontradas.
5. Implementar el factorial de un número, ejercicio 2.c del tema 1 mediante
recursividad.
6. Leer 10 caracteres y mostrarlos en orden inverso junto con su código ASCII.
7. Determinar los posibles podios (1º, 2º y 3º) que pueden darse en una carrera de 8
corredores: Variaciones de n sobre m=m!/(m-n)!.
8. Calcular la probabilidad de que aparezcan las figuras al escoger tres cartas de un palo
de la baraja: Combinaciones de n tomados de m en m= m!/(n!(m-n)!).
9. Calcula el máximo común divisor de dos números leídos, utilizando la función
sigprimo(num, comienzo) que devuelva el siguiente divisor primo de num mayor que
comienzo).
10. Calcula el mínimo común múltiplo de dos números leídos, utilizando sigprimo.
11. Lee un número y di si es positivo o negativo.
12. Realiza una función que dada una cadena y un carácter diga el nº de veces que
aparece el carácter. Haz un programa que lea una cadena y diga cuantas veces aparece
cada vocal.
13. Haz un programa que simule una calculadora (suma, resta, producto, división,
potencia, raíz cuadrada ) usando un menú y funciones.
14. Tenemos una matriz de temperaturas tomadas en ‘n’ puntos durante ‘m’ días:
Lunes Martes Miérc. Jueves Viernes Sábado Domingo
Almería 10 9 8 7 6 5 4
Cádiz 5 4 3 2 1 0 -1
Córdoba 8 7 5 7 7 8 8
Granada 3 1 -1 -3 -3 -5 -7
Huelva -1 4 4 2 2 1 0
Jaén 8 7 5 7 7 8 8
Málaga 12 9 14 7 6 4 4
Sevilla 10 9 8 7 6 5 4

Calcula la temperatura máxima, mínima, media y la dispersión de la temperatura de

cada día y de todos los días. La dispersión es la raíz cuadrada de la varianza y la
varianza es:

Utiliza una función para calcular la máxima, mínima, media y otra función para calcular
la dispersión.
TEMA 4: ESTRUCTURAS Y UNIONES

4.1 UNIONES
Una estructura de datos (registro) es una agrupación de datos de igual o distinto tipo.
Una unión es una agrupación de datos de igual o distinto tipo, compartiendo el mismo
espacio de memoria. Por ejemplo, si un alumno se identifica bien por su dni o bien por
su matrícula:
union alumno{
char matricula[6];
int dni;
}
Los datos deben ser excluyentes y se suele poner un dato fuera de la unión indicando
cual es el dato válido dentro de la unión:
enum datosunionalumno{ matr, DNI};
struct alum{
datosunionalumno datovalido;
union alumno estudiante;
}

4.2 PUNTEROS A ESTRUCTURAS

Al declarar un puntero a una estructura, no se reserva espacio para la estructura. El
puntero es inservible hasta que se inicializa con una dirección de una estructura:
struct alum *punt_alum;
punt_alum->alumno.dni=12345678; /* Da error en tiempo de ejecución */
Podemos reservar espacio dinámico con ‘malloc’:
struct alum *punt_alum=(struct alum *) malloc( sizeof(struct alum));
punt_alum->datovalido=DNI;
punt_alum->alumno.dni=12345678;

4.3 ARRAYS A ESTRUCTURAS

Los arrays de estructuras se definen y se usan igual que los arrays de tipos básicos:
struct alum alumnos[10];
alumnos[2].datovalido=matr;
strcpy(alumnos[2].matricula, “A1524”);

Podemos usar punteros para recorrer vectores:

struct alum *punt_alum=alumnos;
for(int i=0; i<10;i++){
printf(“%d\n”, punt_alum->dni);
punt_alum++;
}

4.4 ESTRUCTURAS AVANZADAS

Una estructura puede tener campos que sean punteros a otra estructura del mimo tipo, a
esta construcción se le denomina estructura encadenada. Ejemplo:
struct persona{
int dni;
char nombre[20];
char ape1[15];
char ape2[15];
char edad;
struct persona *siguiente_persona;
};
Esta idea permite crear estructuras de datos dinámicas (listas, colas, árboles) que
administran la memoria mejor que los arrays.
Para indicar que una estructura no apunta a otra estructura de su mismo tipo (sería el
último elemento de la estructura) se usa ‘null’. Ejemplo:
struct persona *punt_pers=(struct persona *) malloc( sizeof(struct persona));
punt_pers->siguiente_persona=null;

4.7 EJERCICIOS
1. Utiliza la función ‘sizeof(variable)’ para mostrar el tamaño de la estructura ‘libro’ del
ejercicio 2.9 y de cada uno de sus campos.
2. Muestra el tamaño de la unión alum del apartado 4.1 y de cada uno de sus campos.
3. Crea una estructura que guarde el NIF usando los campos DNI y LETRA. Crea una
función para validar el dni y su letra teniendo en cuenta que la letra se obtiene del array
'TRWAGMYFPDXBNJZSQVHLCKE' y la posición dentro del array es el resto de
dividir el dni entre 23.
4. Escribe una estructura para manejar datos de meses: el número de días del mes y el
orden en que se suceden a lo largo del año.
5. Escribe una estructura para manejar datos de coches: modelo, marca, potencia,
consumo en ciudad y en carretera, presión de neumáticos y velocidad máxima.
6. Representa con una estructura un punto cartesiano. Crea una función que calcule el
punto medio de una recta que pase por dos puntos.
7. Escribe una estructura para manejar datos fechas: número de día, día de la semana,
mes y año.
8. Escribe una estructura que represente las cartas de la baraja y otra que represente una
baza en el juego de la escoba (nº de cartas, número de sietes, nº de oros y la posibilidad
de hacer escoba).
9. Crea una estructura con una unión que permita almacenar los precios de productos en
pesetas o euros.
10. Escribe un vector de uniones que represente las fichas de casino que posee un
jugador, sabiendo que es daltónico (no puede reconocer más que algunos colores) y que
sólo conoce los valores asociados que tienen algunos colores de fichas.
11. Dado el siguiente código:
struct nomb{
char nombre[20];
char ape1[20];
};
struct bem{
int brazos;
struct nomb registro;
 char origen[30];
}
struct bem *pb;
struct bem deb={6,{“Santiago”,”Bernabeu”},”Chamartin”};
pb=&deb;
Qué imprimirán las sentencias:
printf(“%d”, deb.brazos);
printf(“%s”, pb->origen+2);
printf(“%s”, (*pb)..origen);
12. Describe con una unión las posibles jugadas del póker (reponer, escalera de color,
póker, foul, trío, color, dobles parejas y parejas) sabiendo que es relevante representar el
valor más alto de la escalera, el valor de los póker, parejas y tríos, y los dos valores del
foul y de las dobles parejas.
13. Escribe un programa que lea una fecha (día, mes y año) y que utilice las estructuras
de los ejercicios 4 y 7. Crea una función que devuelva el nº de días trascurridos en ese
año hasta la fecha indicada (supón que no hay bisiestos). Mostrar ese nº de días
transcurridos y mostrar el nº total de días hasta la fecha actual.
14. Representa la estructura encadenada de un nodo de un árbol binario, sabiendo que
un tiene un único nodo raíz, y cada nodo puede tener hasta dos nodos hijos.
15. Representa la estructura encadenada de la situación de las piezas de un jugador en
un tablero de ajedrez en una partida ya empezada.
16. Crea un programa que reciba un vector con 4 puntos cartesianos y determine si
forman un cuadrado, un rectángulo o ninguna de las figuras anteriores.
17. Usa las estructuras del ejercicio 8 y crea un programa que asigne un valor a los
campos de la estructura ‘jugada_escoba’ con un vector de estructuras de tipo carta.