falso - Cobre 2 Software

Fundamentos de
programación
Conceptos Básicos
Estructura de un programa en C
• Directivas del preprocesador
• Declaraciones globales y/o externas
- Prototipos de funciones (cabeceras)
- Variables
• Declaraciones de funciones (subprogramación)
- Función principal main
- Definición, en su caso, de otras funciones
Estructura de un programa
/* primer programa */
#include <stdio.h>
main()
{
printf (“Hola Mundo\n”);
}
Estructura de un programa
/* primer programa */
#include <stdio.h>
int main()
{
printf (“Hola Mundo\n”);
return 0;
}
Estructura de un programa
/* primer programa */
#include <stdio.h>
void main()
{
printf (“Hola Mundo\n”);
}
Estructura de un programa
/* primer programa */
#include <stdio.h>
void main(void)
{
printf (“Hola Mundo\n”);
}
Directivas del preprocesador
Son instrucciones dadas al compilador previas a
la obtención del código objeto (fase de la
compilación).
Tienen la forma
#directiva
Las dos más usuales son #include y #define
#include “filetype.h”
#include <ctype.h>
#define LENGTH 20
#define MAX(a,b) ((a) > (b) ? (a) : (b))
#ifdef _TEST_
#undef _TEST_
Directivas del preprocesador
#include “filename”
#include <filename>
Indica al preprocesador que inserte el fichero filename
desde la posición donde se encuentra la directiva.
#include “mifichero.ext”
#include <string.h>
#define item valor
Asocia el objeto item con el valor a su derecha. La definición
es efectiva a partir de la línea donde se encuentra la directiva.
#define MENSAJE “Hola Mundo”
#define Max_Length 500
Declaraciones globales
Son el conjunto de objetos (funciones, constantes, variables,…)
que son conocidos en la totalidad del programa.
Las directivas pueden ser consideradas en algunos casos como
declaraciones globales.
char cadena[ ] = {‘c’,‘a’,‘d’,‘e’,‘n’,‘a’};
unsigned long var = 5, otravar;
struct Fecha {
unsigned char dia;
char *
mes;
unsigned int
año;
} Mi_fecha = {12,“Agosto”,2010};
El conjunto de caracteres de C
Alfabeto: ASCII.
• Letras mayúsculas:
A–Z
• Letras minúsculas:
a–z
• Dígitos:
0–9
• Caracteres especiales:
+
!
<
:
?
>
;
*
^
(
.
/
“
)
,
=
‘
[
_
%
~
]
&
\
{
#
|
}
(espacio en blanco)
El conjunto de caracteres de C
Secuencias de escape
\a
alert (bell)
\\
backslash
\b
backspace
\?
question mark
\f
formfeed
\’
quote
\n
newline
\”
double quote
\r
carriage return
\ooo octal number
\t
horizontal tab
\xhh hex number
\v
vertical tab
Identificadores
Término para denominar varios elementos del programa,
como constantes, variables, funciones, ...y otros objetos
definidos por el usuario.
¾ Secuencia de letras, dígitos y/o subrayados _
¾ El primer carácter debe ser una letra, (algún compilador
admite el carácter de subrayado), no puede empezar con
un número ( el carácter de subrayado es considera como
una letra).
¾ Las letras mayúsculas y minúsculas son diferentes (C es
sensible a mayúsculas).
Identificadores
Identificadores válidos:
X
y12 suma_1
Nombres area
A Habitacion120
_temperatura
porc_imp
TABLA
Fecha_Compra_Casa
Identificadores no válidos:
4num
“x”
Orden-no
Indicador error
el primer carácter debe ser una letra
carácter ilegal “
carácter ilegal –
carácter ilegal (espacio en blanco)
Significativo:
Tabla
TABLA tabla TABla tabLA
Identificadores
Palabras reservadas en ANSI C
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
Tipos de datos
Tipos de datos básicos en C
–
–
–
–
–
char
int
float
double
void
1 byte, normalmente identificado con un carácter.
2 ó 4 bytes, la longitud de palabra de la máquina.
reales, 32 bits con al menos 6 dígitos significativos.
float, en doble precisión.
sin valor de retorno, en general.
Modificadores: short, long, unsigned, signed.
Tipos de datos enumerados
enum escapes { BELL = ‘\a’, BACKSPACE = ‘\b’, TAB = ‘\t’,
NEWLINE = ‘\n’, VTAB = ‘\v’, RETURN = ‘\r’ };
enum months { JAN = 1, FEB, MAR, APR, MAY, JUN,
JUL, AUG, SEP, OCT, NOV, DEC }; /* FEB = 2, MAR = 3... */
Tipos enumerados
enum dia_semana {
LUNES = 1, MARTES, MIERCOLES, JUEVES,
VIERNES, SABADO, DOMINGO = 10, FESTIVO = 10
};
void main ()
{
enum dia_semana dia;
··· ··· ···
if (dia <= VIERNES) printf(“Es laborable”);
··· ··· ···
dia = MARTES;
/* Muestra el valor de la constante: 2 */
printf(“Hoy es: %d”, dia);
··· ··· ···
}
Variables
Objeto abstracto donde se almacena un valor. Se puede
consultar y modificar durante la ejecución del programa.
Declaración: antes de ser usadas por primera vez:
– reservar espacio en memoria.
– asociar un identificador.
– opcionalmente, asignar un valor (inicialización).
unsigned short int a, b, c = 5;
char linea [100], vector[5] ={‘\0’};
char stringvar1 [ ] = {‘H’,‘o’,‘l’,‘a’,‘\0’};
char stringvar2 [ ] = “Hola”;
struct { long int a,b; } estructura;
Constantes
Es un objeto cuyo valor no puede cambiar a lo largo de la
ejecución de un programa.
• Constantes literales:
–
–
–
–
constante enteras
constantes reales
constantes carácter
constante cadena
• Constantes definidas (simbólicas)
• Constantes enumeradas
• Constante de carácter de barra invertida (sec. escape)
Constantes
Constantes declaradas
- El calificador const permite dar un nombre simbólico a una
constante:
const tipo nombre = valor;
Si se omite el tipo, C utiliza int por defecto.
const char caracter = ‘a’;
const int semana = 7;
- La directiva #define no especifica ningún tipo de datos, no
utiliza el operador de asignación = y no termina en ;
Entrada y salida básica
C proporciona entrada y salida con formato.
Entrada / salida estándar. Cuando comienza la ejecución de
un programa C se dispone de tres ficheros (streams)
abiertos de forma automática, y que están accesibles a
través de los correspondientes identificadores definidos en
el header stdio.h
stdin
/* entrada estándar */
stdout /* salida estándar */
stderr /* salida de errores estándar */
Salida básica
En general, salida a pantalla, con formato de mensajes y
valores. La función básica de salida es printf:
printf(cadena_de_formato, dato1,dato2,dato3,...)
printf () transforma los datos, que están en representación
binaria, a ASCII según los códigos transmitidos.
printf(“Valores : %d %d %d”, 234,45,-9);
Valores : 234 45 -9
Salida básica
printf (cadena_de_formato, dato1, dato2,...);
– Cadena_de_formato contiene los tipos de los datos y
forma de mostrarlos.
– dato1,dato2,... variables, constantes, datos de salida.
¾ El número de argumentos de printf es indefinido.
¾ La cadena de formato contiene códigos que determinan la
impresión de los datos.
¾ Cada código comienza con el carácter %, a continuación puede
especificarse el ancho mínimo del dato, y termina con el carácter de
conversión apropiado.
Salida básica
Ejemplo:
char ch;
int num;
··· ··· ···
ch = ‘A’;
num = 17;
printf(“Caracter %c y entero %3d\n”, ch, num);
Salida:
Caracter A y entero 17
Salida básica
Mostrar datos en función de su tipo:
char c; ... printf(“%c”, c);
El dato se considera de tipo carácter.
int i;
... printf(“%d”, i);
El dato se convierte a entero decimal.
string
… printf(“%s”,s);
El dato debe ser una cadena de caracteres.
float f; ... printf(“%f”, f);
El dato se considera de tipo float.
Se convierte a notación decimal, con
parte entera y dígitos de precisión.
double d; printf(“%e”,d); El dato se considera de tipo float.
Se convierte a notación científica, de la
forma: [-]n.mmmmmmE[+/- ]dd.
Salida básica
Salida sin formato
• int putchar(int) visualiza un carácter en dispositivo de
salida estándar.
char c;
putchar(c);
• int puts(const char *) visualiza un string (array terminado
en ‘\0’) en el dispositivo de salida estándar.
char frase[ ] = “Hola mundo”;
puts(frase);
Entrada básica
En general, entrada por teclado, con formato de valores.
La función básica de entrada es scanf:
scanf(cadena_de_formato, var1, var2,var3,...)
cadena_de_formato contiene los tipos de datos a capturar (junto con
su formato). var1,var2,... Variables del tipo de los códigos de control.
Los argumentos var1,var2,... se pasan por dirección o referencia
pues van a ser modificados por la función para devolver los datos.
Por ello es necesario el operador de dirección &
Entrada básica
Ejemplo:
char ch;
int num;
…………
scanf(“%c %d”, &ch, &num);
/* salida más clara, mensajes explicativos */
printf(“Teclear un carácter y un número : ”);
scanf(“%c %d”, &ch, &num);
Entrada básica
Capturar datos en función de su tipo:
char c;
... scanf(“%c”, &c);
int i;
... scanf(“%d”, &i);
float f;
... scanf(“%f”, &f);
double d; … scanf(“%lf”,&d);
Entrada básica
Entrada sin formato
• int getchar( ) devuelve el siguiente carácter leído del dispositivo
de entrada estándar como un char sin signo (convertido a int), o
EOF si es fin de fichero o ocurre un error.
int c;
c = getchar();
• char * gets(char *S) lee la siguiente línea de la entrada
estándar en el array S. Además reemplaza el fin de línea ‘\n’ por
un ‘\0’. Esta función retorna S o NULL si existe un error.
• scanf(“%s”,S) rellena el array S. El criterio de terminación es un
blanco o un fin de línea.
Legibilidad
Comentarios:
•
•
•
Sirven para incluir aclaraciones de código.
– // comentarios en una línea (sólo si se soporta C++)
– /* comentarios en varias líneas */
Incluir cometarios que expliquen lo que hace el programa así como
sus características clave.
Deben aclarar y no confundir.
Sangrías
Líneas en blanco
Identificadores significativos
Declaraciones y constantes
Expresiones aritméticas
Fórmula matemática que devuelve un número.
Asignación.
variable = expresión;
variable1 = variable2 = ··· = variableN = expresión;
Operadores. Unarios
Cambio de signo
Incremento
Decremento
Binarios
Suma
Resta
Multiplicación
División
Módulo
−
++
−−
+
−
*
/
%
Expresiones aritméticas
Forma prefija ++ y postfija −−
x = ((++z) − (w−−)) % 100; z++;
x = (z − w) % 100; w−−;
x = 5; y = x++; /* x == 6 pero y == 5 */
x = 5; y = ++x; /* x == 6 e y == 6 */
Operación y asignación de forma compacta.
i += 5; es lo mismo que i = i + 5;
x *= (y + 2); es lo mismo que x = x * (y +2);
Expresiones relacionales
Se usan para realizar comparaciones.
Operadores relacionales:
Menor
Mayor
Menor o igual
Mayor o igual
Igual
Distinto
<
>
<=
>=
==
!=
Expresiones relacionales
Resultado lógico:
falso equivale a cero
cierto equivale a distinto de cero
No confundir asignación (=) con comparación (==).
x=3
4>8
3 <= 24
23 == 22
4 != 5
es también una expresión
equivale a falso
equivale a cierto
equivale a falso
equivale a cierto
Expresiones lógicas
Operadores Lógicos:
&& Conjunción ó Y lógico
|| Disyunción ó O lógico
! Negación ó NO lógico
4 && 0
! (4 > 1)
(x < x − 8) || 4
5 <= 0 || ! (x > x − 1)
2 && 4 > 9
(8 == 4 * 2) && 5 > 2
equivale a falso
equivale a falso
equivale a cierto
equivale a falso
equivale a falso
equivale a cierto
Expresiones lógicas
Tabla de verdad
A
cierto
cierto
falso
falso
B
cierto
falso
cierto
falso
!A
falso
falso
cierto
cierto
A && B
cierto
falso
falso
falso
A || B
cierto
cierto
cierto
falso
! (A && B) es lo mismo que ! A || ! B
! (A || B)
es lo mismo que ! A && ! B
El header ctype.h
isalnum(c)
isalpha(c) || isdigit(c)
isalpha(c)
iscntrl(c)
isdigit(c)
isgraph(c)
islower(c)
isprint(c)
ispunct(c)
isspace(c)
isupper(c)
isxdigit(c)
int tolower(c)
int toupper(c)
isupper(c) || islower(c)
carácter de control
dígito decimal
carácter imprimible excepto el espacio
letra minúscula
carácter imprimible incluido el espacio
carácter imprimible excepto letras, dígitos y el espacio
espacio, formfeed, newline, carriage return, tab, vert tab
letra mayúscula
dígito hexadecimal
convierte a minúscula
convierte a mayúscula
Tabla de precedencia de operadores
Operador
( )
!
[ ]
~
*
/
+
-
++
--
izquierda a derecha
.
+
-
(tipo)
*
&
derecha a izquierda
sizeof
izquierda a derecha
%
izquierda a derecha
<<
<
->
Asociatividad
izquierda a derecha
>>
<=
==
>
izquierda a derecha
>=
izquierda a derecha
!=
& (bitwise)
izquierda a derecha
^
izquierda a derecha
|
izquierda a derecha
&&
izquierda a derecha
||
izquierda a derecha
? :
derecha a izquierda
=
,
+=
-=
*=
/=
%=
&=
^=
|=
<<=
>>=
derecha a izquierda
izquierda a derecha
Nuevos tipos de datos
• Definición de nuevos tipos de datos mediante typedef.
• Muy útil para tipos complejos: tablas, estructuras,…
typedef <tipo_de_datos> nombre_nuevo_tipo;
typedef unsigned long int ENTERO;
typedef enum {FALSE,TRUE} BOOLEAN;
typedef struct {
float parte_real;
float parte_imaginaria;
} COMPLEJO;
Conversión de tipos
El casting cambia el tipo de la expresión que precede. Los
tipos deben ser compatibles.
int x; double y; … … x = (int) 3.7; y = (double) 5;
¾ La conversión de un tipo con menos bits a otro con más
bits es automática, ya que el tipo mayor puede
almacenar cualquier valor que represente el tipo menor
(de short a long, de long a float).
¾ La conversión de un tipo con más bits a un tipo con
menos bits se realiza de forma explícita con el casting.