Tema 1

Introducción al
Lenguaje C
1
 Introducción a C
1. Características generales
2. Tipos, operadores y expresiones
3. Arrays
4. Flujos de control
5. Estructuras
6. Funciones
7. Otras cuestiones
8. Bibliografía
9. Ejercicios 2
 Un tutorial clásico

Ejemplos tomados de:

Programming in C – A Tutorial
Brian Kernighan, Bell Labs
http://www.lysator.liu.se/c/bwk-tutor.html

© 2009 Grupo ARCO Estructura de Computadores 3

 Características generales

Características generales
● Pocas palabras reservadas (32)
● Cercanía a la máquina
–Se usa en muchos núcleos de sistemas
operativos
– Prácticamente tan eficiente como
ensamblador
● Muy portable
– Desde mainframes a micro-controladores
© 2009 Grupo ARCO Estructura de Computadores 4
 Características generales

Estructura de un programa
printf es una función de la biblioteca
estándar que formatea e imprime
textos por salida estándar
main()
main(){{
printf("hello,
printf("hello,world\n");
world\n");
}}

● Una o más funciones La ejecución empieza en la

primera sentencia de main
– Al menos hay una función main
– Invoca otras para hacer el trabajo
● Se comunican mediante paso de argumentos
– Delimitada por { }, sentencias terminan en ;

© 2009 Grupo ARCO Estructura de Computadores 5

 Características generales

Un programa funcional
Variables, tipos y declaraciones

main()
main(){{
int
inta,a,b,b,c,c,sum;
sum;
aa==1;1; bb==2;2; cc==3;3;
sum
sum==aa++bb++c;c;
printf("sum
printf("sumisis%d",%d",sum);
sum);
}}

● Suma tres enteros e imprime el resultado

– a, b, c, y sum se declaran como variables de tipo
entero
– Nombres sin caracteres raros (a-z, A-Z, 0-9, _)

© 2009 Grupo ARCO Estructura de Computadores 6

 Tipos, operadores y expresiones

Tipos básicos
● Las variables deben declararse para poder ser
usadas (indica el tipo)
● Tipos básicos
int Entero del tamaño de una palabra
char Carácter (o entero) de 1 byte
float Número real en coma flotante de
simple precisión
double Número real en coma flotante de
doble precisión

© 2009 Grupo ARCO Estructura de Computadores 7

 Tipos, operadores y expresiones

Constantes
int
inta;a;char
charquest,
quest,newline,
newline,flags;
flags;
aa==1;1;
quest
quest=='?';'?';
newline
newline ='\n';
= '\n';
flags = 077;
flags = 077;

'\n' nueva línea '\\' carácter \

'\t' tabulador 77 decimal
'\b' backspace 077 octal
'\0' terminador 0x77 hexadecimal

© 2009 Grupo ARCO Estructura de Computadores 8

 Tipos, operadores y expresiones

Entrada/salida simple
getchar, putchar

main(
main() ){{
char
charc;c;
cc==getchar(
getchar(););
putchar(c);
putchar(c);
}}

getchar toma un carácter del terminal

putchar saca carácter por salida estándar
printf salida de texto con formato

© 2009 Grupo ARCO Estructura de Computadores 9

 Tipos, operadores y expresiones

Entrada/salida simple
printf

main(
main() ){{
int El formato
intn;n;
nn==511;
511; Lo que tiene
printf
printf("¿Cuál
("¿Cuáles
eselelvalor
valorde
de%d
%den
enoctal?",
octal?",n);
n); que formatear
printf
printf("%s!
("%s!%d
%ddecimal
decimales es%o
%ooctal\n",
octal\n","Correcto",
"Correcto",n,n,n);
n);
}}

%d formatear como número decimal

%o formatear como número octal
%x formatear como número hexadecimal
%s insertar una cadena de texto
© 2009 Grupo ARCO Estructura de Computadores 10
 Tipos, operadores y expresiones

Expresiones básicas
● a == b 1 si a es igual a b
● a != b 1 si a difiere de b
● a>b 1 si a es mayor que b
● a<b 1 si a es menor que b
● a >= b 1 si a es mayor o igual que b
● a<b 1 si a es menor o igual que b
● a && b 1 si a ≠ 0 y b ≠ 0
● a || b 1 si a ≠ 0 o b ≠ 0
© 2009 Grupo ARCO Estructura de Computadores 11
 Tipos, operadores y expresiones

Incremento y decremento
● ++n equivale a n = n + 1
--n equivale a n = n - 1
– Más claro, especialmente si n es complejo
● Existe una versión postfija que devuelve el valor
antes de incremento/decremento

int
inta,a,b,b,x,x,y;y; a == 6 b == 6
aa==bb==5;5; x == 5 y == 6
xx==a++;
a++;
yy==++b;
++b;

© 2009 Grupo ARCO Estructura de Computadores 12

 Flujo de control

Precedencia de operadores

© 2009 Grupo ARCO Estructura de Computadores 13

 Flujo de control

Precedencia de operadores
● (c = getchar()) != '\0'
– Asigna a c un carácter de la entrada estándar
– Compara dicho valor con '\0'
● c = getchar() != '\0' El operador != tiene más
precedencia que el operador =
– Obtiene un carácter de la entrada estándar
– Compara dicho valor con '\0'
– Asigna el resultado de la comparación a c

© 2009 Grupo ARCO Estructura de Computadores 14

 Arrays

Arrays (vectores)
● Se puede declarar un array y usarlo así
int
intx[10];
x[10];int
inty[10][10];
y[10][10];
x[0]
x[0]==1;1;x[8]
x[8]==x[9]
x[9]==5;5;
y[0][0]
y[0][0]==y[1][0]
y[1][0]==8;8;

● Al declararlo se indica el número de elementos

– Tiene que ser constante
Arrays de arrays
– Índices en el rango 0..N-1
– Pueden ser N-dimensionales

© 2009 Grupo ARCO Estructura de Computadores 15

 Arrays

Ejemplo de arrays
● Contar caracteres de cada línea y almacenar los
primeros 100 caracteres

main( ) { El tamaño del array tiene

main( ) {
int n, c; char line[100]; que ser constante
int n, c; char line[100];
n = 0;
n = 0;
while((c=getchar()) != '\0')
while((c=getchar()) != '\0')
if(c == '\n') {
if(c == '\n') {
printf("%d\n", n);
printf("%d\n", n);
n = 0;
n = 0;
}
} Se puede indexar con
else {
else { cualquier
if( n < 100 ) line[n] = c; expresión
if( n < 100 ) line[n] = c;
n++;
n++;
}
}
}
}

© 2009 Grupo ARCO Estructura de Computadores 16

 Arrays

Arrays de caracteres
También llamados
cadenas de texto
● Normalmente terminados en '\0'
– printf lo utiliza como marca de final
● Ejemplo:
– Imprimir longitud así como cada línea
main(
main() ){ {
int
intn;n;
char
charline[100];
line[100];
nn= =0;0;
while((line[n++]=getchar(
while((line[n++]=getchar())))!=!='\n');
'\n');
line[n] = '\0';
line[n] = '\0';
printf("%d:\t%s",
printf("%d:\t%s",n,n,line);
line);
}}

© 2009 Grupo ARCO Estructura de Computadores 17

 Flujo de control

Sentencias condicionales
if, operaciones de relación y lógicos

Evalúa si la
expresión es ≠0
cc==getchar();
getchar();
if(c
if(c =='?')
== '?')
printf("¿Por
printf("¿Porqué
quéhas
hasescrito
escritoun
unsigno
signode
deinterrogación?");
interrogación?");

false: = 0
● Sentencia condicional básica true:≠ 0

– if (expresión) sentencia;
● Op. Relación == != < > <= >=
● Op. Lógicos && || !
– if (a < b && (a < 0 || a > 100)) ...

© 2009 Grupo ARCO Estructura de Computadores 18

 Flujo de control

Bloques y clausula else

● Sentencia arbitrariamente compleja agrupando
varias con { }

ifif(a
(a<<b) b){{ Bloque de
t t==a;a; sentencias
aa==b;b;
bb==t;t;
}}

© 2009 Grupo ARCO Estructura de Computadores 19

 Flujo de control

Bucles básicos
while, expresión de asignación

main()
main(){{
char
charc;c;
while((c=getchar())
while((c=getchar())!=
!='\0')
'\0') La asignación también
putchar(c);
putchar(c); tiene un valor
}}
Es posible hacer
a = b = c = 0;

● Sentencia while
– while (expresión) sentencia;
1.Evalúa expresión
2.Si es true (≠0) ejecuta sentencia y vuelve a 1

© 2009 Grupo ARCO Estructura de Computadores 20

 Flujo de control

Sentencia nula

main()
main(){{
while(putchar(getchar())
while(putchar(getchar())!=!='\0')
'\0')
;; Sentencia nula
}}

● La función putchar(c) devuelve c

– Se puede compactar el ejemplo anterior
● El bucle no tiene nada que ejecutar en el cuerpo
– La sentencia nula no ejecuta nada

© 2009 Grupo ARCO Estructura de Computadores 21

 Flujo de control

Aritmética
Resto

● Operadores aritméticos: + - * / %
● Los caracteres pueden tratarse como enteros
– E.g. Paso de mayúscula a minúscula:
c = c + 'a' - 'A';

main(
main() ){{
char
charc;c;
while((c=getchar()) != '\0') Si es una letra
while((c=getchar()) != '\0') mayúscula
if('A'<=c
if('A'<=c&&
&&c<='Z')
c<='Z')
putchar(c+'a'-'A');
putchar(c+'a'-'A');
else
else
putchar(c);
putchar(c);
}} Imprimir
minúscula

© 2009 Grupo ARCO Estructura de Computadores 22

 Flujo de control

Tabla ASCII

© 2009 Grupo ARCO Estructura de Computadores 23

 Flujo de control
Claúsula else
Expresión condicional
● Cada sentencia if puede tener una claúsula else
– if (expresión) sentencia1; Sentencia2 se ejecuta
si la expresión es = 0
else sentencia2;
Operador condicional
● Otra forma ternario

– expresión1 ? expresión2 : expresión3

● Evalúa expresión1
● Si es true evalúa expresión2
● En caso contrario evalúa expresión3

© 2009 Grupo ARCO Estructura de Computadores 24

 Flujo de control

Otra vez el paso a minúsculas

while((c=getchar())
while((c=getchar())!=
!='\0')
'\0')
putchar(('A'
putchar(('A' <= c &&cc<=
<= c && <='Z')?
'Z')?c-'A'+'a':
c-'A'+'a':c);
c);

● Más compacto no necesariamente mejor

– El novato leerá mejor la otra versión
– El experimentado preferirá normalmente ésta
● Se dice que C es muy expresivo
– Porque casi todo son expresiones
– Porque puede expresar comportamientos complejos con
muy pocas líneas
© 2009 Grupo ARCO Estructura de Computadores 25
 Flujo de control

Escaleras de if/else
● Contar letras, dígitos y otros caracteres
main(
main( )) {{
int
int let,
let, dig,
dig, other,
other, c;c; Incremento
let
let == dig
dig == other
other == 0;
0;
while((c=getchar())
while((c=getchar()) != '\0')
!= '\0')
if(('A'<=c
if(('A'<=c && c<='Z') ||
&& c<='Z') || ('a'<=c
('a'<=c &&
&& c<='z'))
c<='z')) ++let;
++let;
else if('0'<=c && c<='9') ++dig;
else if('0'<=c && c<='9') ++dig;
else
else ++other;
++other;
printf("%d
printf("%d letras,
letras, %d%d dígitos,
dígitos, %d
%d otros",
otros", let,
let, dig,
dig, other);
other);
}}

if (expr) sentencia1;
else if (expr2) sentencia2;
else if (expr3) sentencia3;
...
else sentenciaN;

© 2009 Grupo ARCO Estructura de Computadores 26

 Flujo de control

Sentencia switch
● Algunas escaleras if/else pueden implementarse
más eficientemente

switch(c) { switch(c)
switch(c){{
switch(c) { case
case 'a':
case 'a': case'a':'a':case
case'A':
'A':
aflag++; aflag++;
aflag++;
aflag++;
break;
break;
break;
break;
case 'b': case
case 'b':
bflag++; case'b':'b':case
case'B':
'B':
bflag++; bflag++;
bflag++;
break; break;
break; break;
case 'c':
case 'c': ......
cflag++;
cflag++; }}
break;
break;
default:
default:
printf("%c?\n", c);
printf("%c?\n", c);
}
}

© 2009 Grupo ARCO Estructura de Computadores 27

 Flujo de control

Sentencias break y continue

● La sentencia switch usa break para salir
– Análogamente for y while pueden terminar el bucle con
un break
● La sentencia continue permite avanzar a la
siguiente iteración sin ejecutar más de la actual

for(;;)
for(;;){{
......
ifif(condicionDeSalida)
(condicionDeSalida)break;
break;
......
}}

© 2009 Grupo ARCO Estructura de Computadores 28

 Flujo de control

El bucle for
● Es un caso especial de bucle while
– for(inic; expresión; incr)
sentencia;
● Equivale a
– inic;
while(expresión) {
sentencia;
incr;
}

© 2009 Grupo ARCO Estructura de Computadores 29

 Flujo de control

Ejemplos de bucle for

● Copiar arrays de caracteres
for(i=0;
for(i=0;(t[i]=s[i])
(t[i]=s[i])!=
!='\0';
'\0';i++);
i++);

● Sumar los elementos de un array

sum
sum == 0;
0;
for(
for( i=0;i<n;
i=0; i<n;i++)
i++)sum
sum==sum
sum++array[i];
array[i];

● Inicializar un array bidimensional

for(
for(i=0;
i=0;i<n;
i<n;i++
i++) )
for(
for(j=0;
j=0;j<m;
j<m;j++j++) )
array[i][j]
array[i][j]==0;0;
No se necesitan sentencias compuestas

© 2009 Grupo ARCO Estructura de Computadores 30

 Estructuras

Estructuras
● Agrupaciones inhomogéneas

struct
struct{{ struct
structsymtsymt{{
char
char id[10];
id[10]; ......
int
int line;
line; };
};
char
char type; struct
type; structsymtsymtsym[10],
sym[10],*psym;
*psym;
int
int usage;
usage;
}}sym; psym
sym; psym==&sim[0];
&sim[0];
psym->type
psym->type==077;
077;
sym.type
sym.type==077; psym->usage
077; psym->usage =0;0;
=
sym.usage
sym.usage =0;0;
= ......
......

psym->type es (*psym).type

© 2009 Grupo ARCO Estructura de Computadores 31

 Funciones

Funciones
Definición y declaración

● Definición de función
int
intmin(int
min(inta,a,int
intb)
b){{
return
returnaa<<bb??aa: :b;b;
}}
Pueden devolver un valor
void = no devuelve nada

● Declaración de función
int Declara tipos de argumentos y valor de retorno
intmin(int
min(inta,a,int
intb);
b);
......
i i==min(10,
min(10,6);6); El compilador
...... comprueba que se usa
correctamente

© 2009 Grupo ARCO Estructura de Computadores 32

 Funciones

Declaración implícita
● Siempre deben declararse las funciones
– Si no se declara se genera una declaración implícita:
● int funcion(); Argumentos desconocidos

– La declaración implícita impide que el compilador

compruebe los argumentos

© 2009 Grupo ARCO Estructura de Computadores 33

 Funciones

Comentarios
● Comentarios entre /* */
– En C99 también // hasta final de línea
void
voidstrcopy(char
strcopy(chars1[],s1[],char
chars2[])
s2[]){{/*/*copia
copias1
s1en
ens2
s2*/*/
int
inti;i;
for(i
for(i==0;0;(s2[i]
(s2[i]==s1[i])
s1[i])!=
!='\0';
'\0';i++);
i++);
}}

– Se omite el tamaño de los arrays porque no es necesario

© 2009 Grupo ARCO Estructura de Computadores 34

 Otras cuestiones

Variables automáticas y externas

● Automáticas son locales ● Externas son siempre

al bloque accesibles
ifif(a
(a<<b) b){{ int
inti;i;
int
inti;i; void
voidf() f(){{
...... ......
}} }} Variables externas se
Al terminar el inicializan a 0
bloque desaparece i automáticamente
void
voidg()g(){{
extern
externint
inti;i;
......
}}
La variable i es accesible
desde cualquier función.
Incluso en otro archivo

© 2009 Grupo ARCO Estructura de Computadores 35

 Otras cuestiones

Inicialización de variables
● En la propia definición se proporciona un valor
inicial
– La inicialización puede ser más eficiente que la
asignación

int
intxx==20;
20;int
intaa=='k';
'k';char
charcc==0177;
0177;
int y[] = { 1, 2, 3, 4 };
int y[] = { 1, 2, 3, 4 };
int*
int*pp==&y[1];
&y[1];
char*
char* msg=="Error
msg "Errorde
deformato";
formato";
char
char buf[] = "Introducelos
buf[] = "Introduce losdatos";
datos";
No es lo mismo msg y buf. La
cadena de msg no puede ser
alterada. ¿Por qué?

© 2009 Grupo ARCO Estructura de Computadores 36

 Otras cuestiones

El preprocesador
● Preprocesador: paso previo a compilación
● Interpreta directivas
– Las directivas empiezan por #

#include
#include<stdio.h>
<stdio.h> #define
#defineMAXBUFSIZE
MAXBUFSIZE2525
FILE* f;
FILE* f; int buf[MAXBUFSIZE];
int buf[MAXBUFSIZE];
Incluye el archivo stdio.h
(declaraciones de la Macro-constante
biblioteca estándar)

© 2009 Grupo ARCO Estructura de Computadores 37

 Otras cuestiones

Operaciones de bits
● a&b AND
● a|b OR (or inclusivo)
● a^b XOR (or exclusivo)
● ~a Complemento a 1
● ! Negación lógica
● a << b Desplaza a b bits a la izquierda
● a >> b Desplaza a b bits a la derecha

© 2009 Grupo ARCO Estructura de Computadores 38

 Otras cuestiones

Asignaciones especiales
● a -= b a = a - b
● a &= b a = a & b
● a <<= b a = a << b
● ...

© 2009 Grupo ARCO Estructura de Computadores 39

 Otras cuestiones

Coma flotante
● Calcular la media de un vector de reales de simple
precisión

double
doublesum;
sum;
float
float avg,y[10];
avg, y[10];
sum = 0.0; Se pueden mezclar
sum = 0.0; distintos tipos numéricos.
for(
for(i=0;
i=0;i<n;
i<n;i++
i++) ) Hay promoción implícita
sum
sum=+=+y[i];
y[i]; de tipos
avg
avg==sum/n;
sum/n;

© 2009 Grupo ARCO Estructura de Computadores 40

 Otras cuestiones

Tipos de usuario
typedef

● Se puede dar nombre a tipos complejos

– Son totalmente equivalentes (alias)

typedef
typedefstruct structsymt_
symt_symt;
symt;
struct symt_
struct symt_ { {
char
charid[20];
id[20];
int type;
int type;
......
};};
......
struct
structsymt_ symt_sym1
sym1=={};
{};
symt sym2;
symt sym2;
sym2
sym2==sym1; sym1;

© 2009 Grupo ARCO Estructura de Computadores 41

 Otras cuestiones

Proceso de compilación
Primero compilar, luego
$ gcc -c archivo1.c montar
archivos.c
$ gcc -c archivo2.c
$ gcc -o ejecutable archivo1.o archivo2.o
Compilador
C
Todo de golpe

$ gcc -o ejecutable archivo1.c archivo2.c

archivos.o

Montador

ejecutable

© 2009 Grupo ARCO Estructura de Computadores 42

 Pasos para realizar los
ejercicios
1. Abre un editor de texto
– Por ejemplo gedit
2. Edita el código del programa y guárdalo con
extensión '.c'
– Por ejemplo “prueba.c”
3. Abre un terminal y compila el programa
$ gcc prueba.c

4. Ejecuta el programa
– Por defecto se habrá generado como “a.out”
$ ./a.out

© 2009 Grupo ARCO Estructura de Computadores 43

 Bibliografía

Aprender C
● The C Programming Language, 2nd ed.
B. Kernighan, D. Ritchie Buen libro

Prentice-Hall 1988 También traducido al castellano

El lenguaje de programación C
● Tutoriales de libre disposición
– Curso básico de programación en C
Servicios Informáticos, UCM
– Introducción al lenguaje C
ACM SC, Facultad de Informática, UPM
– Introducción a la programación con C
Dpto. LSI, Universidad Jaume I

© 2009 Grupo ARCO Estructura de Computadores 44

 Ejercicios

Ejercicios (1)
● Experimenta con todo el código que se presentado de ejemplo aquí
● Ejecuta el programa “Hola, mundo”
– Experimenta con la omisión de partes del programa para ver qué
mensajes de error se obtienen
● Escribe un programa que cuente espacios en blanco
● Escribe una función que reciba una cadena de texto y la convierta a
minúsculas
● Escribe un programa que invierta la cadena que se le proporcione en
línea de órdenes

© 2009 Grupo ARCO Estructura de Computadores 45