Lenguaje C

Programacin en
lenguaje C
Ignacio Alvarez Garca

Julio - 2013
Indice
Introduccin al computador y el lenguaje C
Datos, expresiones y algoritmos
Funciones
Tablas y punteros
Cadenas de caracteres
Operaciones con valores binarios
Preprocesador y compilacin separada
E/S en archivos y dispositivos
Criterios de buena programacin
El computador
Un computador es una mquina de ejecucin

secuencial de instrucciones:
Cada instruccin es una operacin muy sencilla, que utiliza
datos fuente y almacena el resultado en datos destino:
MOV
ADD
NEG
DIV
dest,src
dest,src
dest
dest,src
; equivale a dest = src

; equivale a dest = dest + src
; equivale a dest = -dest
; equivale a dest = dest / src
Los datos (o variables) son lugares de almacenamiento de

informacin: guardan valores que pueden ser requeridos o
modificados posteriormente.
Un Programa es una secuencia de instrucciones sencillas.
Ej: calcular de la media de 3 datos x1,x2,x3 y guardarla en el dato m.
MOV m,x1
ADD m,x2
ADD m,x3
DIV m,3
; m = x1
; m = m+x2 = x1+x2
; m = m+x3 = x1+x2+x3
; m = m/3 = (x1+x2+x3)/3
2
El computador
Codificacin de datos
Una misma cantidad (ej. 23) se puede expresar en mltiples
sistemas de numeracin:
101 100
Codificacin ponderada en base 10 (decimal):
Nmeros romanos:
2 3
XXIII
24 23 22 21 20
Codificacin ponderada en base 2 (binario):
10111
Algunos sistemas de numeracin favorecen la realizacin

simple de operaciones:
23
18
+ 10010
10111
41
101001
Misma cantidad expresada
en sistemas de numeracin diferentes
El computador
En el computador, datos e instrucciones se codifican

en binario.
Datos e instrucciones se almacenan en memoria,
organizada en direcciones (0, 1, , 2n-1).
Cada direccin almacena 1 byte (8 bits) en codificacin
ponderada base 2. Direccin Contenido
000..00
000..01
000..10
01101100
00101110
11111100
...
Inst1:
Inst2:
11101100
MOV X,3
01101101
MOV Z,X
Inst3:
11101011
ADD Z,Y
...
X:
Y:
Z:
00000000
0
00000111
7
00000010
2
Instrucciones codificadas
en binario
Datos codificados en
binario
...
El computador
Un programa es una secuencia esttica de instrucciones,

que se ejecutan secuencialmente.
Para que un programa haga cosas diferentes en funcin
de resultados previos, se dispone de instrucciones
especiales:
JMP Inst1
; vuelve a ejecutar la instruccin que se encuentra en Inst1:

>
<
CMP dest,src
Flags
; [ZF, CF,OF,SF]= (dest- src)
JIFLE Inst1
; vuelve a ejecutar la instruccin que se encuentra en Inst1:
0?
slo si los flags indican resultado

Jump If Lower or Equal
5
El computador
Ejemplos de comportamiento dinmico en ejecucin:

y = | x |:
MOV y , x
;y=x
CMP y , 0
; [ZF,CF,] = (y 0) { >, , <, } 0
JIFGE
InstFinal ; Si el resultado fue , salta a InstFinal. Si no, sigue
NEG y
; y = -y (slo se ejecuta si el resultado no fue )
InstFinal: (instrucciones para usar nuevo valor de y)
y=x!:
Bucle:
MOV y , 1
MOV n , x
MUL y , n
SUB n , 1
CMP n , 1
JIFG Bucle
;y=1
;n=x
;y=y*n
;n=n-1
; [ZF,CF,] = (n 1) { >, , <, } 0
; Si el resultado fue >, salta a Bucle
El computador
Para que un computador ejecute un programa:

Se cargan los cdigos binarios de sus instrucciones y datos en
memoria.
Se ordena ejecutar a partir de la primera instruccin
Una vez ejecutada la cada instruccin, pasar automticamente a
la siguiente.
De dnde se sacan los cdigos binarios de

instrucciones y datos ?
Se utiliza un programa ensamblador que traduzca texto en
formato lenguaje mquina a los cdigos binarios:
src se indica de
forma inmediata
0101 00 00110010 11 00000001

dest se indica por
Direccin de n
Valor 1 en binario
su direccin de
memoria
SUB
SUB
n,1
El computador
Cmo se cargan instrucciones y datos en memoria?

Se utiliza un programa cargador que vuelque los contenidos en
memoria.
Cmo se ordena la ejecucin del programa?

Se indica al programa cargador la direccin de la 1 instruccin.
Una vez se ejecuta la 1 instruccin, las siguientes se ejecutan
secuencialmente.
Es necesario conocer y escribir programas en lenguaje

mquina?
No, existen programas ms sofisticados (compiladores e
intrpretes) que nos permiten traducir a cdigo mquina desde
lenguajes de alto nivel (similares al lenguaje matemtico).
8
El computador
Ms informacin:
Presentacin ms detallada (con animaciones) del
funcionamiento interno del computador:
http://isa.uniovi.es/~ialvarez/Curso/descargas/Funcionamiento%20Computador.pps
El lenguaje de alto nivel (C)
Un lenguaje de alto nivel permite escribir programas en

una notacin similar a la utilizada habitualmente en el
clculo matemtico.
Ej. media de 4 valores:
Ensamblador
Lenguaje C
MOV
ADD
ADD
ADD
DIV
m=(x1+x2+x3+x4)/4;
m,x1
m,x2
m,x3
m,x4
m,4
La tarea de traducir el texto (cdigo fuente) a

instrucciones de mquina la realiza un programa
compilador.
El cdigo de alto nivel es ms fcil de escribir, entender,
y portar (independiente del lenguaje mquina).
10
Para escribir programas en lenguaje de alto nivel, el

programador debe:
Conocer y utilizar de forma precisa la notacin que es capaz de
entender el compilador.
Utilizar los tipos de datos adecuados para las variables y
constantes. Los ms bsicos son: int, float, char.
Saber describir un algoritmo complejo (a partir de su
conocimiento del problema a solucionar) en una secuencia de
instrucciones manejables por el compilador.
Ejemplo: calcular media de 4 valores.

De qu naturaleza son los datos a manejar?
Enteros: ej., los 4 valores representan el n de alumnos de 4 clases.
Reales: ej., los 4 valores representan las temperaturas de 4 zonas del aula.
Qu secuencia de operaciones permite obtener la media?

La media se obtiene sumando todos los valores y dividiendo por el n de ellos.
11
El programador debe utilizar de forma precisa la notacin

que es capaz de entender el compilador:
cada declaracin o
Declaraciones previas:
#include, #define, etc.
Declaracin de programa principal:

main() { . }
Dentro de main() { }:
Declaracin de las variables con sus tipos.
Cdigo para obtener datos de partida del
exterior (teclado, archivo, sensor, ).
Cdigo para procesar los datos.
Cdigo para enviar datos resultado hacia el
exterior (pantalla, archivo, accionador, ).
expresin se termina en ;
#include <stdio.h>
#include <stdlib.h>
#define N 4
main()
{
int x1,x2,x3,x4; // Datos
float m; /* Media */
printf("Introduzca
scanf("%d",&x1);
printf("Introduzca
scanf("%d",&x2);
printf("Introduzca
scanf("%d",&x3);
printf("Introduzca
scanf("%d",&x4);
Comentarios (el compilador no los

tiene en cuenta):
Resto de lnea: // texto informativo
Multi-lnea: /* texto informativo */
x1: ");
x2: ");
x3: ");
x4: ");
m=(x1+x2+x3+x4)/N;
printf("La media es %f\n",m);
}
12
Entrada/salida por consola en C
Salida por consola (pantalla):

printf(texto a escribir,valor1,valor2,);
Escribe en pantalla los caracteres de la cadena de texto,
excepto cuando aparece %ALGO. El %ALGO lo sustituye por el
valor correspondiente (por orden):
%d: entero
%f: real (float)
%c: carcter
%s: cadena de caracteres
\n en el texto significa retorno de carro.
Ejemplo:
Resultado en pantalla:
int alumnos;
Hay 12 alumnos, nota media 7.25
float nota_media;
_
alumnos=12;
nota_media=7.25;
printf("Hay %d alumnos, nota media %f\n",alumnos,nota_media);
13
Entrada/salida por consola en C
Entrada de consola (teclado):

scanf(texto,direccion_valor1,direccion_valor2,);
Espera por teclado la pulsacin de una secuencia de
caracteres terminada en INTRO.
El texto slo debe contener cadenas de formato (%ALGO ).
Las direcciones se indican anteponiendo a cada variable el
carcter &:
Resultado en pantalla:
Ejemplo:
Introduzca alumnos y nota media: 12 7.25

Hay 12 alumnos, nota media 7.25
_
int alumnos;
float nota_media;
printf("Introduzca alumnos y nota media: ");
scanf("%d%f",&alumnos,&nota_media);
printf("Hay %d alumnos, nota media %f\n",alumnos,nota_media);
14
Ejercicios propuestos
1)
2)
3)
4)
5)
6)
Realizar un programa que pida los lados de un rectngulo, y calcule y

escriba su diagonal.
Realizar un programa que pida los lados de un paraleleppedo
rectangular, y calcule y escriba su diagonal.
Pedir el radio y el n de lados de un polgono regular, y calcular su
permetro (comprobar que el permetro se acerca a 2 al incrementar el n
de lados).
Pedir dos puntos en el espacio bidimensional, y calcular el ngulo con el
eje x de la recta que los une.
Pedir dos puntos de una recta en el espacio 2D y escribir el valor de la
ordenada y para cualquier valor de la abscisa x.
Realizar un programa que calcule el da de la semana de cualquier fecha
(http://es.wikipedia.org/wiki/Congruencia_de_Zeller).
NOTAS: Algunas operaciones matemticas en C (incluir <math.h>)
x2 = x*x
= sqrt(x)
Operaciones trigonomtricas: sin(x),cos(x),tan(x),atan(x)
Divisin entera. Cociente = a/b ; Resto = a%b
15
Indice
Funciones
Tablas y punteros
16
Tipos de datos
Los datos pueden ser de varios tipos. Los ms bsicos:

int: para almacenar y realizar operaciones con valores enteros.
float: para almacenar y realizar operaciones con valores reales.
char: para almacenar y realizar operaciones con texto.
El cdigo programa puede utilizar datos de dos

procedencias diferentes:
Variables: valores que pueden cambiar a lo largo del programa.
Ejs:
int n_alumnos;
float nota_media=7.25;
// Variable tipo entero, sin inicializar

// Variable tipo real, valor inicial 7.25
Constantes: valores que no cambian a lo largo del programa.

Ejs: 7 (das de la semana), 3.1416 (), Introduzca x1: (texto), etc.
Preferible declararlas con #define al principio del cdigo:
#define PI
3.1416
y usar despus mediante el nombre:

z = 2 * cos(PI/4);
17
Tipos de datos
Y si hay datos que no son de los tipos bsicos?

Ejemplos: meses del ao, frutas, colores, num. complejos, etc.
Hay que buscar la mejor conversin de nuestros tipos de

datos a los manejables por el lenguaje:
Meses del ao: se puede utilizar un int que valga 1 para Enero, 2 para
Febrero, , 12 para Diciembre.
Frutas: un int para cada tipo de fruta: 1 para Manzana, 2 para Pera, .
En los casos anteriores, es convienente asociar cada valor a una
constante con #define:
#define ENERO
#define FEBRERO
int mes;
mes=FEBRERO;
1
2
Colores: un color es la combinacin de 3 valores (RGB); se pueden

utilizar 3 float (uno para cada componente) con valores de 0 a 1.
Complejos: utilizar 2 float (parte real, parte imaginaria).
18
Sentencias y expresiones
Sentencia bsica: la asignacin.

variable = expresin ;
Expresin: resultado de una operacin matemtica,

utilizando los operadores tpicos.
Aritmticos: + - * /
Parntesis: ( )
etc.
Los operandos pueden ser:

Variables
Constantes
Resultados de funciones (sin,cos,tan,atan,exp,sqrt,pow,log,log10,)
Ejemplo de sentencia:
z = 3*y + (2*cos(PI/4));
// Incluir <math.h> para usar cos()

19
Expresiones
A tener en cuenta al realizar expresiones:

El compilador dividir la expresin en una secuencia de
operaciones, por orden de prioridad (similar a nuestro lenguaje
matemtico):
z = 3*y + (2*cos(PI/4)); // Incluir <math.h> para usar cos()
Los clculos internos (secuencia de instrucciones de mquina

generada por el compilador) se ejecutarn por este orden:
3.1416 / 4
cos(r1)
2*r2
3*y
r4+r3
z=r5
r1
r2
r3
r4
r5
r6
Los valores r1, r2, se almacenan

temporalmente en los registros
de la CPU
(z pasa a valer r5)
20
Expresiones

ATENCION !! Cada operacin parcial utiliza los tipos de datos
que tiene como operandos, y realiza la operacin y devuelve el
resultado segn esos tipos:
op1(int) OP op2(int)
op1(float) OP op2(float)
op1(int) OP op2(float)
op1(float) OP op2(int)
r(int)
r(float)
r(float)
r(float)
Ejemplo:
int x=4,y=8;
float z;
z=x/y;
// Resultado esperado: z=0.5
Ejecucin:
x(=4 int) / y(=8 int)
z = r1(=0,int)
r1 (=0, int)
r2 (=0,float) (z pasa a valer 0)
21
Expresiones

No hay que cambiar el tipo de un dato por culpa de las
expresiones en que va a estar involucrado. Se puede forzar un
cambio de tipo de datos en una expresin mediante el operador
molde (cast):
(tipo) op
r (tipo)
r es lo ms parecido posible a op en el nuevo tipo
Ejemplo:
int profes=4,alumnos=8;
// El n de profesores y alumnos es entero
float ratio;
ratio=(float) profes/(float) alumnos;
Ejecucin:
(float) profes(=4 int)
(float) alumnos(=8 int)
r1(=4 float) / r2(=8 float)
ratio = r3(=0.5,float)
r1 (=4, float)
r2 (=8, float)
r3 (=0.5, float)
r4 (=0.5,float)
(ratio pasa a valer 0.5)
22
Sentencias de control
La ejecucin de sentencias es secuencial, salvo si se

usan sentencias de control:
Bloque:
{
sentencia1;
sentencia2;
// Las sentencias incluidas en un bloque

// son tratadas como una sola por otras
// sentencias de control
Alternativa:
if (condicion)
sentenciaSiTRUE;
else
sentenciaSiFALSE;
// Slo se ejecuta si se cumple la condicin

// La clusula else es opcional
// Slo se ejecuta si no se cumple la condicin
Bucle while:
while (condicion)
sentenciaARepetir; // Repite sentencia mientras se cumpla condicin
Bucle for:
for (inicializacion ; condicion_continuidad ; paso )
sentenciaARepetir;
23
Condicin de una sentencia de control:

Es un valor entero que se interpreta como FALSO si vale 0, y
como VERDADERO si es distinto de 0.
Suele ser el resultado de una expresin con operadores
relacionales:
(op1 == op2)
(op1 != op2)
(op1 > op2)
(op1 >= op2)
(op1 < op2)
(op1 <= op2)
Ejemplo: y = | x |
if (x>=0)
y = x;
else
y = -x;
Verdadero (0) si ambos son iguales, Falso (0) si no.

Verdadero si ambos son distintos
Verdadero si op1 es mayor estricto que op2
La sentencia que depende del if,

else, while o for, se indenta
una tabulacin a la derecha por
claridad.
24
Condicin de una sentencia de control:

Los operadores relacionales se pueden encadenar con
operadores lgicos a nivel de palabra:
(r1 && r2)
(r1 || r2)
(! r1)
Verdadero si r1 Y r2 son verdaderos, falso en caso contrario

Verdadero si r1 O r2 son verdaderos, falso en caso contrario
Verdadero si r1 es falso, falso si r1 es verdadero
Ejemplo: y = min ( | x | , 4 )
if ((x>4) || (x<-4))
y = 4;
else
{
if (x>=0)
y = x;
else
y = -x;
}
Usar { } cuando una if, else,

for while debe afectar a un
conjunto de sentencias.
Indentar correctamente el texto

facilita su lectura.
25
Algoritmos
Usando variables, constantes, expresiones y sentencias

de control, el programador debe trasladar su pensamiento
lgico (algoritmo) a una secuencia de instrucciones que lo
desarrollen.
Aunque las expresiones de alto nivel son ms complejas,
siguen estando lejos del pensamiento humano.
Ej: fact = n!
En nuestra forma de pensar: fact = n * (n-1)* (n-2) * * 1
La expresin anterior no es realizable directamente en lenguaje C: hay que
pensar un algoritmo que pueda ser desarrollado en una secuencia de
instrucciones:
fact=1
Repetir desde i=1 hasta n
fact=fact*i
Al llegar aqu: fact=n!
26
Algoritmos
Una vez pensado el algoritmo, hay que traducirlo al

lenguaje C:
Detectar las variables necesarias y sus tipos.

Dar valores iniciales a las variables que lo requieran.
Convertir el algoritmo en expresiones y sentencias de control.
Usar los resultados en el modo deseado.
Comprobar el funcionamiento con casos conocidos.
Algoritmo:
fact=1
fact=fact*i
Al final, fact=n!
Lenguaje C:
int n,i,fact;
printf("Introd n: ");
scanf("%d",&n);
fact=1;
for (i=1;i<=n;i++)
fact=fact*i;
printf("%d! = %d\n",n,fact);
27
Algoritmos
Dos formas bsicas de pensar algoritmos:

Pseudo-cdigo:
Similar al lenguaje de programacin, pero sin sus restricciones de formato
fact=1
fact=fact*i
Diagrama de bloques:
fact=1
i=1
F
i<=n ?
T
fact=fact*i
i=i+1
28
Algoritmos
Cuando pensamos algoritmos:

Desarrollo top-down: diseccionar el algoritmo total en grandes
bloques, luego ir resolviendo cada bloque.
Al final, tenemos que llegar a instrucciones sencillas realizables
mediante el lenguaje.
Ej: calcular ex en desarrollo de serie de Taylor.

=0 !
No se puede llegar hasta

(no acabara nunca)
// Algoritmo completo
exp_x=0
Repetir desde n=0 hasta nmax
exp_x=exp_x + xn / n!
// x_n=xn
x_n=1
x_n=x_n*x;
// fact_n=n!
fact_n=1
fact_n=fact_n*i
29
Algoritmos
Al traducir los algoritmos al lenguaje C:

Detectar las nuevas variables necesarias y sus tipos.
Intentar buscar optimizaciones.
Ej: calcular ex en desarrollo de serie de Taylor.
Aprovechamos que:
xn=x*xn-1
n!=n*(n-1)!

=0 !
// Algoritmo completo
exp_x=1
x_n=1
fact_n=1
Repetir desde n=1 hasta nmax
x_n = x_n * x
fact_n = fact_n * n
exp_x=exp_x + x_n / fact_n
La iteracin n=0 da x0/0! = 1
OJO! Las optimizaciones hacen que nuestro cdigo se ejecute

ms rpido (menos operaciones), pero dificultan su legibilidad.
30
Algoritmos
Una vez escrito el cdigo, hay que probarlo !!

Un programa sintcticamente correcto (compila sin
errores) no es equivalente a un programa correcto:
Pueden producirse numerosos fallos en el proceso:
Algoritmo mal pensado: no hace lo que se espera.
Mala traduccin: no se convierte correctamente al lenguaje.
Mal uso de variables: modificaciones inesperadas o en lugares inapropiados,
errores en tipos de datos, etc.
Fallos de clculo: no se estima correctamente lo que el lenguaje va a hacer.
Errores ocasionales: no se han tenido en cuenta todas las opciones que
pueden suceder.
La prueba de los programas y correccin de errores en su cdigo

se llama depuracin.
La depuracin es un paso clave en el desarrollo de programas.
31
Ms sobre tipos de datos
char,float, int son los tipos de datos ms utilizados de

los disponibles en C.
En ocasiones hay que seleccionar otros tipos para
ajustarse al rango/resolucin de los valores a manejar:
Tipos enteros, segn el n de bits utilizados:
char, short, int, long (de menor a mayor n de bits).
A mayor n de bits, mayor rango (2n valores diferentes).
Todos ellos admiten unsigned (slo positivos) o signed (por defecto).
Rango
Rango
unsigned
signed
Mn (0) Mx (2n-1) Mn (-2n-1) Mx (2n-1-1)
N bits
mn
N bits
VC++
char
255
-128
127
short
>=char
16
65535
-32768
32767
32
4.294.967.295 -2.147.483.648 2.147.483.647
32
4.294.967.295 -2.147.483.648 2.147.483.647
int
long
>char
>=short
>short
>=int
32
char,float, int son los tipos de datos ms utilizados de

los disponibles en C.
En ocasiones hay que seleccionar otros tipos para
ajustarse al rango/resolucin de los valores a manejar:
Tipos reales, segn el n de bits utilizados:
float, double, long double (de menor a mayor n de bits).
A mayor n de bits, mayor rango y resolucin (precisin).
Se codifican en notacin exponencial: 1.mant x 2exp
N bits
mn
N bits
VC++
float
32
32
double
>=float
64
long double
>float
>=double
Codificacin partes
Capacidad de
representacin
Mx
Resolucin
Exp.
Mant.
8 bits
23 bits
1.Mant
3.4x1038
>=6 dgitos
decimales
11 bits
52 bits
1.Mant
1.8x10308
>=15 dgitos
decimales
exceso a 127
exceso a 1023
id. a double
33
El programador puede definir nuevos tipos de datos:

Estructuras
Uniones
Enumeraciones
Las estructuras permiten agrupar varias variables bajo

un solo tipo, de forma que se pueden usar como
conjunto o aisladamente cuando convenga:
Declaracin:
struct nombre
{
tipoA campo1A,campo2A;
tipoB campo1B;
} ;
Uso:
struct nombre vble;
vble.campo1A=;
if (vble.campo1B==)
;
34
El programador puede definir nuevos tipos de datos:

Estructuras
Uniones
Enumeraciones
Las estructuras permiten agrupar varias variables bajo

un solo tipo, de forma que se pueden usar como
conjunto o aisladamente cuando convenga:
Declaracin:
struct nombre
{
tipoA campo1A,campo2A;
tipoB campo1B;
} ;
Uso:
struct nombre vble;
vble.campo1A=;
if (vble.campo1B==)
;
35
Ejemplos de uso de estructuras:

Manejo de colores: estructura con tres reales para las
componentes r,g,b:
struct color
{
float red,green,blue;
} ;
struct complejo amarillo;
amarillo.red=1; amarillo.green=1 ; amarillo.blue=0;
Estructura para dibujo en 2D de un crculo:

struct circulo
{
float centroX,centroY,radio;
struct color colorBorde,colorFondo;
int anchoBorde,dibujarFondo;
} ;
struct circulo sol;
...
sol.colorFondo=amarillo;
sol.dibujarFondo=1;
...
36
1)
Obtener las races (reales o complejas conjugadas) de un polinomio de

grado 2: p(x)=a.x2+b.x+c.
2
=
4
2
2)
Realizar un programa que calcule el n de equipos titulares diferentes que

puede realizar un entrenador, segn el n de jugadores convocados y el n
de jugadores que se alinean.
3)
Realizar un programa pida un n entre 0 y 255, y escriba el valor binario

equivalente (8 bits).
Comprobar que las dos aproximaciones siguientes se acercan al nmero
e cuando n .
4)
5)
Calcular el mnimo de un polinomio de grado 2 entre dos lmites, utilizando

la aproximacin Golden-Search
(http://pages.intnet.mu/cueboy/education/notes/algebra/goldensectionsearch.pdf ).
NOTAS: Algunas operaciones matemticas en C (incluir <math.h>)
xn = x*x**x
= sqrt(x)
(x debe ser 0)
37
Indice
Funciones
Tablas y punteros
38
Funciones
Al desarrollar nuestros algoritmos, detectamos porciones

de cdigo repetitivas.
En estas porciones de cdigo:
Slo cambian las variables afectadas y/o sus valores.
Se requieren nuevas variables para un uso temporal.
Ej: calcular
=
!
!
// Algoritmo
comb_m_n = m! / (m-n)!
// fact_m=m!
fact_m=1
Repetir desde i=1 hasta m
fact_m=fact_m*i
// fact_m_n=(m-n)!
fact_m_n=1
Repetir desde i=1 hasta m-n
fact_m_n=fact_m_n*i
El clculo de m! y (m-n)! es idntico, pero los valores de partida son distintos.

El resultado de los dos factoriales se almacenar en variables distintas.
Para el clculo de factorial se requiere temporalmente una variable ndice, que
despus no se utiliza ms.
39
Funciones
Las porciones de cdigo repetitivas (o que pudieran

serlo) se desarrollan en forma de funciones
Una funcin, para el resto del cdigo, trabaja como
una caja negra:
Funcin
Entradas
(parmetros)
Vbles
locales
Cdigo
Salida (valor devuelto)
Las entradas (parmetros) de la funcin son los valores que modifican

su comportamiento.
La salida de la funcin es el valor calculado a partir de los parmetros.
La funcin necesita para su desarrollo variables temporales (locales) y
un cdigo a ejecutar
Factorial
n
i
fact
fact=1
fact=fact*i
fact=n!
40
Funciones en C
Declaracin de una funcin
Parmetros
tipoDvto NombreFuncion(tipo1 param1,tipo2 param2,...)

{
tipoDvto resultado;
tipoA varlocalA;
tipoB varlocalB1,varlocalB2;
sentencias a ejecutar terminadas en ;
(slo pueden usar los parmetros y
las variables locales)
Cabecera
Declaracin variables locales
Cdigo de la funcin
return resultado;
}
El cdigo de la funcin slo depende de s

misma: dar nombres generales a su
identificador, parmetros y variables locales.
Una funcin debe ser declarada antes de ser
utilizada en el resto del cdigo.
int Factorial(int n)
// Calcula y devuelve n!
{
int fact;
int i;
fact=1;
for (i=1;i<=n;i++)
fact=fact*i;
return fact;
}
41
Invocacin de funciones
Una vez declarada una funcin, puede ser llamada (o invocada)

desde cualquier expresin en otra zona del cdigo (funcin llamante),
pasando como parmetros los valores deseados y utilizando su
resultado.
Cuando se invoca a una funcin, se deja de ejecutar temporalmente
el cdigo de la llamante, y se vuelve al mismo al finalizar.
No hay que indicar tipos en la llamada, pero stos deben ser
compatibles con los declarados.
int Factorial(int n)
// Calcula y devuelve n!
{
...
}
Aunque estas variables se

llamen igual, son distintas
(estn en zonas de memoria
diferentes)
...
// En otra zona del programa (funcin llamante)
int m, n,comb;
... Damos valores a m,n ...
comb=Factorial(m)/Factorial(m-n);
... Usamos comb ...
42
Funcionamiento interno
Cuando se invoca a una funcin, se deja de ejecutar temporalmente

el cdigo de la llamante, y se vuelve al mismo al finalizar.
Las variables locales de la funcin llamante mantienen sus valores,
pero no son utilizables en la invocada.
Las variables locales y parmetros de la funcin invocada tienen una
vida temporal: slo existen mientras se est ejecutando.
Los parmetros toman su valor inicial en la invocacin, pero son
variables nuevas (y por tanto se pueden modificar sin afectar a las
variables de la llamante).
Al regresar a la llamante, slo se puede utilizar el valor devuelto.
El detalle del funcionamiento (pila LIFO) se puede observar en:
http://isa.uniovi.es/~ialvarez/Curso/descargas/Funcionamiento%20Computador.pps
43
Uso de funciones
Es importante usar funciones !!! :

Se reduce la cantidad de cdigo a escribir.
Se pueden realizar y probar por separado, antes de incluirlas en
el programa definitivo.
Una funcin puede llamar a otra(s), permitiendo desarrollar con
facilidad algoritmos top-down ms complejos.
El cdigo es reutilizable para otros programas, ya que la funcin
no depende del resto del programa.
Cundo introducir una funcin?

Siempre que se detecte una porcin de cdigo que realiza una
tarea parcial auto-contenida:
Slo depende de valores iniciales para producir un resultado.
Es independiente del resto del programa (n! no depende de para qu va a ser
usado).
Requiere valores temporales que no necesita el resto del programa.
44
Funciones y estructuras
Las funciones pueden recibir y devolver valores tipo

estructura.
Al igual que con el resto de tipos, se realiza una copia local para
los parmetros, y se copia en la variable destino el resultado (en
estructuras grandes, estas copias pueden ser muy lentas).
complejo
Ejemplo: struct
{
float re,im;
} ;
struct complejo ProdComplejos(struct complejo a, struct complejo b)
// Calcula y devuelve a*b
{
struct complejo prod;
prod.re=a.re*b.re-a.im*b.im;
prod.im=a.re*b.im+a.im*b.re;
return prod;
}
...
// En otra zona del programa (funcin llamante)
struct complejo uno_menos_j,uno_menos_j_cuadrado;
uno_menos_j.re=1;
uno_menos_j.im= -1;
uno_menos_j_cuadrado=ProdComplejos(uno_menos_j,uno_menos_j);
45
Realizar utilizando funciones (cada ejercicio utilizar

funciones realizadas en los anteriores):
1)
2)
3)
Calcular el mximo comn divisor de 2 enteros mediante el algoritmo

de Euclides (http://latecladeescape.com/t/Algoritmo+de+Euclides ).
Calcular el mnimo comn mltiplo de 2 enteros: mcm(a,b)=a.b/mcd(a,b)
Se divide una misma longitud utilizando 3 escalas:
La escala A cada 12 m
La escala B cada 18 m
La escala C cada 30 m
En qu punto despus del origen coincidirn por 1 vez las marcas

de las 3 escalas?
mcm(a,b,c)=mcm(mcm(a,b),c)
4)
Cul es el rea del crculo cuyo centro es la primera coincidencia de

las escalas A y B, y que pasa por la primera coincidencia de las 3
escalas?
46
Indice
Funciones
Tablas y punteros
47
Tablas (arrays)
En muchas ocasiones, necesitamos usar conjuntos de

variables del mismo tipo.
int x1,x2,x3,x4;
int media;
// Creamos 4 variables con nombres distintos
media=(x1+x2+x3+x4)/4;
El desarrollo de algoritmos se simplifica si las guardamos

como una tabla (o array):
int x[4]; // Creamos 4 variables bajo el mismo nombre
// accesibles como x[0], x[1], x[2], x[3]
int media,suma,i;
suma=0;
for (i=0;i<4;i++)
suma=suma+x[i];
media=suma/4;
48
Tablas (arrays)
int x1,x2,x3,x4;
int m;
int x[4];
int m,suma,i;
m=(x1+x2+x3+x4)/4;
suma=0;
for (i=0;i<4;i++)
suma=suma+x[i];
m=suma/4;
Realmente se ha simplificado el algoritmo? La respuesta

es sencilla, slo hay que considerar otras situaciones:
Si se necesitan 100 1000 variables en lugar de 4:
El cdigo con variables sueltas es mucho ms largo y tedioso de escribir.
El cdigo con arrays se mantiene igual (slo cambiar 4 por 100 1000).
Si el nmero de variables a utilizar (n) depende de resultados

previos del programa:
Con variables sueltas es prcticamente inabordable (hay que escribir cdigo
especfico para cada valor de n).
Con arrays, slo hay que cambiar 4 por n (*)
(*) excepto en la declaracin de la variable,

donde el tamao debe ser un valor constante49
Tablas (arrays)
Es importante entender cmo son manejados los arrays

por el lenguaje.
En C, cuando se declara un array de N posiciones:
tipo tabla[N];
N debe ser un valor constante.
Se reservan en memoria N posiciones consecutivas para datos del tipo indicado.
Los N elementos se acceden mediante tabla[i], donde i es un valor entero
entre 0 y N-1. Cada elemento es a todos los efectos una variable del tipo
declarado.
Una vez declarado el array, el lenguaje C no recuerda el tamao N, es
responsabilidad del programador.
El identificador a secas (tabla) es un valor constante, que indica la direccin de
memoria donde comienzan los elementos del array.
La posicin del elemento tabla[i] se calcula sumando i a la direccin inicial
tabla. No hay comprobacin de salida de rango.
Por todo lo anterior, el programador deber manejar 2 datos para cada tabla:
direccin de inicio y n de elementos, y es responsable de no salirse de sus lmites.
50
Tablas (arrays)
Utilizando tablas en el programa:

Se utilizar una tabla siempre que se precise un n de datos
similares o equivalentes:
int nacimientos[365];
float vec3D[3];
float color[3];
float complejo[2];
char texto[20];
//
//
//
//
vec3D[0]=x, vec3D[1]=y, vec3D[2]=z

color[0]=R, color[1]=G, color[2]=B
complejo[0]=real, complejo[1]=imag
caracteres ordenados = texto
Lo ms habitual ser acceder a los elementos de la tabla mediante

bucles, donde el ndice debe ser entero (entre 0 y tamao-1).
Es conveniente utilizar #define para las constantes numricas:
#define DIAS_ANYO
365
int nacimientos[DIAS_ANYO],defunciones[DIAS_ANYO];
Este formato es el tpico en C:
int crec_anual,i;
- Empezar en ndice 0
crec_anual=0;
- Mantenerse mientras el ndice es
for (i=0;i<DIAS_ANYO;i++)
menor estricto que el tamao
crec_anual=crec_anual+nacimientos[i]-defunciones[i];
51
Tablas (arrays)
En algunos casos especiales, es ms conveniente

manejar la longitud de una manera diferente:
Ejemplo: codificacin de un polinomio de grado 3
p(x)=a.x3+b.x2+c.x+d
#define GRADO 3
float pol[GRADO+1];
// pol[0]=a, pol[1]=b, , pol[3]=d
float x,px;
int i;
Se necesitan 4 elementos para grado 3
x= valor de x;
for (i=0,px=0;i<GRADO+1;i++)
px=pol[i]*px+x;
Nos mantenemos en el bucle mientras
el ndice es menor estricto que el
tamao
52
Punteros (pointers)
Un puntero es un valor (constante o variable) que

contiene una posicin de memoria donde se encuentra
una variable.
Su tipo de datos es tipo* (valor entero que indica una
direccin donde hay una variable del tipo tipo)
Se puede obtener la direccin de una variable con el
operador &: Indica al compilador que reserve espacio para
int x=5;
int y=27;
x en memoria. Todas las referencias a x en el

cdigo se compilarn como: contenido de la
posicin 3000, tratada como int
3000
27
3010
x
y
&x : es un int* que vale 3000 (valor constante)

&y: es un int* que vale 3010 (valor constante)
El compilador y el entorno de ejecucin deciden dnde estarn x e y.
La nica forma de saberlo en el cdigo es mediante el operador &.
53
Punteros (pointers)
Las variables de tipo puntero permiten acceder de forma

indirecta a una variable.
Se declaran con:
tipo* nombre;
y permiten acceder al contenido de la direccin mediante:

*nombre;
Ej:
int x=5,y=27;
int* pt;
pt=&x;
*pt=44;
pt=&y;
*pt=44;
x
y
pt
3000
27
3010
3000
3016
54
Punteros (pointers)

Se declaran con:
tipo* nombre;

*nombre;
Ej:
int x=5,y=27;
int* pt;
pt=&x;
*pt=44;
pt=&y;
*pt=44;
x
y
pt
44
3000
27
3010
3000
3016
55
Punteros (pointers)

Se declaran con:
tipo* nombre;

*nombre;
Ej:
int x=5,y=27;
int* pt;
pt=&x;
*pt=44;
pt=&y;
*pt=44;
x
y
pt
44
3000
27
3010
3010
3016
56
Punteros (pointers)

Se declaran con:
tipo* nombre;

*nombre;
Ej:
int x=5,y=27;
int* pt;
pt=&x;
*pt=44;
pt=&y;
*pt=44;
x
y
pt
El mismo cdigo
afecta a variables diferentes
gracias al puntero
44
3000
44
3010
3010
3016
57
Punteros (pointers)
Para qu sirven los punteros?
USO 1: Permiten modificar una variable de una funcin llamadora

desde la funcin llamada.
Ejemplo: funcin que incremente x y devuelva x!
Sin punteros: no es posible
int Fact_con_Inc(int x)
{
int fact;
x=x+1;
fact=Factorial(x);
return fact;
}
...
// Funcin llamadora
int x=4,f;
f=Fact_con_Inc(x);
...
x
f
3000
3010
58
Punteros (pointers)

{
int fact;
x=x+1;
fact=Factorial(x);
return fact;
x
fact
2900
2908
3000
3010
}
...
// Funcin llamadora
int x=4,f;
f=Fact_con_Inc(x);
...
x
f
59
Punteros (pointers)

{
int fact;
x=x+1;
fact=Factorial(x);
return fact;
x
fact
2900
120
2908
3000
3010
}
...
// Funcin llamadora
int x=4,f;
f=Fact_con_Inc(x);
...
x
f
60
Punteros (pointers)

{
int i,fact;
x=x+1;
fact=Factorial(x);
return fact;
x
fact
2900
120
2908
3000
120
3010
}
...
// Funcin llamadora
int x=4,f;
f=Fact_con_Inc(x);
...
x
f
61
Punteros (pointers)

Con punteros: es posible
int Fact_con_Inc(int* pt)
{
int fact;
*pt=*pt+1;
fact=Factorial(*pt);
return fact;
}
...
// Funcin llamadora
int x=4,f;
f=Fact_con_Inc(&x);
...
x
f
3000
3010
62
Punteros (pointers)

{
int fact;
*pt=*pt+1;
return fact;
pt
fact
3000
2900
2908
3000
3010
}
...
// Funcin llamadora
int x=4,f;
f=Fact_con_Inc(&x);
...
*ptx
f
63
Punteros (pointers)

{
int fact;
*pt=*pt+1;
return fact;
pt
fact
3000
2900
2908
3000
3010
}
...
// Funcin llamadora
int x=4,f;
f=Fact_con_Inc(&x);
...
*ptx
f
64
Punteros (pointers)

{
int fact;
*pt=*pt+1;
return fact;
pt
fact
3000
2900
120
2908
3000
3010
}
...
// Funcin llamadora
int x=4,f;
f=Fact_con_Inc(&x);
...
*ptx
f
65
Punteros (pointers)

{
int fact;
*pt=*pt+1;
return fact;
pt
fact
3000
2900
120
2908
3000
120
3010
}
...
// Funcin llamadora
int x=4,f;
f=Fact_con_Inc(&x);
...
x
f
66
Punteros (pointers)

Ya habamos dado este uso en la funcin scanf() !
int x;
printf("Introduce valor de x: ");
scanf("%d",&x);
// scanf() necesita &x para modificar x
printf("x = %d\n",x);
// printf() no necesita &x porque no
//
va a modificar x
67
Punteros (pointers)

USO 2: Permiten usar tablas declaradas en otras funciones.
Ejemplo: funcin que calcula la media
float Media(float* tabla,int n)

// Un parmetro no puede ser una tabla completa,
// slo su direccin de comienzo (el C no tiene nocin
// de la tabla completa una vez declarada).
// float* tabla y float tabla[] son equivalentes.
{
float media,suma;
int i;
suma=0;
for (i=0;i<n;i++)
suma=suma+tabla[i];
media=suma/n;
return media;
}
...
// Funcin llamadora
int notas[5],n_alumnos;
float nota_media;
... Dar valores a n_alumnos (ej. 3) y notas[i] ...
nota_media=Media(notas,n_alumnos);
...
n_alumnos
nota_media
notas
3
?
8.5
9.3
7.1
?
?
3000
3004
3008
68
Punteros (pointers)

float Media(float* t,int n)

t
n
// float* t y float t[] son equivalentes.
media
{
suma
float media,suma;
int i;
i
suma=0;
for (i=0;i<n;i++)
n_alumnos
suma=suma+t[i];
media=suma/n;
nota_media
return media;
}
*t *(t+0) t[0]
...
*(t+1) t[1]
// Funcin llamadora
*(t+2) t[2]
float nota_media;
...
3008
3
?
?
?
3
?
8.5
9.3
7.1
?
?
2900
2904
2908
2912
2916
3000
3004
3008
69
Punteros (pointers)


t
n
media
{
suma
float media,suma;
int i;
i
suma=0;
for (i=0;i<n;i++)
n_alumnos
suma=suma+t[i];
media=suma/n;
nota_media
return media;
}
*t *(t+0) t[0]
...
*(t+1) t[1]
// Funcin llamadora
*(t+2) t[2]
float nota_media;
...
3008
3
8.3
24.9
3
3
?
8.5
9.3
7.1
?
?
2900
2904
2908
2912
2916
3000
3004
3008
70
Punteros (pointers)


{
float media,suma;
int i;
suma=0;
for (i=0;i<n;i++)
suma=suma+t[i];
media=suma/n;
return media;
}
...
// Funcin llamadora
float nota_media;
...
t
n
media
suma
i
n_alumnos
nota_media
notas
3008
3
8.3
24.9
3
3
8.3
8.5
9.3
7.1
?
?
2900
2904
2908
2912
2916
3000
3004
3008
71
Punteros y tablas
Algunas consideraciones importantes (I):

Una tabla slo es tabla en el instante de su declaracin como
variable local. A partir de ah, su identificador es un puntero
constante: el lenguaje C no tiene nocin de tabla.
Si se declara una tabla como parmetro, no se est declarando
una tabla completa, slo un puntero (su direccin inicial).
Siempre se necesitar un 2 parmetro que indique la longitud.
Los punteros (y tablas por tanto) son peligrosos, ya que
permiten acceder a cualquier posicin de memoria.
Se puede evitar parcialmente el peligro de tablas y punteros
usando el modificador const: impide modificar el contenido de
las direcciones apuntadas.
float Media(float tabla[],int n)
{
...
tabla[i]=xx; // Deseado?
}
float Media(const float tabla[],int n)

{
...
tabla[i]=xx; // Error de compilacin
}
72
Punteros y tablas
Algunas consideraciones importantes (II):

Una funcin no puede devolver una tabla, slo modificar una de
la funcin llamante, cuya direccin inicial se pase como
parmetro.
Siempre que se pase una tabla a una funcin, hay que utilizar la
direccin de comienzo y el n de elementos. Una funcin ser
ms reutilizable si sirve para cualquier n de elementos.
// INCORRECTO!!!!
// OJO! Compila pero ejecuta mal
int* FuncionDevuelveTabla(...)
{
int t[10];
// CORRECTO
void FuncionDevuelveTabla(int t[],int n)
{
... Dar valores a t[i]...
}
... Dar valores a t[i]...

return t;
}
No se maneja informacin del tamao de la tabla.

La tabla t desaparece cuando se deje de ejecutar
la funcin, por lo que el valor devuelto se refiere a
una direccin de memoria desasignada.
Se maneja informacin del tamao de la tabla.

El puntero t se refiere a una tabla que existe (y
seguir existiendo) en la funcin llamante.
73
Punteros y tablas
Algunas consideraciones importantes (III):

El tamao de una tabla debe ser declarado en tiempo de
compilacin (valor constante).
Si no se conoce, se asignar en la declaracin un tamao
mayor o igual que el mximo posible, y se usar solamente la
parte que se desee.
#define NMAX
10
...
int t[NMAX];
int n;
...
Se declara una tabla de 10

elementos, aunque
posteriormente se utilizan
slo los n primeros.
... Dar valor a n ...

... Asegurar que n>=0 && n<= NMAX ...
... Usar t[i], i=0 hasta n-1 ...
...
}
74
Punteros y tablas
Asignacin dinmica de memoria:

Es posible reservar el tamao de una tabla en tiempo de
ejecucin, utilizando funciones especiales (incluir <malloc.h>):
void* malloc(int nBytes);
// Busca y reserva memoria para nBytes

// consecutivos, y devuelve direccin de
// comienzo ( NULL si no se dispone)
void free(void* memAsignada); // Libera memoria asignada con malloc
Se declara una variable tipo puntero que
contendr la direccin de inicio de la tabla.
...
float *t;
int n;
...
... Dar valor a n ...
t=(float*) malloc(n*sizeof(float));
if (t!=NULL)
{
... Usar t[i], i=0 hasta n-1 ...
free(t);
}
...
}
Se solicita espacio para una tabla que

necesita n*4 bytes (4 es el n de bytes que
ocupa un float, lo devuelve el operador
sizeof).
Se comprueba que se ha podido asignar la
memoria solicitada
Se utilizan normalmente los elementos de
la tabla, gracias la dualidad tabla
puntero.
Se debe liberar la memoria asignada
cuando ya no sea necesaria.
75
Punteros, tablas y estructuras
Un campo de una estructura puede ser una tabla o un

puntero.
#define N_MAX
100
Ejemplo: struct vector
{
int n;
float datos[N_MAX];
} ;
float Sumatorio(struct vector v)
{
...
}
ATENCION !!!
De esta manera, se puede conseguir que una funcin reciba o
devuelva una tabla completa.
PERO NO SE SUELE USAR PORQUE

Al usar tablas estticas como campos de estructura, se copian
completas al pasar o devolver en funciones, lo que puede llevar un
gran consumo de tiempo.
76
Punteros, tablas y estructuras
Si se desea pasar estructuras grandes a funciones, es

ms conveniente usar punteros a estructura.
#define N_MAX
100
Ejemplo:
struct vector
{
int n;
float datos[N_MAX];
} ;
float Sumatorio(const struct vector* v)

{
...
}
Para acceder a los campos de la estructura dado un

puntero:
(*v).n
O mejor con el operador flecha (guin seguido de mayor que):
v->n
77
Realizar utilizando funciones:

1)
Calcular la desviacin tpica de los datos de una tabla de 5 elementos.

=
2)
3)
4)
5)
6)
( )
Calcular el ndice donde se produce el valor mnimo de una tabla de 5

elementos, y escribir el ndice y el valor mnimo.
Calcular la mediana de los valores de una tabla de 5 elementos
(obtener una tabla auxiliar ordenada de menor a mayor, de sta sacar
el elemento central).
Actualizar la funcin del ejercicio anterior para que devuelva un cdigo
de error si el n de elementos es impar.
Actualizar el ejercicio anterior anterior para que las tablas tengan
declaracin dinmica.
Realizar una funcin que mueva cada elemento de una tabla al
siguiente, y actualice el primer elemento con un nuevo valor.
78
Indice
Funciones
Tablas y punteros
79
Codificacin de texto
Al igual que otros conceptos abstractos (das de la

semana, tipos de fruta, etc.), el texto se codifica como
nmeros enteros:
Cada carcter de un texto est codificado por un valor entero.
Todos los computadores deben utilizar la misma codificacin
para entenderse entre ellos: cdigos ASCII y UNICODE.
Puesto que no hay muchos caracteres diferentes, no es
necesario un elevado n de bits para codificarlos todos:
ASCII: 8 bits = 256 caracteres diferentes.
UNICODE: 16 bits = 65536 caracteres diferentes.
Se utiliza el tipo de datos char para indicar un entero con el n

de bits necesarios (8/16) para codificar un carcter.
Para declarar constantes se pone el carcter entre comillas
simples, para evitar recordar el cdigo de cada carcter.
Ejs: a 97
b 98
c 99
. 46 0 48
1 49 \n 10
80
La tabla de cdigos ASCII
ASCII utiliza 8 bits = 256 valores diferentes:

Estndar (0 a 127)
Extendidos (128 a 255)
81
Operaciones con caracteres
Se opera igual que con datos enteros (son enteros).

char c1,c2;
c1='a';
// c1=97
c2=c1+2;
// c2=99='c'
if (c2>='a' && c2<='z')
printf("El carcter %c es una letra minscula\n",c2);
Existen funciones especficas de inters:
char getchar();
// Pide un carcter por consola
putchar(char c);
// Escribe un carcter en consola
Se utiliza %c en printf() y scanf()
int isalpha(char c); // Devuelve Verdadero si c est entre az A..Z
char toupper(char c); // Devuelve mayscula si era minscula.
Ojo con caracteres extendidos !

, , , , etc. : no siguen reglas de ordenacin.
Cdigos para caracteres especiales comienzan con \:

\n, \0, \, \, \\,
82
Cadenas de caracteres (string)
Un texto es una secuencia ordenada de caracteres, por

tanto en C ser un array de char (en ingls string).
Como en todo array, se requiere su direccin de comienzo y su

longitud.
char txt[4];
int n=4;
txt[0]='H';
txt[1]='o';
txt[2]='l';
txt[3]='a';
Ojo ! No es la forma en que

se hace.
Por comodidad, en los arrays de caracteres (string) no se

maneja la longitud con una 2 variable, sino que se gestiona
colocando un cdigo especial (0) al final de la tabla.
char txt[5];
txt[0]='H';
txt[1]='o';
txt[2]='l';
txt[3]='a';
txt[4]=0;
Ojo ! Para el texto Hola (4 caracteres) se debe

declarar una tabla con un elemento ms.
El string queda definido nicamente por su direccin
de comienzo (txt). El final se produce donde se
encuentre el carcter de cdigo 0 (0 = '\0' '0' = 48 )
83
Se pueden manejar constantes de tipo string,

colocando el texto entre comillas dobles:
char txt[5]="Hola";
txt[0]
txt[1]
txt[2]
txt[3]
txt[4]
txt[5]
'H'
'o'
'l'
'a'
0
?
3000 = txt
3001
3002
3003
3004
3005
Una constante tipo string es un const char*, y se puede

utilizar en cualquier lugar del cdigo que lo acepte:
// En <stdio.h>
int printf(const char* fmt,...);
printf() recibe como parmetro la direccin
de comienzo de una tabla de char, que se
puede obtener de una constante string.
// En nuestro programa
int x=3,z=2;
printf("x vale %d, y vale %d\n",x,y);
84
Slo se puede asignar el contenido de un string a una

constante en el momento de su declaracin:
char txt[5]="Hola";
char nom[5];
nom="Pepe";
nom=txt;
txt[0]
txt[1]
txt[2]
txt[3]
txt[4]
txt[5]
'H'
'o'
'l'
'a'
0
?
3000 = txt
nom[0]
3001
nom[1]
3002
nom[2]
3003
nom[3]
3004
nom[4]
3005
nom[5]
// Correcto
// Incorrecto, equivale a 3100=4000 !
// Incorrecto, equivale a 3100=3000 !
?
?
?
?
?
?
3100 = nom
3101
3102
3103
3104
3105
'P'
'e'
'p'
'e'
0
?
4000 = "Pepe"
4001
4002
4003
4004
4005
85
Todas las operaciones con string requieren recorrer los

elementos de la tabla uno por uno, terminando al
alcanzar el carcter 0:
char txt[5]="Pepe";
char nom[5];
int i,iguales;
// Copiar txt a nom
for (i=0;txt[i]!=0;i++)
nom[i]=txt[i];
nom[i]=0;
// Aqu: nom vale lo mismo que txt
// Comparar nom y txt
if (nom==txt) // MAL: Siempre falso (3000==3100)
iguales=1;
for (i=0;txt[i]!=0;i++)
iguales=iguales && (txt[i]==nom[i]);
// Aqu: iguales (V F) indica si son iguales
86
Operaciones con strings
Funciones para E/S de strings:

char* gets(char* cad);
// Pide una cadena por consola
int puts(const char* cad);
// Escribe una cadena en consola
Se utiliza %s en printf() y scanf()
Ejemplo:
char nombre[20];
char apellido[20];
printf("Nombre: ");
gets(nombre);
printf("Apellido: ");
gets(apellido);
printf("Nombre completo: %s %s\n",nombre,apellido);
87
Funciones de cadena de caracteres
Realizan los bucles ms tpicos en el tratamiento de

strings (copiar, comparar, aadir, buscar, )
Trabajan con tablas de char terminadas en el caracter 0.
Incluir <string.h>
Funciones ms utilizadas
int strlen(const char* cad); // Devuelve longitud de cadena
char* strcpy(char* dst,const char* src);
// Copia src en dst
char* strncpy(char* dst,const char* src, int n); // Copia mx n caracteres
de src en dst (no incl. nulo)
char* strcat(char* dst,const char* src); // Aade src al final de dst
char* strncat(char* dst,const char* src,int n); // Aade mx n caracteres
de src al final de dst (incl. nulo)

El valor devuelto es el mismo que dst, as

que no se suele utilizar (strcpy, strncpy,
strcat, strncat).
88
int strcmp(const char* str1,const char* str2); // Compara a nivel de
cdigos ASCII. Devuelve: 0 iguales, <0 str1 es anterior, >0 str1
es posterior.
int strncmp(const char* str1,const char* src,int n);
// Id. con mximo n caracteres
char* strchr(const char* str,char c); // Busca caracter c en cadena cad
char* strstr(const char* str,const char* substr); // Busca subcadena
substr en cadena str
Otras funciones de bsqueda (ver ayuda VC++): strcspn(), strpbrk(),
strtok(), strspn(),
89
Ejemplo: pedir nombre y apellido, unirlos, y comprobar si

se trata de Marie Curie.
char nombre[20];
char apellido[20];
char* todo;
printf("Nombre: ");
gets(nombre);
printf("Apellido: ");
gets(apellido);
todo=(char*) malloc(strlen(nombre)+1+strlen(apellido)+1);
strcpy(todo,nombre);
strcat(todo," ");
strcat(todo,apellido);
if (strcmp(todo,"Marie Curie")==0)
puts("Es una cientfica\n");
free(todo);
90
Funciones de conversin de datos
Convierten cadenas de caracteres de/hacia tipos de

datos numricos.
int atoi(const char* cad);
// Obtiene entero decimal
double atof(const char* cad);
// Obtiene valor real
double strtod(const char* cad,char** ptEnd); // Obtiene valor real
// y puntero al final de conversin
int sscanf(const char* cad,const char* fmt,); // Id. a scanf() pero
// obteniendo datos de una cadena
char* itoa(int num);
// Obtiene cadena decimal para entero
char* ftoa(double num); // Obtiene cadena decimal para real
int sprintf(char* cad,const char* fmt,); // Id. a printf() pero
// almacenando en una cadena
91
Ejemplo: pedir comando de texto y extraer valor entero

en una variable (. POS = 90 .)
char texto[40];
int posicion;
char* cmd;
printf("Comando: ");
gets(texto);
cmd=strstr(texto,"POS");
if (cmd!=NULL)
{
for (cmd=cmd+strlen("POS");*cmd==' ';cmd++)
;
if (*cmd=='=')
posicion=atoi(cmd+1);
}
92
A tener en cuenta al usar cadenas de caracteres:

Son tablas como cualquier otra: requieren su reserva de espacio
en memoria, no hay comprobacin de salida de rango, etc.
No se usa la longitud de la tabla, sino el cdigo especial 0. No
se puede olvidar aadir el carcter 0 al manipular strings !
Se pueden manipular:
Carcter por carcter, usando ndices o punteros.
Usando funciones de la librera estndar.
Creando funciones propias, con los mismos criterios vistos para tablas
(excepto el parmetro longitud, que no suele utilizarse).
Pero siempre hay que asegurar que el tamao reservado es

capaz de albergar los datos de la tabla:
char txt[5]="Pepe";
strcat(txt," Prez");
// Incorrecto: en txt no hay sitio para todo
Es muy habitual el uso de asignacin dinmica de memoria, ya

que son tablas de tamao muy variable.
93
1)
2)
3)
4)
5)
Pedir por consola el nombre de una unidad lgica, directorio y archivo,

y componer el camino completo hacia el archivo (ej:
c:\user\practicas\ejemplo.txt).
Comprobar si el archivo anterior tiene extensin txt y se encuentra
en el subdirectorio practicas.
Realizar una funcin que, dado un comando con el formato
POSICION=valor entero, devuelva el valor entero. Se debe admitir
que la palabra clave POSICION sea POS POSI POSIC
POSICION, y que haya espacios en blanco antes y despus del =.
Aadir a la funcin anterior la posibilidad de devolver un cdigo de
error si no se encuentra el comando o el formato es incorrecto.
Pedir por consola una cadena con el formato [v1,v2,v3,vn] y
extraer de la misma los contenidos de una tabla de float con esos
valores.
94
Indice
Funciones
Tablas y punteros
95
Recordatorio: un entero se codifica en el computador

con valores binarios (codificacin ponderada en base 2).
x
000010111
El n de bits utilizados depende del tipo

de datos y del procesador. Se puede saber
con el clculo 8*sizeof(int).
int x=23;
En ciertas ocasiones, el programador puede tener

inters en el valor particular de algn(os) bit(s), y no en
el valor completo (la cantidad que representa):
Cuando los bits representan el estado de valores binarios
diferentes (ej. E/S digital).
Cuando se desea comprimir informaciones de varios valores en

un solo entero.
96
En los casos anteriores, el valor decimal y las

operaciones aritmticas aportan poca informacin o
difcil de extraer.
27 26 25 24 23 22 21 20
valor
valor=77;
// 26+23+22+20
Est activa la luz de peso 2?

Quiero activar la luz de peso 4.
Quiero cambiar el estado de las luces de peso 6 y 7 para
generar una intermitencia.
97
Operadores lgicos de bit
Operadores de C para manejar bits (slo valores enteros)

Binarios (2 operandos):
i=0..n-1
& (y): entA & entB entR
BITi(entR)= BITi(entA) AND BITi(entB)
| (o):
entA | entB entR
BITi(entR)= BITi(entA) OR BITi(entB)
^ (o excl.): entA ^ entB entR
BITi(entR)= BITi(entA) XOR BITi(entB)
Monarios:
~ (negacin lgica):
i=0..n-1
A
~ entA entR
BITi(entR)= BITi(entA)
Ejemplos:
int v1=77;
int v2=23;
v1 & v2
v1 | v2
v1 ^ v2
~v1
->
->
->
->
00..01001101
00..00010111
00..00000101
00..01011111
00..01011010
11..10110010
(=5)
(=95)
(=90)
(=-78)
98
Operadores de desplazamiento de bits
Binarios (2 operandos):
<< (desplazamiento a izquierda):
i=entB..n-1
i=0..entB-1
entA << entB entR
BITi(entR)= BITi-entB(entA)
BITi(entR)= 0
A
A
>> (desplazamiento a derecha):

A
i=0..entB-1
i=entB..n-1
peso 2n-1
int x=26
0000 00011010
x<<3=
=208=
=26x23
0000 11010000
entA >> entB entR

BITi(entR)= BITi+entB(entA)
0: si entA es unsigned
BITi(entR)=
Bit signo entA: si entA es signed
peso 20
peso 2n-1
int x=26
0000 00011010
x>>3=
=3=
=26/23
0000 00000011
peso 20
99
Para indicar constantes de cuyo valor interesan los bits,

se usa la codificacin hexadecimal (base 16, dgitos
0..9A..F).
Un cdigo hexadecimal equivale a 4 dgitos binarios:
0h=0000b
1h=0001b
2h=0010b
3h=0011b
4h=0100b
5h=0101b
6h=0110b
7h=0111b
8h=1000b
9h=1001b
Ah=1010b
Bh=1011b
Ch=1100b
Dh=1101b
Eh=1110b
Fh=1111b
En C, las constantes enteras en hexadecimal se preceden de 0x

valor=77;
valor=0x4D;
// 26+23+22+20
// 4h=0100b, Dh=1101b
valor
Se pueden leer/escribir valores en hexadecimal utilizando %x en

printf() y scanf() (no usar 0x)
100
Operaciones habituales con el bit de peso p de la

variable entera x (afectando slo a ese bit):
int x,p;
2p
int mascara;
Dar valores a p y x
mascara=1<<p;
// mascara = 0..00100..000
// 1<<p = 2p
Est activo el bit de peso p de la variable x?

if (x & mascara)
Poner a 1 el bit de peso p de la variable x:

x=x | mascara;
Poner a 0 el bit de peso p de la variable x :

x=x & ~mascara;
Cambiar el valor del bit de peso p de la variable x :

x=x ^ mascara;
101
Operaciones habituales con varios datos

25
20
comprimidos en un entero:
int v;
int vx,vy,vz;
// v = zzyxxx
// Extraer vx,vy,vz de v
Dar valor a v
vx= v & 0x7;
vy= (v & 0x8) >> 3;
vz= (v & 0x30) >> 4;
Mscara Z
// vx= 000xxx
// vy= 00000y
// vz= 0000zz
Rotacin Z
// Cambiar valor de los campos de v

Dar valores a vx,vy,vz
v= (v & ~0x7) | (vx & 0x7);
// v= zzyxxx
v= (v & ~0x8) | ((vy << 3) & 0x8); // v= zzyxxx
v= (v & ~0x30)| ((vz <<4) & 0x30); // v= zzyxxx
Rotacin Z
Mscara Z
102
Calcular mscara y rotacin para un bit de comienzo y

un n de bits de un campo
Ej: v = zzyxxx
bitstart_z = 4, nbits_z=2
Rotacin = bitstart_z
2n
(1<<n)
(1<<n)-1
= 0001000000
= 0000111111
Mscara
= (((1<<(bitstart_z+nbits_z))-1) & ~((1<<bitstart_z)-1))
00111111
#define
#define
#define
#define
#define
#define
#define
#define
#define
BITSTART_X
NBITS_X
MASK_X
BITSTART_Y
NBITS_Y
MASK_Y
BITSTART_Z
NBITS_Z
MASK_Z
11110000
00110000
0
3
(((1<<(BITSTART_X+NBITS_X))-1) & ~((1<<BITSTART_X)-1))
(BITSTART_X+NBITS_X)
1
(((1<<(BITSTART_Y+NBITS_Y))-1) & ~((1<<BITSTART_Y)-1))
(BITSTART_Y+NBITS_Y)
2
(((1<<(BITSTART_Z+NBITS_Z))-1) & ~((1<<BITSTART_Z)-1))
vz= (v & MASK_Z) >> BITSTART_Z;
// vz= 0000zz
103
1)
2)
Realizar una funcin que escriba en pantalla una cadena de

caracteres que indique el contenido binario de un valor.
Realizar una funcin que pida por teclado una cadena de caracteres
que contenga 0s y 1s, y devuelva el valor entero que codifica a dicho
valor binario.
Usando el simulador (utilizar funcin Sleep(200) para temporizar):

3)
4)
5)
6)
Realizar un programa que encienda las luces en funcin del estado de

activacin de los interruptores.
Realizar una programa que haga parpadear las luces cuyos
interruptores estn activos.
Realizar un programa que permita visualizar una luz que va
desplazndose de izquierda a derecha (de forma circular).
Realizar un programa que hace parpadear las luces 0 a 3 en funcin
del estado de sus interruptores, y que a la vez traslade una sola luz
entre 4 y 7.
104
Indice
Funciones
Tablas y punteros
105
Alto nivel cdigo mquina
Pasos en la obtencin
de cdigo mquina:
Editor
Escribir cdigo fuente

(programa editor)
Compilar cdigo fuenteCompilador

(programa compilador)
Enlazar cdigo objeto y

libreras (programa
Enlazador
enlazador)
.C
main()
{
int i;
...
printf(x=%d..
}
.OBJ
_main:
00011100
00010100
exports _main
extern _printf
00011100
00010100
11011100
11010100
.LIB
_printf:
11011100
11010100
extern _main
exports _printf
.EXE
...
106
Ejecucin del programa
Ejecucin de un programa:
El programa Cargador
(Loader) vuelca en memoria
el archivo ejecutable.
El cargador pone en el PC
(Contador de Programa) la
direccin de la 1 instruccin
del programa (el resto se
ejecutan secuencialmente).
O bien cargar en memoria y
ejecutar paso a paso con un
programa depurador.
00011100
00010100
11011100
11010100
.EXE
...
Cargador
00011100
00010100
11011100
11010100
. . .
. . .
. . .
107
Compilacin separada
Tambin es posible escribir el cdigo en varios archivos

de cdigo fuente, compilar por separado, y enlazar
conjuntamente.
.LIB
uno.obj
uno.c
main()
{
x=FnDos();
y=FnTres();
Comp
dos.c
int FnDos()
{
dos.obj
Comp
_FnDos:
01010100
exports _FnDos
Enlazador
tres.c
int FnTres()
{
_main:
00011100
exports _main
extern _printf
extern _FnDos
extern _FnTres
_printf:
11011100
11010100
extern _main
exports _printf
tres.obj
Comp
_FnTres:
11001100
exports _FnTres
00011100
01010100
11001100
11011100
11010100
.EXE
108
El preprocesador
Se puede indicar ciertas acciones previas al compilado

mediante directivas de preprocesador.
Las directivas de preprocesador deben ocupar una lnea
comenzando por #
Directivas ms usuales:
#include <archivo.h> "archivo.h"
// Inclusin archivo de cabecera,

// con < > para cabeceras estndar
#define IDENTIF texto
// Definicin de ctes. y macros
#pragma
// Indicaciones al compilador
#ifxxx
#else
#endif
// Directivas de
// compilacin
// condicional
#error
// Genera error de compilacin

109
El preprocesador
Las directivas del preprocesador actan sobre el texto
que va a ser compilado, no en tiempo de ejecucin.
Ejemplo:
miprog.c
#include <stdio.h>
#define N 5
Pre
pro
cesa
dor
main()
{
int i,t[N];
miprog.obj
/***
*stdio.h definitions
*
main()
{
float t[5];
int i;
for (i=0;i<N;i++)
00010100111
11010010011
01001010111
Com
pila
dor
for (i=0;i<5;i++)
stdio.h
/***
*stdio.h - definitions/declarations for standard I/O routines
*
110
Cuando se realiza compilacin separada, se utiliza la directiva

#include para que todos los mdulos utilicen las mismas definiciones
(prototipos de funcin, constantes, etc).
uno.c
uno.obj
int FnDos();
#include "dos.h"
main()
{
float x=PI/4;
if (FnDos(x,))
Pre pro
cesador
main()
{
float x=3.1416/4;
if (FnDos(x,))
Com
pila
dor
00010100111
11010010011
01001010111
dos.h
#define PI 3.1416
int FnDos();
dos.c
#include "dos.h"
int FnDos()
{
if (x>PI)
return 1;
return 0;
}
dos.obj
int FnDos();
Pre pro
cesador
int FnDos()
{
if (x>3.1416)
return 1;
return 0;
}
Com
pila
dor
11010010011
00010100111
01001010111
111
Diferencias fundamentales entre archivo de cdigo fuente

(.c) y archivo de cabecera (.h):
Slo los .c son compilados para generar .obj
Los .h slo sirven para ser incluidos en uno o varios .c
Los .c llevan el cdigo ejecutable (funciones, sentencias,
expresiones, ).
Los .h slo llevan declaraciones que sean necesarias para los .c
que los incluyan:
Prototipos de funciones (cabecera terminada en ; )
Constantes
Nuevos tipos (struct, enum, typedef, )
Otros #include necesarios
Es prctica habitual hacer un .h para cada mdulo .c, que

contenga las declaraciones necesarias (y slo esas) para utilizar
las funciones de ese mdulo.
112
El preprocesador
Definicin de constantes y macros

Sin parmetros:
#define
50
Todas las apariciones del identificador

N sern sustituidas por el valor 50
antes de compilar
Con parmetros:
#define
MIN(a,b) (a>b) ? a : b
Macros con parmetros:

Aunque su invocacin es similar a la de una funcin, su
funcionamiento es diferente. Usar nicamente para cdigo
sencillo y repetitivo (ej. MIN)
Evitar problemas en expansin de macros poniendo
parntesis a los parmetros y a la expresin completa:
#define
MIN(a,b) ( ((a)>(b)) ? (a) : (b) )

113
El preprocesador
Compilacin condicional:
#if condicin_evaluable_en_tiempo_de_compilacin
// Cdigo a compilar si condicin != 0

#else
// Alternativa opcional
// Cdigo a compilar si condicin == 0

#endif
Alternativas a #if:
#ifdef
#ifndef
identif_constante
identif_constante
Diferenciar entre:
#if :
if () :
Se produce la comprobacin en tiempo de compilacin.

El cdigo que no cumple no forma parte del ejecutable.
Se produce la comprobacin en tiempo de ejecucin.
Todo el cdigo forma parte del ejecutable
114
El preprocesador
Ejemplos de compilacin condicional:

#define DEPURANDO 0
// cambiar por 1 2
#if DEPURANDO > 0

printf(Resultado parcial 1 = ,);
#endif
#if DEPURANDO > 1
printf(Resultado parcial 2 = ,);
#endif
115
El preprocesador
Compilacin condicional para evitar

inclusiones mltiples:
miprog.c
#include matrices.h
#include determinante.h
...
Error compilacin:
Declaracin doble
de struct matriz
miprog.c
#include matrices.h
#include determinante.h
...
matrices.h
struct matriz
{
...
};
determinante.h
#include matrices.h
...
...
matrices.h
#ifndef _INC_MATRICES_H
#define _INC_MATRICES_H
struct matriz
{
...
};
...
#endif
determinante.h
#ifndef _INC_DETERM_H
#define _INC_DETERM_H
#include matrices.h
...
#endif
116
1)
2)
3)
Realizar un programa que calcule la desviacin tpica de los datos de

una tabla mediante dos mdulos de cdigo fuente (principal.c y
funciones.c) y un archivo de cabecera (funciones.h).
Realizar mediante una macro el clculo de la mscara binaria dado el
bit de comienzo y el n de bits.
Realizar un programa que, en un bucle infinito, pida el primer valor de
una tabla de float, y desplace los datos de la tabla aadiendo el nuevo
valor al primer elemento. El programa debe permitir visualizar o no el
contenido de la tabla en cada pasada en funcin de una opcin de
compilacin (#define, #ifdef).
117
Indice
Funciones
Tablas y punteros
118
Funciones de E/S por stream

Permiten intercambiar informacin con los
dispositivos de E/S mediante streams
Interrupcin
Programa
usuario
Intercambio
datos
Sistema Operativo
Driver
dispositivo
Driver
dispositivo
Driver
dispositivo
Puertos E/S
Puertos E/S
Puertos E/S
Puertos E/S
Dispositivo
perifrico
Dispositivo
perifrico
Dispositivo
perifrico
Dispositivo
perifrico119
SOFTWARE
HARDWARE
Programa
usuario
E/S por stream
Funcionamiento de la E/S por stream
PROGRAMA
Solicitud
acceso dispositivo
Id. de stream
Solicitud
lectura id.
Datos
ledos
S.O.
Comprueba
si existe y est
libre
Asigna
identificador
Busca driver
asignado
Compone
resultado
DRIVER
Inicializa
Compone
Estado
Comprueba
Puertos y estado
Devolver
resultado?
Lee puertos
y compone
estado
DISPOSITIVO
Acciones al
acceder a puertos
Acciones al
acceder a puertos
Genera
interrupcin
120
E/S por stream
Stream: corriente de datos se envan o reciben un conjunto

ordenado de bytes al/del dispositivo
Todos los dispositivos son tratados de igual forma: se leen o
escriben corrientes de bytes
Tipos de streams:
De entrada / salida / entrada y salida
Con memoria (archivos en dispositivos de almacenamiento) / sin
memoria (resto de dispositivos)
Orientados a texto / binarios
Denominacin de dispositivos: cadena de caracteres (ejs COM1,

/dev/ttyS0, C:\usuario\datos.txt)
El S.O. se encarga de la organizacin lgica de los dispositivos

(nombres, drivers, derechos de acceso, libre/ocupado,).
Los drivers se encargan del acceso fsico a los dispositivos
(leer/escribir puertos, gestin de interrupciones).
121
Funciones para manejo de streams
Permiten asignar identificador a stream, leer/escribir

sobre identificador, liberar stream asociado.
Incluir <stdio.h>
Identificador de stream: variable tipo FILE*.
Funciones de apertura/cierre de stream:
FILE* fopen(const char* name,const char* mode);
name: nombre del dispositivo. Si no existe, supone que es un
archivo en un dispositivo de almacenamiento.
mode: modo de apertura: lectura/escritura/aadir, texto/binario
(ver ayuda en VC++).
int fclose(FILE* fid);
122
Funciones de E/S en streams de texto:

E/S de caracteres:
int fgetc(FILE* fid);
int fputc(int car,FILE* fid);
// Lee 1 carcter
// Escribe 1 carcter
E/S de cadenas:
char *fgets(char *str,int n,FILE *fid); // Lee 1 lnea
int fputs(const char* str,FILE* fid); // Escribe 1 lnea
E/S con formato:

int fscanf(FILE* fid,char *fmt,);
int fprintf(FILE *fid,char *fmt, );
// Lee con formato

// Escribe con formato
123
Streams por defecto para consola
Streams por defecto: permiten realizar E/S a

consola con printf(), scanf(),gets() ,puts(),
getchar(),putchar():
stdin: entrada estndar
stdout: salida estndar
stderr: salida de error
Ej: printf() fprintf(stdout,)
Estos streams estn conectados por defecto a la
consola, en modo texto (stdin a lectura, stdout y stderr
a escritura), pero pueden redirigirse a otros dispositivos
(ej. a archivo):
Miprograma.exe < entrada.txt > salida.txt
124
Funciones de E/S en streams binarios:

Lectura de datos:
int fread(void* buffer, size_t size, size_t count, FILE *fid);
// Lee un conjunto de count*size bytes del stream y los
// almacena en el mismo formato en el buffer
Escritura de datos:
int fwrite(const void* buffer, size_t size, size_t count, FILE *fid);
// Enva al stream un conjunto de count*size bytes indicados
// a partir de la direccin de memoria buffer
En ambos casos:
Las funciones devuelven el n de elementos (bytes/size)
realmente escritos o ledos.
125
Funciones auxiliares para streams con

almacenamiento (archivos):
int feof(FILE* fid);
// Alcanzado fin de archivo?
void rewind(FILE* fid); // Vuelve al principio del archivo
long ftell(FILE *fid ); // Devuelve posicin (en bytes)
// desde el principio del stream
int fseek(FILE *fid, long offset, int origin );

// Coloca en posicin (bytes) deseada
// desde:
// el principio: origin = SEEK_SET
// la posicin actual: origin = SEEK_CUR
// el final: origin = SEEK_END
126
Funciones auxiliares para streams:

int ferror(FILE* fid); // Dve. cdigo del ltimo error (0 = ok)
void clearerr(FILE* fid); // Borra cdigo del ltimo error
int fflush(FILE *fid ); // Vaca buffers intermedios con los que el
// S.O. gestiona la E/S fsica del dispositivo
// asociado al stream:
// Si estaba abierto para salida, asegura
// que dicha salida es escrita fsicamente.
// Si estaba abierto para entrada, elimina
// los datos de los buffer intermedios.
127
Funciones de E/S sin buffer
Se hace la E/S directamente al driver, sin

conversiones ni buffers intermedios.
Identificador de dispositivo: tipo de datos int
Dispositivos por defecto: stdin 0, stdout 1, stderr 2
Funciones:
open(), creat(), close(), read(), write(), tell(),
No forman parte del estndar ANSI, aunque s estn

presentes en la mayora de implementaciones.
Dan acceso al uso de funciones ms especializadas
en entornos estilo Unix:
ioctl(), fcntl(), select()
128
1)
Realizar un programa que lea los datos de una matriz de reales de un

archivo de texto, supuesto el siguiente formato:
matriz.txt
nm
x0,0
x1,0
x0,1
x1,1
x0,m-1
x1,m-1
xn-1,0 xn-1,1 xn-1,m-1
2)
3)
4)
5)
Realizar un programa que lea lneas de un archivo de texto y calcule

el n de lneas que contienen un texto determinado.
Realizar un programa que cree lea un archivo de texto y cree un
segundo archivo sustituyendo todas las apariciones del texto <x> por
el valor de la variable entera x (solicitada por teclado).
Leer de un archivo binario tantos datos tipo float como sea posible en
un vector columna, y escribir un archivo de texto en el formato del
ejercicio 1.
Realizar un programa similar al ejercicio 1, pero excluyendo del
formato del archivo la lnea con los valores n,m.
129
Indice
Funciones
Tablas y punteros
130
El presente curso es un resumen: se debe consultar la

documentacin y/o libros/tutoriales ms detallados.
Algunas omisiones (I):
Tipos de datos:
Existen diversos tipos de datos enteros (long, int, short, char) segn el n de
bits utilizados, en formato signed (por defecto) o unsigned. (enlace)
El lenguaje C no comprueba la salida de rango en operaciones de enteros:
es responsabilidad del programador, y puede ser importante. (enlace)
Para nmeros reales se puede usar float, double y long double. (enlace)
Se pueden utilizar reales en coma fija para acelerar la ejecucin en
procesadores sin unidad de coma flotante. (enlace)
La variables cuyo tipo de datos necesita ms de un byte se almacenan en
direcciones consecutivas, en formato little-endian o big-endian. (enlace)
El operador sizeof() devuelve el tamao en bytes de un tipo de datos o
variable. (enlace)
Se pueden crear nuevos tipos de datos con struct, union, enum y typedef.
(enlace)
131
Algunas omisiones (II):

Variables:
Adems de las variables locales y parmetros, se pueden utilizar
variables globales y estticas. (enlace)
Se pueden utilizar arrays multidimensionales, con asignacin de
memoria esttica o dinmica, aunque no se recomienda como norma
general. (enlace)
Operadores y expresiones:
Operadores con asignacin: += -= *= ++ -- (enlace)
Operador alternativa ? : (enlace)
Operador de separacin , (enlace)
Seguir correctamente las reglas de evaluacin de expresiones. (enlace)
132
Algunas omisiones (III):

Funciones:
La funcin main() puede tener parmetros y devolver un resultado, que
permiten configurar la ejecucin desde el programa cargador. (enlace)
Existen punteros a funcin, que permiten llamar a funciones distintas
en tiempo de ejecucin. (enlace)
Se dispone de funciones de librera estndar para las operaciones ms
habituales (enlace) :
Matemticas (incluir <math.h>)

Cadena de caracteres (incluir <string.h>)
Asignacin dinmica de memoria (incluir <malloc.h>)
E/S por stream (incluir <stdio.h>)
Conversin de datos
Caracteres
Manipulacin de memoria
Sistema y entorno
Fecha y hora
Bsqueda y ordenacin
Generacin de nmeros aleatorios
133
Al escribir el programa:
Realizar funciones y probar por separado, antes de incluirlas
en el programa definitivo.
Las funciones deben ser lo ms genricas posible,
dependiendo nicamente de sus entradas para producir los
resultados:
No incluir printf() o scanf() habitualmente en funciones.
Las funciones deben devolver cdigos de error si no pueden hacer su
trabajo con los parmetros recibidos.
No usar en lo posible variables globales en funciones.
Agrupar funciones similares en un mdulo fuente, y usar

compilacin separada.
No intentar optimizar el cdigo a la primera.
Usar #define para constantes.
Aadir comentarios en el cdigo, especialmente en
cabeceras de funcin y cdigo no auto-explicativo.
134
Al ejecutar y probar el programa:

No hay que esperar que todo funcione a la perfeccin a la
primera: un cdigo que compila bien no significa que ejecute
lo que se espera.
Probar las funciones previamente por separado: facilita la
localizacin de errores.
Probar en modo depuracin: no aadir printf() para depurar.
Comprobar la respuesta ante situaciones anmalas que se
pueden producir con cierta probabilidad.
135

Lenguaje C

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Lenguaje C

Diunggah oleh

Hak Cipta:

Format Tersedia

Programacin en

Ignacio Alvarez Garca

Introduccin al computador y el lenguaje C

Datos, expresiones y algoritmos

Operaciones con valores binarios

Preprocesador y compilacin separada

E/S en archivos y dispositivos

Criterios de buena programacin

Un computador es una mquina de ejecucin

; equivale a dest = src

Los datos (o variables) son lugares de almacenamiento de

Codificacin ponderada en base 2 (binario):

Algunos sistemas de numeracin favorecen la realizacin

En el computador, datos e instrucciones se codifican

Un programa es una secuencia esttica de instrucciones,

; vuelve a ejecutar la instruccin que se encuentra en Inst1:

; vuelve a ejecutar la instruccin que se encuentra en Inst1:

slo si los flags indican resultado

Ejemplos de comportamiento dinmico en ejecucin:

Para que un computador ejecute un programa:

De dnde se sacan los cdigos binarios de

0101 00 00110010 11 00000001

Cmo se cargan instrucciones y datos en memoria?

Cmo se ordena la ejecucin del programa?

Es necesario conocer y escribir programas en lenguaje

El lenguaje de alto nivel (C)

Un lenguaje de alto nivel permite escribir programas en

La tarea de traducir el texto (cdigo fuente) a

El lenguaje de alto nivel (C)

Para escribir programas en lenguaje de alto nivel, el

Ejemplo: calcular media de 4 valores.

Qu secuencia de operaciones permite obtener la media?

El lenguaje de alto nivel (C)

El programador debe utilizar de forma precisa la notacin

Declaracin de programa principal:

Comentarios (el compilador no los

Entrada/salida por consola en C

Salida por consola (pantalla):

\n en el texto significa retorno de carro.

Entrada/salida por consola en C

Entrada de consola (teclado):

Introduzca alumnos y nota media: 12 7.25

Realizar un programa que pida los lados de un rectngulo, y calcule y

Introduccin al computador y el lenguaje C

Datos, expresiones y algoritmos

Operaciones con valores binarios

Preprocesador y compilacin separada

E/S en archivos y dispositivos

Criterios de buena programacin

Los datos pueden ser de varios tipos. Los ms bsicos:

El cdigo programa puede utilizar datos de dos

// Variable tipo entero, sin inicializar

Constantes: valores que no cambian a lo largo del programa.

y usar despus mediante el nombre:

Y si hay datos que no son de los tipos bsicos?

Hay que buscar la mejor conversin de nuestros tipos de

Colores: un color es la combinacin de 3 valores (RGB); se pueden

Sentencia bsica: la asignacin.

Expresin: resultado de una operacin matemtica,

Los operandos pueden ser:

// Incluir <math.h> para usar cos()

A tener en cuenta al realizar expresiones:

Los clculos internos (secuencia de instrucciones de mquina