Lenguaje C, ampliado

El lenguaje C
Introducción
Construcción de programas
●
●
●
●
Escribir el/los fuente/s (*.c)
Incluir los archivos de encabezado (*.h)
Compilar
Enlazar (linking)
Palabras claves
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
Estructura de un programa
# include <stdio.h>
// variables externas a usar
int main()
{
printf(“Hello, world.");
return 0;
}
Directiv
a
preproce al
sado
r
Estructura de un programa
#include <stdio.h>
int main() {
/* Comentario ignorado por el compilador */
int index;
index = 13;
printf("The value of the index is %d\n", index);
index = 27;
printf("The value of the index is %d\n", index);
return 0;
}
Estructura de un programa
«grande»
n
Uso de archivos cabecera (.h)
por lo general sólo contienen definiciones de tipos
de datos, prototipos de funciones y comandos del
preprocesador de C
n
Uso de varios archivos .c
por lo general con un preámbulo consistente de las
definiciones de constantes, cabeceras a incluir,
definición de tipos de datos, declaración de variables
globales y externas (e inicializacion), y una o más
funciones
Estructura de un programa
«grande»
n
División en directorios
Por lo general agrupando los archivos relacionados o
bajo cierta lógica
n
Uso de make y makefile
Para una fácil y consistente compilación
n Uso de macros en make
típicamente usadas para guardar nombres de
archivos fuente, nombres de archivos objeto,
opciones del compilador o links a bibliotecas
Tipos de datos
n
n
n
n
n
char (1 byte)
int (2 bytes)
float (4 bytes)
double (8 bytes)
void
n short – long – signed - unsigned
Constantes
n
n
n
n
n
n
n
n
2323 int
5656L long
78.56float
89e-2float
56.9Ldouble
033 octal
0xf1 hexadecimal
0xFUL unsigned long (15 en decimal)
Constantes
n
n
n
‘n’ caracter
‘\000’ carácter (representado en octal)
‘\xhh’ carácter (representado en hexa)
\a
alerta
\\
barra
\b
blanco
\?
Pregunta
\f
fin de linea
\’
Comilla simle
\n
Nueva linea
\”
Doble comilla
\r
Carriage return
\v
Tab vertical
\t
Tab horizontal
Constantes
n
Enumeración: es una lista de valores enteros
constantes. Es una opcion al #define.
enum opcion {SI,NO,TALVEZ}; //SI vale 1, NO vale2,
y así sucesivamente.
enum dia {LUNES=1, MARTES=2, ...DOMINGO=‘F’}
dia k;
k=LUNES;
k=3;
Identificadores
n El primer carácter debe ser una letra,
después puede haber letras, números o
guión bajo.
n Es sensible a mayúsculas y minúsculas.
n Hasta 31 caracteres.
Variables
n Deben declararse antes de utilizarse y pueden
ser:
n externas: se definen sólo una vez, fuera de toda
función y se declaran extern (implícita o
explicitamente) en cada función que las vaya a
utilizar, siendo comunes a todas. Son inicializadas
a 0 por omisión.
n internas (o automáticas): son declaradas dentro
de una función y solo existen en ellas. No tienen
una inicialización por omisión, quedan indefinidas
en su valor inicial si no se las inicializa
explícitamente.
Variables
n Las variables pueden ser:
n estáticas: son visibles sólo dentro del archivo
fuente (externas) o función (internas) en donde se
declaran. Las estáticas internas mantienen su
valor en sucesivos llamados a la función. Son
inicializadas a 0 por omisión. Se deben inicializar
con un valor o una expresión constante.
n register: le indica al compilador que la variable
será muy usada. El compilador decidirá si será
almacenada en un registro. No poseen
inicialización por omisión.
Calificadores de tipo
n
Sirven para dar características
especiales a los objetos (variables) que
están siendo declarados:
n const: se puede inicializar, pero después no
puede cambiarse el valor
n volatile: le indica al complilador que su
contenido puede variar mas allá del flujo
del programa (no son optimizables)
Calificador de tipo volatile
int z=8;
int main() {
for (int k=1;k<=100;k++){
printf("Z vale%d\n", z);
}
}
¿Y si Z cambia su
valor por factores
externos?
Ejemplos const y volatile
La comillas
dobles definen
una cadena
const double e = 2.7182
const char msg [] = “warning:”
int strlen (const char []);
const int hex = 0x80A; /* 2058 en decimal */
const int oct = 012; /* 10 en decimal */
volatile int k=2;
volatile unsigned char puerto1 @0x00000002
Arreglos y Cadenas
int digitos [10];
int valores[] = {3,4,5,6,7}; // longitud 5
char patron [] = “salida”;
es equivalente a:
char patron [] = {‘s’, ‘a’, ‘l’, ‘i’, ‘d’, ‘a’,
‘\0’} // longitud 7
Operadores aritméticos
Operador
Nombre
definicion
*
Multiplicación
Multiplica x por y
/
Division
Divide x por y
%
Modulo
Resto de x dividido y
+
Suma
Suma x mas y
-
Susbtracción
Resta y de x
++
Incremento
--
Decremento
-
Negación
+
Suma unaria
++X
--X
X++
X--
Multiplica x por -1
Acceso a datos y elementos
de array
Operador
Nombre
Ejemplo
Definición
[]
Elemento de
array
X[6]
7mo elemento de x
.
Selección de
miembro
PORTD.2
2do bit de PORTD
->
Selección de
miembro
pStruct->x
Miembro x de la
estructura apuntada
por pStruct
*
Indirección
*p
Contenido de la
memoria localizada en
la dirección p
&
Dirección de
&x
Direccion de la variable
x
Operadores lógicos
Operador
Ejemplo
Definición
>
x>y
1 si x es mayor que y, en caso contrario es 0
>=
x >= y
1 si x es mayor o igual a y, en caso contrario
es 0
<
x<y
1 si x es menor que y, en caso contrario es 0
<=
x <= y
1 si x es menor o igual a y, en caso contrario
es 0
==
x == y
1 si x es igual que y, en caso contrario es 0
!=
x != y
1 si x no es igual que y, en caso contrario es 0
Operadores lógicos
!
!x
1 si x es 0, en caso contrario es 0
&&
x && y
0 si x o y es 0, en caso contrario 1
||
x || y
0 si x e y son 0, en caso contrario 1
Operadores de bits
Operador
Nombre
Ejemplo
Definición
~
NOT
~x
Cambia 1 por 0, y 0 por 1
&
AND
x&y
AND bit a bit de x e y
|
OR
x|y
OR bit a bit de x e y
^
XOR
x^y
XOR bit a bit de x e y
<<
Desp. Izq.
x<<2
Bits de x los desplaza 2pos. a la
izquierda
>>
Desp. Der.
x>>2
Bits de x los desplaza 2pos. a la
derecha
Sentencias de control
n
n
n
n
n
n
n
while
do...while
for
if ..else
break
continue
switch
Sentencia while y do-while
// ejemplo while
while( condicion ){
sentencia;
…
}
// ejemplo do-while
do{
sentencias;
…
} while( condicion )
Sentencia for
for( condicion inicial; control; variacion ){
…
}
// ejemplo:
for( i = 0; i < 10; i++){
cont += i;
}
Sentencia if
1:
if (something_is_true) {
/* do something */
}
2a: if (something_is_true) {
/* do one thing */
}
else {
/* do something else */
}
2b: ? (something_is_true) :
/* do one thing */
:
/* do something else */
Sentencia switch
switch (integer value)
{
case 1: statement1;
break;
/* optional line */
case 2: statement2;
break;
/* optional line */
....
default: default statement
break;
/* optional line */
}
break y continue
break rompe la secuencia de un ciclo
while, do-while, switch o for, saltando a la
primera sentencia externa al bloque.
continue retoma el control en la próxima
iteración de un ciclo ciclo while, do-while
o for
Funciones
n
n
n
En general un programa en C son
muchas funciones de pequeño tamaño,
y no pocas funciones de gran tamaño.
La comunicación entre las funciones es
por los argumentos, valores de retorno
y a través de variables externas.
Los argumentos son pasados por valor.
Estructuras de datos
n
struct: Colección de variables de distinto tipo,
agrupadas bajo un nombre. En memoria puedo
almacenar cualquier variable del tipo struct que se
defina
rótulo opcional
struct point{
int x;
int y;
};
....
struct point pt = {3,5};
printf (“%d, %d”, pt.x, pt.y);
struct {
int pulseFrec;
unsigned char pulseWdith;
} pulser1, pulser2;
ó
struct pwm{
int pulseFrec;
unsigned char pulseWdith;
} pulser1, pulser2;
Estructuras
n
Las estructuras se pueden anidar :
struct rect {
struct point p;
struct point z;
};
...
struct rect ventana;
ventana.p.x =25;
Estructuras y funciones
n
Las estructuras se puede pasar como argumentos de funciones.
struct point pt = {3,5};
struct point *pp;
pp = &pt;
n pasar la estructura completa (pt):
void funcion( struct point w)
n pasar un componente de la estructura (pt.x):
void funcion( int w)
n pasar un puntero a una estructura (pp)
void funcion( struct point *w)
Arreglos de estructuras
struct message {
int emisor;
int receptor ;
char datos [50];
}
struct message buffer[50];
buffer[0].emisor=0;
Uniones
n
n
n
n
n
Es semejante a una estructura, pero los campos que
declaramos en una unión ocupan todos la misma
posición de memoria.
Solo se puede almacenar un campo por vez.
Cuando se define una unión solo se reserva espacio
para almacenar el campo de mayor tamaño.
Permite manejar distintos tipos de datos en una
misma área de almacenamiento
El programador es responsable del uso debiendo
asignar y recuperar coherentemente.
Uniones
union ejemplo {
int entero;
//16 bits
char caracter; //8 bits
} mi_var;
mi_var. entero =0; // solo se puede incializar mediante el
primer miembro
mi_var. caracter =‘A’; //(como el carácter ASCII de A es
65, mi_var.entero vale 65, es
decir 000000001000001)
mi_var. entero= 65; // pero no es seguro que
mi_var.caracter sea una ‘A’
Campo de bits
n
n
Es un conjunto de bits adyacentes, agrupados, en
una palabra.
Los bits se manipulan según su tipo declarado
Puede ser
cualquier
numero de bits
struct {
unsigned int ctrl_compresor :1;
unsigned int ctrl_cinta :1;
unsigned int ctrl_quemador :1;
} control;
...
control.ctrl_compresor=1; //enciende el compresor
Creación de tipos de datos
n La instrucción typedef crea una
definicion de un tipo de datos:
typedef int Longitud;
hace que Longitud sea un sinónimo de
int. Luego se puede hacer:
Longitud k;
lo que declara k del tipo Longitud, con
todas sus características.
Ejemplos de creación de tipos
de datos
typedef struct {
int coor_x;
int coor_y;
} Complejo;
crea el tipo Complejo que es análogo a la
estructura definida en este caso.
Ejemplos de creación de tipos
de datos
typedef unsigned char byte; //crea el tipo byte
typedef union {
byte Byte;
struct {
byte b0
:1;
byte b1
:1;
byte b2
:1;
byte b3
:1;
} Bits;
} Control;
//crea el tipo Control
luego:
Control Z;
Z.Byte= 4;
Z.Bits.b2=˜Z.Bits.b2;
Entrada/Salida
n
n
El C no tiene instrucciones específicas para
I/O.
Existen un conjunto de funciones para I/O
desarrolladas y agrupadas en la biblioteca
(library) estándar (ANSI): stdio.h
#include <stdio.h> //incluye en el programa
todas las funciones de la librería.
Salida con formato
n
int printf(“Cadena de control”, variables,
operaciones, ...);
printf(“La salida es %6.1f:”,temp);
campo
Entrada con formato
n
n
int scanf(“Cadena de control”, variable,
variable, ...);
La variable o variables que se van a introducir
tendrán que ir acompañadas delante del nombre
por el signo & (son punteros).
Ejemplo E/S
#include <stdio.h>
main() {
int edad;
debe ser lo suficientemente grande
char nombre[20];
printf(“Introduce nombre: \n“);
scanf(“%s”, nombre);
printf(“Introduce edad: \n”);
scanf(“%d”, &edad);
printf(“Tu nombre es %s y tienes %d años. \n”,
nombre, edad);
}
Caracteres de control
n
n
n
n
n
n
n
n
n
n
d
c
s
f
e
u
o
x
X
p
entero decimal
caracter
cadena de caracteres
número de punto flotante con notación decimal
número de punto flotante con notación exponencial
entero decimal sin signo
entero octal sin signo
entero hexadecimal sin signo (minúsculas)
entero hexadecimal sin signo (mayúsculas)
puntero
Funciones para manejar
caracteres
n
int getchar(void ): captura caracteres
uno a uno desde la entrada estándar
char variable;
variable=getchar();
Funciones para manejar
caracteres
n
int putchar(int): imprime caracteres uno
a uno en la salida estandar y devuelve
el carácter escrito o EOF si hubo error.
char variable=‘m’;
putchar(variable);
Proceso de compilación
n La compilación de un programa C se realiza en
varias fases que normalmente son automatizadas
y ocultadas por los entornos de desarrollo:
n Preprocesado: consistente en modificar el código en C
según una serie de directivas de preprocesador.
simplificando de esta forma el trabajo del compilador.
n Compilación: que genera el código objeto a partir del
código ya preprocesado.
n Enlazado: que une los códigos objeto de los distintos
módulos y bibliotecas externas (como las bibliotecas
del sistema) para generar el programa ejecutable final.
Directivas al preprocesador
n
Facilidad del lenguaje:
n Inclusión de archivos include
n Definición de macros define
n Operador
##
n Inclusion condicional # if !defined ......
Directivas al preprocesador
n
Inclusión de archivos:
#include “nombrearchivo”
o
#include <nombrearchivo>
n Incluye el contenido del archivo en donde
se encuentra el include
n El proceso es recursivo
Directivas al preprocesador
n
Sustitución de macros:
#define nombre texto_de_reemplazo
n Reemplza nombre por texto_de_reemplazo
en todo el codigo subsiguiente
n Puede manejar argumentos
n La sintaxis debe manejarse con mucho cuidado
Directivas al preprocesador
n
Ejemplo:
#define PI 3.1416
#define max(A,B) ((A)>(B)?(A):(B))
Si mas adelante en el código en el código dice:
x=max(p+g,PI);
Quedará:
x=((p+g) > (3.1416) ? (p+g) : (3.1416));
Antes de compilar.
Directivas al preprocesador
#undef nombre
n asegura que nombre no será sustituido
##
n Concatena argumentos reales durante la sustitucion
Ejemplo:
#define unir(inicio,fin) inicio ## fin
Hace que:
A[unir(zapa,tero)];
Pase a ser:
A[zapatero];
Directivas al preprocesador
n Inclusión condicional:
#if MICRO == INTEL
#define LIBRERIA “intel.h”
#elif MICRO == AMD
#define LIBRERÍA “amd.h”
#else
#define LIBRERÍA
...
/*aquí va la definicion de la librería generica*/
...
#endif
#include LIBRERIA
Directivas al preprocesador
n #IFDEF, #IFNDEF
n Son If especializados que testean si un
nombre está definido
#ifndef LIBRERÍA
#define LIBRERÍA
....
#endif