Programacion - C - Libro Luis Dieguez Gonzalez PDF

INDICE PROLOGO 1.- FUNDAMENTOS DE PROGRAMACIÓN...............................................................................5 1.1.- Definiciones......................................................................................................................5 1.2.- Tipos de lenguajes...........................................................................................................5 1.3.- Requisitos para la compilación de programas..................................................................6 1.4.- Compilación de programas según la plataforma..............................................................6 1.4.1.- Linux.....................................................................................................................6 5.2.2.- Windows...............................................................................................................7 2.- HISTORIA DE C.....................................................................................................................9 2.1.- Un poco de historia..........................................................................................................9 2.2.- Características del lenguaje de programación.................................................................9 3 – INTRODUCCIÓN AL LENGUAJE C....................................................................................11 3.1.- El conjunto de caracteres...............................................................................................11 3.2.- Identificadores, palabras reservadas y caracteres especiales.......................................11 3.3.- Tipos de datos................................................................................................................12 3.4.- Constantes.....................................................................................................................15 3.5.- Variables........................................................................................................................17 3.6.- Declaraciones................................................................................................................18 3.7.- Expresiones...................................................................................................................18 3.8.- Sentencias o instrucciones............................................................................................18 3.9.- Operadores....................................................................................................................19 3.10.- Estructura de un programa en C..................................................................................21 Ejercicios resueltos.............................................................................................................22 4 – FUNCIONES BÁSICAS DE E/S..........................................................................................25 4.1.- getchar() y putchar().......................................................................................................25 4.2.- gets() y puts().................................................................................................................26 4.3.- printf() y scanf()..............................................................................................................27 Ejercicios resueltos.............................................................................................................29 5 – SENTENCIAS DE CONTROL E FLUJO.............................................................................30 5.1.- Sentencias de salto........................................................................................................30 5.1.1 Break....................................................................................................................30 5.1.2 Continue...............................................................................................................31 5.2.- Sentencias condicionales...............................................................................................28 5.2.1 if then else............................................................................................................31 5.2.2 switch....................................................................................................................32

5.3.- Sentencias de bucle.......................................................................................................32 5.3.1 for.........................................................................................................................32 5.3.2 while.....................................................................................................................34 5.3.3 do while.................................................................................................................34 Ejercicios resueltos..................................................................................................................36 6.- FUNCIONES.........................................................................................................................37 6.1.- ¿Qué es una función?....................................................................................................38 6.2.- Partes de una función....................................................................................................38 6.2.1 Declaración...........................................................................................................39 6.2.2 Definición..............................................................................................................40 Ejercicios resueltos..................................................................................................................43 7.- ARRAYS...............................................................................................................................46 7.1.- Definición de un array....................................................................................................46 7.2.- Arrays unidimensionales................................................................................................46 7.3.- Arrays bidimensionales..................................................................................................47 7.4.- Cadenas de caracteres..................................................................................................49 Ejercicios resueltos..................................................................................................................51 8.- PUNTEROS..........................................................................................................................56 8.1.- Conceptos básicos.........................................................................................................56 8.2.- Declaración de punteros................................................................................................57 8.3.- Paso de punteros a una función.....................................................................................57 8.4.- Punteros y arrays unidimensionales..............................................................................58 8.5.- Operaciones con punteros ............................................................................................59 8.6.- Punteros y arrays bidimensionales................................................................................60 8.7.- Arrays de punteros.........................................................................................................60 Ejercicios resueltos..................................................................................................................62 9.- ESTRUCTURAS Y UNIONES..............................................................................................63 9.1.- Definición de una estructura...........................................................................................63 9.2.- Referencia a los elementos de una estructura...............................................................64 9.3.- Arrays de estructuras.....................................................................................................64 9.4.- Uniones..........................................................................................................................65 9.5.- Definición de nuevos tipos de datos...............................................................................66 9.6.- Tipos enumerados de datos...........................................................................................66 Ejercicios resueltos..................................................................................................................68 10.- FICHEROS DE DATOS......................................................................................................69 10.1.- Introducción..................................................................................................................69 10.2.- Apertura y cierre de un fichero.....................................................................................69 10.3.- Creación de un fichero.................................................................................................70

10.4.- Funciones para la manipulación de ficheros................................................................71 10.4.1 fopen...................................................................................................................71 10.4.2 fclose..................................................................................................................71 10.4.3 fgetc....................................................................................................................72 10.4.4 fputc....................................................................................................................72 10.4.5 feof......................................................................................................................72 10.4.6 fgets....................................................................................................................73 10.4.7 fputs....................................................................................................................73 10.4.8 fread...................................................................................................................73 10.4.9 fwrite...................................................................................................................73 10.4.10 fprintf.................................................................................................................74 10.4.11 fscanf................................................................................................................41 10.4.12 fflush.................................................................................................................74 Ejercicios resueltos..................................................................................................................76 11.- LIBRERIAS.........................................................................................................................80 9.1.- Definición de una estructura...........................................................................................80 9.2.- Algunas librerías y funciones importantes en ANSI C....................................................81 9.3.- Arrays de estructuras.....................................................................................................38 9.4.- Uniones..........................................................................................................................38

BIBLIOGRAFIA FRANCISCO JAVIER CEBALLOS 1989. Lenguaje de programación C. Profesor en la universidad politécnica de Alcalá de Henares. Editorial rama. HANSEN, A. 1994. Aprenda C ya Anaya.

Fundamentos de programación

1

1.1 DEFINICIONES: • Se denomina algoritmo a una secuencia de instrucciones que permiten obtener un resultado en particular. No necesariamente son programas de computadora, una receta de cocina, o las instrucciones para cambiar un neumático son ejemplos de algoritmos de la vida real. • Las computadoras, son maquinas sin inteligencia propia, cuya única finalidad es interpretar el código que se les provee. • El lenguaje de máquina es el único lenguaje que la computadora "entiende" y es capaz de ejecutar. • Los lenguajes de programación son el medio de comunicación entre el programador y una computadora. El programador escribe en algún lenguaje de programación y utiliza las herramientas provistas por ese lenguaje para transformarlo en lenguaje de máquina. • Programa es una secuencia de órdenes a ser ejecutadas por una computadora. Un programa debe estar escrito en algún lenguaje de programación, y puede incluir uno o más algoritmos. 1.2 TIPOS DE LENGUAJES Según su nivel • • •

Lenguaje maquina Lenguaje de bajo nivel (ensamblador) Lenguajes de alto nivel

Lenguajes máquina. Se llama lenguaje máquina a las instrucciones que se dan directamente a la computadora, utilizando una serie de dígitos binarios o bits, representados por los números 0 y 1 que especifican una operación. Aunque este lenguaje es el que entiende la computadora, es muy difícil de manejar en la comunicación humana. Las instrucciones en lenguaje maquina dependen del hardware de la computadora y, por lo tanto, diferirán de una computadora a otra. Lenguajes de bajo nivel (ensamblador).Estos lenguajes son más fáciles de utilizar que los lenguajes máquina, pero, al igual que ellos, dependen de la máquina en particular. El lenguaje de bajo nivel por excelencia es el ensamblador (assembler lenguaje). Las instrucciones en lenguaje ensamblador son conocidas como mnemotécnicos. Por ejemplo, mnemotécnicos típicos de operaciones aritméticas son: en ingles, ADD, SUB, DIV, etc. en español, SUM, RES, DIV, etc. Lenguajes de alto nivel Los lenguajes de alto nivel son los más utilizados por los programadores. Están diseñados para que las personas escriban y entiendan los programas de un modo mucho más fácil que los lenguajes máquina y ensambladores. Otra razón es que un programa escrito en un lenguaje de alto nivel es independiente de la máquina; esto es, las instrucciones del programa de la computadora no dependen del diseño del hardware o de una computadora en particular. Por ello, los

programas escritos en estos lenguajes son portables, lo que significa que podemos ejecutarlos con poca o ninguna modificación en diferentes tipos de computadoras; al contrario que los programas en lenguaje máquina o ensamblador que sólo se pueden ejecutar en un determinado tipo de computadora. Según la forma en que se ejecutan sus órdenes • •

Lenguajes compilados Lenguajes interpretados

Lenguajes interpretados, cuyas órdenes pasan a través de un intérprete que se encarga de ejecutarla a partir del código fuente en el mismo momento en que están siendo leídas. Algunos de los lenguajes interpretados son java y perl entre otros. Lenguajes compilados, como es el caso de C que se diferencian en que las órdenes son transformadas a lenguaje de máquina para posteriormente almacenarlas en un fichero ejecutable. Ese archivo puede ejecutarse luego, sin recurrir al compilador. Los lenguajes compilados tienen la ventaja de la velocidad y la eficiencia, pero los interpretados tienen la ventaja de que, generalmente, son muy portables y de más alto nivel. 1.3 REQUISITOS PARA LA COMPILACIÓN DE PROGRAMAS Para poder compilar un programa, será necesario tener instalado el compilador y un editor o entorno de desarrollo que permitan escribir el código fuente a compilar. El código a compilar debe guardarse con un nombre que represente al programa en cuestión y la extensión .c. Para su edición, podemos hacer uso del editor que suele venir integrado en el propio compilador, o cualquier otro como puede ser el blog de notas. 1.4 COMPILACIÓN DE PROGRAMAS SEGÚN LA PLATAFORMA

1.4.1 LINUX Si bien existen otros compiladores, lo más usual y más sencillo para compilar un programa en GNU/Linux es el compilador gcc, ya que es el que se incluye en todas las distribuciones. Esta compilación es posible realizarla desde la línea de comandos o desde el entorno gráfico. Para poder realizarla desde línea de comandos, será necesario abrir una terminal. En ella deberemos teclear :

gcc nombre_programa.c En el caso que no existiesen errores en el código, este comando nos creará un archivo ejecutable, que por defecto se llama "a.out", el cual podemos ejecutar desde la línea de comandos de la siguiente forma :

./a.out Es recomendable especificar el nombre que queremos dar al archivo ejecutable, pasando como parámetro al compilador la opción -o, de la siguiente forma :

gcc hola.c -o hola

De esta forma, el nombre del fichero creado será hola. Este fichero no tiene extensión ya que es la forma usual de llamar a los archivos ejecutables en los entornos UNIX y GNU/Linux, sin embargo funcionaría de la misma forma si se llamara hola.exe. Para poder ejecutarlo, haremos :

./hola El compilador, contiene otros parámetros que podemos especificarle en la línea de comandos, dependiendo del tipo de programa, y en función de la complejidad del mismo. Por ejemplo, podemos agregar las siguientes opciones:

gcc hola.c -o hola -Wall -pedantic La opción -Wall nos mostrará todos los avisos que produzca el compilador, no solamente los errores. Los avisos nos indican dónde y/o porqué podría surgir algún error en nuestro programa. 1.4.2 WINDOWS Para compilar un programa C en entornos Windows, debemos seguir una serie de pasos que varían según el compilador de C que queramos utilizar. Compilación del código fuente ●

Si se utiliza un entorno de desarrollo, será posible compilar directamente desde el entorno, mediante un botón o una combinación de teclas.

●

Si se ejecuta el compilador desde la línea de comandos, la línea será distinta según el compilador utilizado.

●

Una vez compilado el código fuente se genera un archivo llamado archivo objeto o programa objeto que es luego enlazado mediante el enlazador, para generar el archivo ejecutable.

●

Los compiladores actuales suelen hacer dos funciones de una vez, compilando y enlazando todo en una sola función, aunque es posible pedirles que no lo hagan mediante parámetros adicionales.

Según el compilador y la configuración utilizada, se obtendrán dos o tres archivos: El archivo fuente

hola.c El archivo objeto

hola.obj El archivo ejecutable

hola.exe Este último es el que nos interesa, puesto a que es el código ejecutable, el programa en sí. Al ejecutarlo se producirá la salida deseada en una ventana de consola. En el siguiente esquema de bloques, se detallan los pasos desde que se edita un programa hasta que se obtiene el ejecutable. E D I T O R

Programa fuente hola.c

Program a objeto COMPILADOR DE “C”

uno.lib

mi.lib

hola.obj

E N L A Z A D O R

hola.exe

Figura 1 Diagrama de bloques desde edición hasta la compilación.

Historia de C

2

2.1. UN POCO DE HISTORIA El lenguaje C fue creado en los años setenta por Dennis Ritchie, de los Laboratorios Bell. Su propósito era ser un lenguaje para el sistema operativo UNIX. Surgió a partir de los lenguajes de programación BCPL y B. En el año 1978 Kernighan e Ritchie publican su descripción en el libro "The C Programming Language", versión que hoy se llama 'K&R C'. A lo largo de los años ochenta, el mercado ya disponía de numerosos compiladores de C, y muchas aplicaciones fueron reescritas para aprovechar sus ventajas. En este periodo de tiempo, muchos fabricantes meten mejoras, las cuales evalúa un comité de estandarización ANSI y así se establecen unas especificaciones de lo que hoy se conoce como 'ANSI C'. 2.2. CARACTERÍSTICAS DEL LENGUAJE C pertenece a lo que se conoce como lenguajes de nivel intermedio entre Pascal y lenguaje ensamblador. Pretende ser una lenguaje de alto nivel con la versatilidad de bajo nivel. Se diseñó junto con el sistema operativo UNIX y está muy orientado a trabajar en su entorno. En su desarrollo se siguieron una serie de líneas generales tales como: • Es un lenguaje estructurado. Con lo que facilita la legibilidad y entendimiento de los programas. • La entrada/salida se hace a través de funciones de librería. La entrada/salida no se considera parte del lenguaje en sí, sino que se realiza a través de funciones de librería. La misma política se sigue con cualquier otro tipo complejo de instrucciones. • Reducido número de palabras reservadas. Para escribir un programa se debe poder escribir poco texto. Para lograr esto se reduce el número de palabras claves. • Eficiencia. Con ello se llegó a un compilador con un poderoso juego de instrucciones, que permite aumentar la productividad/día de los programadores. • Fácil de aprender. C es un lenguaje rápido de aprender, que deriva en compiladores sencillos de diseñar, robustos, y que generan objetos pequeños y eficientes.

• Gran portabilidad. Una de las características más apreciadas de C es su gran portabilidad, gracias a que deja en manos de librerías las funciones dependientes de la máquina, ¡y todo ello sin restringir el acceso a dicha máquina! Estas y otras características lo hacen adecuado para la programación en áreas tales como: • programación de sistemas • estructuras de datos y sistemas de bases de datos • aplicaciones científicas • software gráfico • análisis numérico Sin embargo, posee algunas desventajas que suscitaron algunas críticas, dentro de las se pueden destacar: • Comprobación de datos: Lo poco estricto que es el lenguaje con esta tarea, dejando esta muchas veces en manos del programador. • El no verificar automáticamente los límites de los vectores. • Sobrecarga de operadores. • El no poder anidar funciones : con lo que se dificulta la estructuración y la abstracción de datos. • La incertidumbre existente en el orden de evaluación de las listas de expresiones y parámetros.

Introducción al lenguaje C

3

3.1 EL CONJUNTO DE CARACTERES C. A la hora de elaborar programas en C se pueden utilizar para crear los elementos básicos (constantes, variables, operadores y expresiones) las letras mayúsculas de la A a la Z, las minúsculas de la a a la z , los dígitos del 0 al 9 y ciertos caracteres especiales. 3.2 IDENTIFICADORES,PALABRAS RESERVADAS Y CARACTERES ESPECIALES. Los identificadores son nombres que se les da a varios elementos de un programa, como variables, constantes o funciones. Un identificador puede estar compuesto de cualquier combinación de letras (minúsculas y mayúsculas), dígitos y el símbolo subrayado '_'. La única restricción es que el primer carácter debe ser una letra o un subrayado. Hay ciertas palabras reservadas, denominadas palabras clave, que tienen en C un significado estándar y por tanto no pueden ser utilizadas como identificadores definidos por el programador. Las palabras clave están en minúsculas.

Identificadores válidos Identificadores no válidos a 7aux (primer carácter v5 no es letra) funci_suma “x” (carácter ilegal “) _b funci-resta (carácter ilegal -) ARRAY TABLA UNO (espacio ilegal)

Figura 2 Ejemplos de identificadores legales e ilegales ● ●

No se limita la longitud de los identificadores. Pero algunas implementaciones sólo reconocen los 8 primeros y otras (ANSI) los 31 primeros caracteres. Se diferencia entre mayúsculas y minúsculas.

Existe un conjunto de caracteres que tienen un significado especial en el lenguaje C. Se muestran en la siguiente figura.

Caracteres especiales !

*

+

\

“

<

#

(

=

|

{

>

%

)

~

;

}

/

^

-

[

:

,

?

&

_

]

'

.

(blanco)

Tabla 1 Caracteres especiales. C tiene un total de 32 palabras reservadas, que no pueden ser definidas por el usuario. Son las que se exponen a continuación. Palabras reservadas auto

extern

sizeof

break

float

static

case

for

struct

char

goto

switch

const

if

typedef

continue

int

union

default

long

unsigned

do

register

void

double

return

volatile

else

short

while

enum

signed

Tabla 2 Palabras reservadas de C 3.3 TIPOS DE DATOS En el lenguaje C estándar, existen cinco tipos de datos básicos que son: los caracteres, los números enteros, los números reales,los números reales en doble precisión y void. Estos tipos de datos son parte del lenguaje, y por ello se los considera primitivos. Adicionalmente, podremos ver como a partir de este tipo de datos primitivos podemos crear tipos compuestos de datos como son las estructuras y las uniones. En este tema veremos los enteros, los reales y los caracteres. Más adelante se verán otros tipos de datos más complejos, como son los arrays o vectores, las cadenas de caracteres, y los punteros en general. Los más destacados son:

int : Números enteros char : Caracteres float : Número de coma flotante (con punto decimal y/o exponente) double : Número de coma flotante de doble precisión (más cifras significativas y mayor valor posible del exponente) Existen una serie de calificadores: short, long, signed y unsigned que sirven para ampliar o reducir el rango de los diferentes tipos de datos.

char

Representa un carácter en código ASCII, también se puede interpretar como un entero. Sólo ocupa 1 byte

int

Entero. Ocupa como máximo de 2 bytes

short int

Indica un entero de tamaño corto.

long int

Entero largo. Ocupa como máximo 4 bytes

unsigned short int Como short int pero sin signo. unsigned int

Como int pero sin signo.

unsigned long int

Como long int pero sin signo.

float

Flotante corto. Para representar números reales Ocupa 4 bytes

double

Flotante largo. Ocupa 8 bytes

void

No indica ningún tipo. Es el tipo de las funciones que no devuelven nada.

La sintaxis para declarar variables o constantes con los diferentes tipos de datos es: tipo_dato nombre_variable

A continuación, se muestra una tabla resumen de los tipos de datos: Tipos de datos TIPO

RANGO

BYTES

char

-127....127(ASCII)

1

int

32768.....32767

2

long

-2.127.483.648...-2.127.483.647

4

float

3,4 * 10 ^-38...3,4 * 10 ^-38

4

double

1,7 * 10 ^-308...1,7 * 10 ^-308

8

void

Valor nulo

nulo

Tabla 3 Tipos de datos 3.3.1 Caracteres Los caracteres se representan utilizando el tipo char, que tiene sólo 1 byte de tamaño. Este tipo se utiliza para representar los 255 caracteres de la tabla de caracteres del sistema. El tipo char es también un tipo entero, ya que puede tomar valores de 0 a 255. Ejemplos de declaraciones de variables de tipo char: char car; char car = 'a'; char car = 25; 3.3.2 Enteros Los enteros son el tipo de dato más primitivo en C. Se usan para representar números enteros. C hace la distinción de si el entero es con signo o sin signo (signed o unsigned). La forma de declarar un entero es con uno de los tipos de datos que sean enteros según el tamaño que se quiera. En caso de que no se declare si es con signo o sin signo, se toma con signo. Algunos ejemplos de declaraciones de enteros: int a; int b; unsigned int c; 3.3.3 Números reales Los tipos de datos en coma flotantes son los tipos de datos que representan a los números reales, ya que utilizan un sistema de representación basado en la técnica de coma flotante, que permite operar con números reales de diversas magnitudes, mediante un número decimal llamado mantisa y un exponente que indica el orden de magnitud. El tipo de dato flotante en lenguaje C sólo tiene dos tamaños: el float y el double, que son 4 bytes y 8 bytes respectivamente. Se los puede utilizar tanto para representar números decimales, como para representar números enteros con un orden de magnitud muy grande. La forma de declarar una variable flotante es escribiendo en una línea uno de los tipos de datos flotantes y a continuación el nombre de la variable y tal vez algún valor que se les quiera dar. Algunos ejemplos de números en coma flotante: double a,b; double c = 25; double d = 3.1416; float e = 2e-3; double f = -33; 3.4 CONSTANTES Las constantes son datos referenciados a través de un identificador cuyo valor no varía a lo largo de toda la ejecución de un programa. 3.4.1 Constantes enteras Una constante entera es un número con un valor entero que se puede escribir en tres sistemas numéricos: decimal, octal o hexadecimal. Se pueden escribir en decimal (número que no empieza por 0), octal (el primer dígito es 0) y hexadecimal (comienza con 0x ó 0X). Además,pueden ser con signo o sin signo. Si es sin signo se

les añade el sufijo U. El tamaño de las constantes puede ser normal o largo, en este caso se añade el sufijo L. 3.4.2 Constantes en coma flotante Una constante de coma flotante es un número en base 10 que contiene un punto decimal y/o un exponente. 3.4.3 Constantes de caracteres Una constante de carácter es un sólo carácter o una secuencia de escape encerrado con comillas simples. Char car = 'a' Ciertos caracteres no imprimibles se pueden expresar en términos de secuencias de escape. Una secuencia de escape siempre comienza por una barra \ y siempre representa un solo carácter.

Secuencias de escape SECUENCIA

SIGNIFICADO

'\a'

Sonido (campana)

'\b'

backscape

'\t'

Tabulación horizontal

'\v'

Tabulación vertical

'\n'

Nueva línea

'\f'

Form feed

'\r'

Retorno de carro

'\”'

Comillas

'\''

Comilla simple

'\?'

Signo de interrogación

'\\'

Backslash (\)

'\0'

Nulo Tabla 4 Secuencias de escape

Mediante secuencias de escape se puede expresar cualquier carácter ASCII indicando su código en octal (\ooo) o en hexa (\xhh). Donde los símbolos 'o' representan dígitos octales y las 'h' dígitos hexadecimales. 3.4.4 Constantes de cadenas de caracteres Constan de cualquier número de caracteres o secuencias de escape consecutivos encerrados entre comillas dobles. También se admite ausencia de caracteres (""). El carácter nulo no puede aparecer en medio de una constante de cadena de caracteres puesto que se usa para indicar fin de cadena. El carácter de fin de cadena '\0' se coloca de forma automática en las cadenas literales; así en la cadena "abc" hay 4 caracteres: a, b, c y '\0'. char nombre[25] = “José Luis”; 3.4.5 Constantes enumeradas Son las definidas de tipo enum

3.5 VARIABLES Una variable es un identificador que se utiliza para representar cierto tipo de información dentro del programa. En algún punto del programa se le asigna a la variable un valor que después se puede recuperar en cualquier momento sin más que hacer referencia la nombre de la variable. int a; a=25; 3.6 DECLARACIONES Una declaración implica asociar un tipo concreto de datos a una variable o grupo de variables. En esencia, consiste en un tipo de datos, seguido de uno o más nombres de variables, finalizando con un punto y coma. Todas las variables deben ser declaradas antes de ser utilizadas. Int a,b,c; float uno,dos ; char car, cadena[25]; short int a; char cadena[3] = "uno"; char a = '\n'; char cadena[] = "uno";

Tres variables enteras. Dos variables de tipo real. Un carácter y una cadena de 25. Entero corto. Declaración e inicialización Inicialización con Return. Sin especificar tamaño.

Figura 10 Ejemplos de declaración de variables. 3.7 EXPRESIONES Una expresión representa una unidad de datos simple, tal como un número o un carácter. Puede consistir en una constante, una variable o una combinación de ellas mediante operadores. numero = 5; 3.8 SENTENCIAS O INSTRUCCIONES Una sentencia o instrucción hace que el ordenador lleve a cabo alguna acción. En C hay tres tipos de sentencias: de expresión, de control y compuestas. Una sentencia de expresión consiste en una expresión seguida de un punto y coma. Su ejecución hace que se evalúe la expresión: a = 25; c = a+b; Una sentencia compuesta está formada por varias sentencias individuales encerradas entre llaves. Las sentencias individuales pueden ser de cualquiera de los tres tipos mencionados. Las sentencias de control se utilizan para realizar bucles o ramificaciones. 3.9 OPERADORES C es un lenguaje muy rico en operadores. Se definen seis tipos de operadores: aritméticos, relacionales, de asignación, lógicos, de dirección y de movimiento. Existe otro tipo de operador denominado cast o molde.

3.9.1 Operadores Aritméticos Operadores aritméticos OPERADOR

EJEMPLO

SIGNIFICADO

+

a+b

Suma

-

a-b

Resta

*

a*b

Multiplicación

/

a/b

Cociente de una división

%

a%b

Resto de una división

++

a++

Incremento unitario

--

a--

Decremento unitario

Tabla 5 Operadores aritméticos int a,b,c; a = 1; b = 5; c = a+b; El operador % es el de resto y requiere que los dos operandos sean enteros y el segundo no nulo. El operador de división requiere que el segundo operando no sea nulo. La división de dos cantidades enteras da como resultado el cociente entero truncado. 3.9.2 Operadores lógicos

Operadores lógicos OPERADOR

EJEMPLO

SIGNIFICADO

!

!(a

Mayor que

=

Mayor o igual que

==

Igual que

!=

Distinto que

Tabla 8 Operadores relacionales 3.9.4 Operador de asignación Operador de asignación OPERADOR

SIGNIFICADO

=

Asigna dato a variable Tabla 9 Operadores de asignación

Se utiliza para formar expresiones de asignación en las que se asigna el valor de una expresión a un identificador. Una expresión de asignación recibe el nombre de sentencia de asignación y es de la forma : identificador = expresión int numero; numero = 5; 3.9.6 Operadores de dirección Operador de dirección OPERADOR

SIGNIFICADO

*

Operador de contenido

&

Operador de dirección Tabla 10 Operadores de dirección

3.9.7 Precedencia de los operadores De mayor a menor precedencia

OPERADOR ()[] ! ~ ++ -- * & sizeof (tipo dato) */% +> < >= == != & ^ | && || ?: = += -= *= /= %= Tabla 11 precedencia de operadores

3.10 ESTRUCTURA DE UN PROGRAMA EN C Un programa en C tiene básicamente la siguiente estructura. #include stdio.h int a,b;

/* directivas del preprocesador.*/ /* definición de variables globales.*/

int suma(int,int); main()

/* declaración prototipo funciones.*/ /* función principal.*/

{ int resul; …

/* inicio del programa principal.*/ /* declaración variables locales.*/

…

/* código del programa.*/

… resul=suma(a,b);

/* llamadas a funciones.*/

… …

/* código del programa.*/

… }

/* fin del programa principal.*/

int suma(int,int)

/* definición funciones*/

{ … …

/* código de la función.*/

… } Un ejemplo de un programa simple es el popular Hola Mundo: #include stdio.h main() { printf(“ Hola Mundo\n”); }

EJERCICIOS RESUELTOS 1.- Calcular el doble de un número que se pide por teclado #include “stdio.h” #include “conio.h” main() { int nun; printf("Introduce el número\n"); scanf(“%d”,&nun); printf("\nEl doble de %d es %d\n”,nun,nun*2; getch(); } 2.- Programa que pide dos dos números por teclado e intercambia sus valores #include “stdio.h” #include “conio.h” main() { int nun1,nun2,aux; printf("Introduce los números: a,b\n"); scanf(“%d,%d”,&nun1,&nun2); aux=nun1; nun1=nun2; nun2=aux; printf("\n Los nuevos valores son : nun1 = %d nun2 = %d\n”,nun1,nun2); getch(); } 3- Programa que lea un número entero por teclado y que calcule su factorial #include “stdio.h” main() { int x; double fact; fact=1; printf("Introduce el número: \n"); scanf(“%d”,&x); while(x>1) { fact=fact*x; x--; } printf("\n Factorial = %lf\n”,fact); } 4. Escriba un programa que imprima una tabla con las cuatro primeras potencias de los números 1 a 10. /* Imprime la tabla de las primera 4 potencias del 1 al 10 */ #include

main() { int n; puts(" numero\t exp2\t exp3\t exp4"); puts("------\t-----\t-----\t-----"); for (n=0; n1; --i) factorial *= i; printf("\n%d! = %d\n",numero,factorial); }

6. Escriba un programa que muestre la tabla ASCII #include main() { int a, b, i; for (a=0; ab) if(a>c) max=a; else max=c; else if(b>c) max=b; else max=c; return(max); } Ahora, supongamos que queremos utilizar nuestra función y llamarla desde nuestro programa principal. Para ello, definimos la estructura del programa principal, declarando dicha función junto con sus parámetros formales, y haciendo una llamada en el momento que la necesitemos. #include “stdio.h” #include “conio.h” int calcula_mayor(int a,int b,int c); main() { int a,b,c,resul; printf("Programa que calcula el mayor …\n"); printf("Introduzca los números:a,b,c\n"); scanf(“%d %d %d”,&a,&b,&c”); resul=calcula_mayor(a,b,c); printf("\nEl mayor de %d %d %d es:%d\n”,a,b,c,resul); getch(); } Por lo tanto, el programa deberá retornar el mayor de los tres números introducidos por teclado. En el caso de que la función mayor no recibiese ningún parámetro, pero si retorne el mayor de los tres números, el programa completo quedaría de la siguiente forma: #include “stdio.h” #include “conio.h” int calcula_mayor(void); main()

{ int resul; printf("Programa que calcula el mayor …\n"); resul=calcula_mayor(); printf("\nEl mayor de %d %d %d es:%d\n”,a,b,c,resul); getch(); } int calcula_mayor(void) { int a,b,c,max; printf("Introduzca los números:a,b,c\n"); scanf(“%d %d %d”,&a,&b,&c”); if(a>b) if(a>c) max=a; else max=c; else if(b>c) max=b; else max=c; return(max); } Cabe destacar que en este ejemplo, es la propia función la que se encarga de la recogida de datos. Esto podríamos realizarlo desde la función principal teniendo la habilidad de declarar las variables a,b y c como globales, es decir, fuerza de la función main() para que tuviese acceso. Supongamos ahora que la función no devuelve ni recibe ningún parámetro. Una solución par la toma de datos sería como se comentó anteriormente, es decir, definir a,b y c como globales. Para la presentación de resultado también tendremos varias opciones. Optaremos por que sea la función principal la que nos presente el resultado. En este caso, main() debe tener acceso a la variable que contiene el mayor de los tres números, por lo que deberá se la propia función calcula_mayor la que se encargue de esa tarea. Veamos el ejemplo: #include “stdio.h” #include “conio.h” void calcula_mayor(void); int a,b,c,resul; main() { printf("Programa que calcula el mayor …\n"); printf("Introduzca los números:a,b,c\n"); scanf(“%d %d %d”,&a,&b,&c”); calcula_mayor(); printf("\nEl mayor de %d %d %d es:%d\n”,a,b,c,resul); getch(); } int calcula_mayor(void) { int max; if(a>b) if(a>c) max=a; else max=c;

}

else if(b>c) max=b; else max=c; resul=max;

EJERCICIOS RESUELTOS 1.- Escribir un programa que calcule el menor de dos números mediante una función. El programa principal leerá los dos números y se los pasará a la función como argumentos, posteriormente la función calculará el menor devolviéndoselo al programa principal, siendo éste el encargado de presentarlo por pantalla. /* menor de dos numeros con una funcion*/ #include #include int menor(int a,int b); main() { int n1,n2; printf("Dame dos numeros\n"); scanf("%d,%d",&n1,&n2); if(n1==n2) printf("son iguales \n"); else printf("el menor es:%d\n", menor(n1,n2)); getch(); } int menor (int a,int b) { if(a