facultad de ingenieríadea.unsj.edu.ar/.../recursos/apuntes/capitulo-01.pdf · 2019-07-01 · todo...

Facultad de Ingeniería

Departamento de Electrónica y Automática

Unidad I

Introducción al Lenguaje de Programación C

Cátedra:

Computación II (ELO)

Informática II (BIO)

COMPUTACIÓN II (ELO) - INFORMÁTICA II (BIO) Introducción al Lenguaje de Programación C

INDICE 1 El lenguaje de programación C............................................................................................................. 1

1.1 Introducción.................................................................................................................................... 1 1.2 Ejemplo de un programa en C........................................................................................................ 1 1.3 Identificadores ................................................................................................................................ 2 1.4 Tipos de Datos................................................................................................................................ 3 1.5 Constantes Literales ....................................................................................................................... 4

1.5.1 Constantes enteras................................................................................................................... 4 1.5.2 Constantes de coma flotante ................................................................................................... 4 1.5.3 Constante caracter ................................................................................................................... 5 1.5.4 Secuencias de escape .............................................................................................................. 5 1.5.5 Constantes de cadena de caracteres ........................................................................................ 5

1.6 Variables......................................................................................................................................... 5 1.7 Declaraciones ................................................................................................................................. 6 1.8 Constantes simbólicas .................................................................................................................... 6 1.9 Expresiones y Oraciones ................................................................................................................ 7 1.10 Operadores y expresiones ........................................................................................................... 7

1.10.1 Operadores Aritméticos....................................................................................................... 8 1.10.2 Operadores monarios (o unarios) ........................................................................................ 9 1.10.3 Operadores relacionales ...................................................................................................... 9 1.10.4 Operadores lógicos. ........................................................................................................... 10 1.10.5 Operadores de asignación.................................................................................................. 10 1.10.6 Operador condicional ........................................................................................................ 11 1.10.7 Precedencia y orden de evaluación ................................................................................... 11

1.11 Estructuras de control ............................................................................................................... 12 1.11.1 Estructura while................................................................................................................. 12 1.11.2 Estructura do - while ......................................................................................................... 13 1.11.3 Estructura for..................................................................................................................... 14 1.11.4 Repeticiones anidadas ....................................................................................................... 15 1.11.5 Estructura if-else................................................................................................................ 16 1.11.6 Estructura switch ............................................................................................................... 16 1.11.7 Oración break .................................................................................................................... 18 1.11.8 Oración continue ............................................................................................................... 19

1.12 Tabla de conversión de operadores de LPP a C. ...................................................................... 19 1.13 Tabla de conversión de estructuras de control de LPP a lenguaje C ........................................ 20 1.14 Entrada y salida de datos .......................................................................................................... 20

1.14.1 Algunas funciones de la biblioteca estándar ..................................................................... 20 1.14.2 Entrada de un caracter - Función getchar......................................................................... 21 1.14.3 Salida de un caracter - Función putchar............................................................................ 21 1.14.4 Función scanf.................................................................................................................... 22 1.14.5 Función printf .................................................................................................................... 23 1.14.6 Funciones gets y puts........................................................................................................ 24

1.15 Estructura general de un programa en C................................................................................... 24 1.16 Ejercitación con estructuras de control..................................................................................... 25 1.17 Ejercicios propuestos ................................................................................................................ 31

COMPUTACIÓN II (ELO) - INFORMÁTICA II (BIO)

1

Capítulo 1

1 El lenguaje de programación C

1.1 Introducción C es un lenguaje de programación de propósito general, es decir, no está especializado en ningún área en particular. Se caracteriza por tener estructuras de control de flujo modernas y poderosas estructuras de datos. Si bien es un lenguaje de relativamente alto nivel, el C tiene instrucciones de bajo nivel que solo se encuentran disponibles en lenguajes ensambladores.

Este lenguaje fue diseñado originariamente para el sistema operativo UNIX en la PDP 11 de Digital Equipment Corporation (DEC), y tanto el sistema operativo como el compilador C y casi todos los programas que componen UNIX están desarrollados en este lenguaje.

Las razones de la popularidad del lenguaje C son:

• Es un lenguaje estructurado, de alto nivel y flexible.

• Posee potentes instrucciones de bajo nivel.

• Permite la generación de programas objeto eficientes.

• Existe disponibilidad de compiladores C para todas las plataformas de hardware.

• Provee una gran portabilidad.

• Existe una muy amplia disponibilidad de bibliotecas para usos muy diversos.

1.2 Ejemplo de un programa en C Todo programa en C consta de uno o más módulos llamados funciones. Una función es una unidad lógica formada por una o más oraciones, y puede realizar una o más tareas si bien se recomienda que su diseño encapsule un único proceso. Una de estas funciones se llama main , que es por la cual inicia su ejecución todo programa en C, y ella es quien se encarga de invocar a otras funciones si fuera necesario.

Cada función debe contener un encabezamiento (header ) que consta del tipo de datos que eventualmente será devuelto por la función, del nombre de la función, de una lista opcional de argumentos encerrados entre paréntesis y de una instrucción compuesta que contiene el resto de la función.

Los argumentos son variables que transportan los datos que se le envían a la función desde otra sección del programa para que esta pueda llevar a cabo su trabajo. Cada oración compuesta está encerrada entre llaves {} .

El siguiente es un ejemplo de un programa simple en C: /* ejemplo de un programa sencillo*/

#include <stdio.h>

int main( ) { printf("Bienvenido a la Programación en lenguaje C \n");

return 0; }

y en él se puede observar que:

1. El programa está escrito en minúsculas y en particular, todas las palabras claves del lenguaje C están escritas en minúsculas.


2

2. La primera línea es un comentario que describe el propósito del programa. En el lenguaje C se toma como comentario todo caracter interno a los símbolos: /* */ , y pueden ocupar uno o más renglones. El compilador ignora los comentarios, es decir que no genera líneas de código para lo que esté entre los símbolos de comienzo y fin de comentario. Los comentarios son frases que pueden ser de gran ayuda para clarificar la operación de un programa o fragmento del mismo.

3. La segunda línea contiene una referencia a un archivo llamado stdio.h (standard input/output), que posee información relacionada con la entrada y salida de datos, que debe incluirse en el programa cuando este se compila.

4. La tercera línea es la cabecera de la función main , esta función indica donde comienza el programa. Los paréntesis vacíos indican que esta función, en este caso en particular, no recibe argumentos.

5. Las dos líneas restantes que están encerradas entre llaves, integran la oración compuesta dentro de la función main : la primera es un llamado a una función denominada printf() , y la segunda es la instrucción return que finaliza el programa retornando al sistema operativo. En este caso se invoca a la función printf(argumento) existente en la biblioteca stdio.h y se le envían como argumento aquellos caracteres que se desean escribir en la pantalla. Los mismos deben estar delimitados por comillas. La secuencia \n que aparece al final del mensaje es la notación que se emplea en C para el caracter "nueva linea" que hace avanzar al cursor a la posición extrema izquierda de la línea siguiente. La última oración (return 0 ) termina el programa y devuelve un valor al sistema operativo, que por lo general es cero si la ejecución fué correcta y valores distintos de cero para indicar diversos errores que pudieron ocurrir. Si bien no es obligatorio terminar el programa retornando un valor, es conveniente indicarle a quien lo haya invocado, sea el sistema operativo o algún otro programa, si la finalización ha sido exitosa, o no.

6. Cada oración simple está terminada por un "; ", el que indica al compilador donde finaliza la misma.

1.3 Identificadores Los identificadores son nombres que permiten hacer referencia a las diferentes entidades gestionadas por un programa. En particular hacen referencia a:

• Constantes simbólicas.

• Variables.

• Funciones.

Todo identificador está constituido por una secuencia de letras y dígitos en cualquier orden excepto el primero que debe ser obligatoriamente un caracter diferente de un número. Se pueden utilizar letras mayúsculas y minúsculas, pero ambas se consideran distintas (‘ A’ es diferente de ‘ a’ ). El caracter de subrayado '_' también se puede incluir y se puede considerar como una letra.

Como mínimo, los primeros 31 caracteres son significativos para caracterizar un identificador (lo que significa que, eventualente, pueden aceptarse mas caracteres pero solo los 31 primeros serán considerados para unicidad del nombre), al igual que el estándar ANSI. En los nombres de funciones la longitud admitida puede ser menor ya que el lenguaje no tiene control del comportamiento de herramientas de software externas al compilador y que suelen formar parte del entorno de trabajo. En C hay ciertas palabras reservadas que se denominan palabras


3

claves que tienen un significado especial y no pueden ser usadas como identificadores definidos por el usuario (obsérvese que son palabras en idioma inglés y en minúsculas).

Estas palabras reservadas son: 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

Algunos compiladores pueden reconocer, además de éstas, algunas otras palabras claves por lo que siempre hay que realizar una consulta al manual de referencia del mismo.

1.4 Tipos de Datos En C existen distintos tipos de datos y cada uno de los cuales puede encontrarse representado de forma diferente en la memoria de la máquina. El requerimiento de memoria para cada tipo de dato numérico determinará el rango permitido de valores para ese tipo de datos. Además, los requisitos de memoria para cada tipo de datos son dependientes de la arquitectura de cómputa subyacente y además pueden variar de un compilador a otro. En la siguiente tabla se presenta una lista de tipos de datos básicos, con los requerimientos de memoria típicos.

Tipo de Dato Descripción Memoria int Cantidad entera 2 bytes char Caracter 1 byte float Número de coma flotante 4 bytes double Número de coma flotante doble precisión 8 bytes

Algunos tipos de datos básicos se pueden modificar o ampliar agregando alguno de los siguientes calificadores:

• short (corto)

• long (largo)

• signed (con signo)

• unsigned (sin signo)

Por ejemplo, se puede definir enteros de la siguiente forma:

• enteros cortos � short int

• enteros largos � long int

• enteros con signo � signed int

• enteros sin signo � unsigned int


4

El calificador unsigned puede aplicarse a otros tipos de datos int ya calificados, por ejemplo:

• unsigned short int .

El tipo char se utiliza para representar caracteres individuales y puede considerarse que el tipo char es un tipo entero pequeño. Asimismo algunos compiladores permiten la calificación long float (equivalente a doble) o long double (equivalente a doble extra largo).

1.5 Constantes Literales El lenguaje C tiene los siguientes tipos básicos de constantes:

• constantes enteras

• constantes de coma flotante

• constantes de caracter

• constantes de cadena de caracteres.

1.5.1 Constantes enteras

Las constantes enteras se pueden escribir en tres sistemas numéricos diferentes: decimal (base 10), octal (base 8) y hexadecimal (base 16). Una constante entera decimal puede ser cualquier combinación de dígitos tomados del conjunto de 0 a 9.

Ejemplo:

0 1 5547

Una constante entera octal está formada por cualquier combinación de dígitos tomados del conjunto de 0 a 7 pero el primer dígito debe ser cero (0).

Ejemplo:

01 047 0553

Una constante entera hexadecimal está formada por cualquier combinación de dígitos tomados del conjunto de 0 a 9 y desde la letra A hasta la F (en minúsculas o en mayúsculas, no hay diferencia alguna). Una constante entera hexadecimal debe comenzar con 0x o 0X.

Ejemplo:

0x1 0X78 0Xab

1.5.2 Constantes de coma flotante

Una constante de coma flotante es un número que contiene un punto decimal, un exponente o ambos, por ejemplo:

5000. 0.2 0.06E-3

Una constante de coma flotante con exponente se le conoce también con el nombre de notación científica , excepto que se sustituye la base 10 por la letra E o e.

Típicamente la magnitud de una constante de coma flotante puede variar entre un valor mínimo aproximado de 3.4E-38 y un valor máximo de 3.4E+38 . El número de dígitos significativos es de al menos 6. De todos modos, siempre es necesario averiguar estos valores para la instalación particular del compilador C y plataforma de hardware que se esté utilizando.


5

1.5.3 Constante caracter

Una constante caracter es un sólo caracter encerrado entre apóstrofes. Por ejemplo,

'a' '$' 'Z'

Las constantes caracter tienen valores enteros determinados por el valor numérico que le corresponde en el conjunto de caracteres de la computadora (código). En general, el código mas utilizado es el ASCII (American Standard Code for Information Interchange).

1.5.4 Secuencias de escape

Ciertos caracteres especiales, imprimibles o nó, como por ejemplo, el tabulador, las comillas, el apóstrofe, el signo de interrogación o la barra invertida ( \ � backslash ), pueden expresarse como constantes caracter en términos de secuencias de escape . Una secuencia de escape comienza con una \ seguida por uno o más caracteres. Los siguientes son ejemplos de secuencias de escape:

Sonido \a Form Feed \f Backslash \\ Backspace \b Retorno de carro \r Nulo \0 Tab horizontal \t Comillas \" Apóstrofe \' Tab vertical \v Nueva línea \n Interrogación \?

En particular la secuencia de escape ‘\0’ representa un caracter nulo, y en el lenguaje C se emplea para indicar el final de una cadena de caracteres (string).

También se puede expresar una secuencia de escape en términos de uno, dos o tres dígitos octales que representan los patrones de bits correspondientes a un caracter. Algunos compiladores también aceptan dígitos hexadecimales. Por ejemplo, '\014' que indica el caracter Form Feed .

1.5.5 Constantes de cadena de caracteres

Una constante de cadena de caracteres (string) consta de cualquier número de caracteres consecutivos encerrados entre comillas. Si se deben incluir comillas, signos de interrogación o barras invertidas, deben hacerse mediante la correspondiente secuencia de escape. El compilador inserta automáticamente el caracter '\0' al final de la cadena.

No se debe confundir una constante caracter con una constante de cadena de caracteres, pues no son equivalentes. De hecho, la constante caracter 'A' y su correspondiente constante de cadena de caracteres "A" no son equivalentes. La primera solo posee un caracter, mientras que la segunda posee dos, la 'A' y el caracter nulo ('\0' ).

1.6 Variables Una variable es un identificador que tiene un nombre definido por el usuario, y que se utiliza para almacenar un valor. El valor contenido en las variables se puede cambiar en cualquier momento a lo largo de la ejecución del programa.


6

Para dar el nombre a las variables hay que seguir las siguientes reglas:

• Se pueden poner letras de la 'a' a la 'z' (la 'ñ' no puede utilizarse) en minúsculas y mayúsculas, números y el símbolo '_' .

• No pueden utilizarse los acentos.

• No se pueden utilizar signos de admiración ni de interrogación.

• El nombre de una variable puede contener números, pero su primer carácter debe ser una letra o un símbolo underscore ('_' ).

Los siguientes son nombres de variables válidos : promedio , x , numero , x2 , Valor_Residual , _contador

mientras que los a continuación son de nombres de variables no válidos : 1abc , ?valor , número

1.7 Declaraciones En el lenguaje C, para poder utilizar un identificador, tiene que ser declarado previamente. Esta declaración asocia un tipo de dato determinado a una variable. Así, una declaración simple consta de un tipo de dato seguido por un nombre. La declaración finaliza con un punto y coma. Por ejemplo:

double salario;

double peso;

int mes;

unsigned long distancia;

Cuando hay más de una variable del mismo tipo, se pueden declarar juntas separadas entre sí por una coma. Por ejemplo, las variables de tipo double del ejemplo anterior se pueden declarar en la misma línea:

double salario, peso;

En el momento de la declaración se le pueden asignar un valor a una variable, es decir que inicialmente tenga un valor determinado. Para esto, la declaración consiste en un tipo de dato seguido de un nombre de variable, un signo = y una constante de tipo apropiado finalizando con ‘;’. Por ejemplo:

int c = 12; /*declara la variable entera c y le asigna el valor 12*/

float tot = 3.56e2; /*declara la variable flotante tot y le asigna 356*/

char letra = 'Z';

1.8 Constantes simbólicas Una constante simbólica es un nombre que sustituye una secuencia de caracteres. Cuando el programa se compila, cada aparición de la constante simbólica es reemplazada por su secuencia de caracteres. Este tipo de constantes se suelen definir al inicio del programa. La forma de definir una constante simbólica es:

#define nombre_constante texto

Donde nombre_constante representa un nombre simbólico que generalmente se lo suele definir en mayúsculas y texto representa la secuencia de caracteres asociada a ese nombre simbólico. A continuación se muestran algunos ejemplos de este tipo de constantes:

#define PI 3.14159

#define NUMERO 5

#define LETRAS "alfabeto"


7

Debe observarse que las definiciones de las constantes simbólicas no finalizan con “;”. Este tipo de constantes no son imprescindibles en el lenguaje C pero permiten escribir programas más claros y ordenados.

1.9 Expresiones y Oraciones Una expresión representa una unidad de datos, tal como un número o un caracter. Una expresión consiste en una entidad simple como una constante, una variable, o la referencia a alguna funcion. Tambien puede ser una combinación de tales entidades interconectadas por operadores, que incluso puede representar condiciones lógicas que son ciertas o falsas. Algunos ejemplos de expresiones son:

x = y

c = a + b

x <= y

Una oración hace que la computadora ejecute alguna acción, son unidades ejecutables en si mismas. Hay tres tipos de oraciones: simples , compuestas y de control .

Una oración simple consiste de una expresión seguida de ´;´ . La ejecución de la oración hace que se evalúe la expresión. Las siguientes son oraciones simples:

x = y; /* asigna el valor de la variable y a la var iable x */

c = a + b; /* asigna a c la suma de las variables a y b */

++i; /* es equivalente a i = i + 1 */

; /* oración nula o vacía */

Una oración compuesta está formada por varias oraciones simples encerradas entre {} (llaves) y no finaliza con ‘;’ después de la llave de cierre, como por ejemplo:

{

pi = 3.141593;

long_circunf = 2. * pi * radio;

area_circunf = pi * radio * radio;

}

Las oraciones de un programa se ejecutan secuencialmente, una a continuación de la otra, empezando por la primera y así siguiendo hasta la última. El Lenguaje C cuenta con varias construcciones para modificar este flujo secuencial de ejecución, las llamadas oraciones de control o estructuras de control y se utilizan para modificar el flujo de ejecución del programa. Por ejemplo: while(i < 20) {

printf("i= %d",i);

++i;

}

Este ejemplo de oración o estructura de control contiene una oración compuesta que a su vez contiene varias oraciones simples. La oración de control se ejecuta mientras el valor de la variable i sea menor que 20, o lo que es lo mismo decir, se ejecuta hasta que i tenga el valor de 20.

1.10 Operadores y expresiones Un operador es un carácter o grupo de caracteres que operan sobre uno, dos o más datos, para realizar una operación determinada que provee un resultado.


8

Los datos sobre los que actúan los operadores se denominan operandos . Existen operadores que actúan sobre un operando (denominados unarios o monarios) y otros sobre dos operandos (denominados binarios).

Una expresión es un conjunto de variables y constantes relacionadas mediante distintos operadores, como por ejemplo:

x = y; /* asigna el valor de la variable y a la var iable x */

c = a + b; /* asigna a c la suma de las variables a y b */

Las expresiones pueden contener paréntesis que agrupan algunos de los términos y paréntesis dentro de otros paréntesis, y su significado es el habitual de las expresiones matemáticas

1.10.1 Operadores Aritméticos

En lenguaje C existen cinco operadores aritméticos, ellos son:

Operador Propósito + Suma - Resta * Producto / Cociente % Resto de división entera

Los operadores aritméticos actúan sobre operandos numéricos y por lo tanto los mismos deben ser numéricos, ya sean enteros, de coma flotante o tipo caracter (este último por que son un subtipo de los enteros).

Si uno de los operandos es negativo, el resultado tomará el signo dado por las reglas del álgebra común. Para evaluar el signo correcto del de la resto de división entera debe satisfacerse que:

a = (a / b) * b + (a % b)

Por ejemplo si, a = -5 y b = 2

la operación resto dará como resultado -1 pues: a = (a / b) * b + (a % b)

-5 = -2 * 2 + x

x = -5 + 4 = -1

Cuando una operación posee operadores de distintos tipos, estos pueden sufrir conversión implícita de tipo (o promoción) antes de resolver la operación. En general, el resultado final se expresará con la mayor precisión posible. Si se desea, se puede convertir el valor resultante de una expresión a un tipo de datos diferente, y esto se realiza de la siguiente manera:

(tipo de dato) expresión

Este tipo de construcción se llama conversión explícita de tipo o cast .

Por ejemplo, si i una variable de tipo entero y f una de tipo flotante, la operación: (i+f) % 4

es inválida, pues la operación módulo se aplica a datos de tipo entero, en cambio i+f es flotante. Pero usando un cast adecuado, la operación:

( (int)(i+f) ) % 4


9

ahora es válida. El tipo de dato asociado a la expresión no sufre el cambio por un cast sino que el valor resultante de la expresión es el que sufre la transformación.

En C los operadores se agrupan jerárquicamente de acuerdo con su precedencia u orden de evaluación. Las operaciones con mayor precedencia se ejecutan primero. Este orden se puede alterar mediante el agregado de paréntesis en las operaciones.

Los operadores aritméticos * , / y % se encuentran en un grupo de precedencia, mientras que los operadores + y - se encuentran en un nivel inferior de prioridad.

La asociatividad (orden en que se realizan las operaciones entre operadores de igual precedencia) es de izquierda a derecha.

1.10.2 Operadores monarios (o unarios)

Existen ciertos operadores que actúan sobre un único operando y se denominan monarios. El operador monario más frecuentemente utilizado es el signo ‘-‘ que se utiliza para definir un valor negativo.

Otros operadores monarios son el operador incremento (++) y el operador decremento (-- ). Los mismos se utilizan para incrementar o decrementar el valor de una variable. Por ejemplo, ++i; es equivalente a i = i + 1

--j; es equivalente a j = j - 1

Los operadores incremento y decremento pueden usarse de dos formas:

a) Precediendo al nombre de la variable, y esto significa que la variable se incrementa antes de utilizar su valor (notación prefijo).

b) Después de la variable (notación postfijo), y esto implica que su valor se incrementará luego de utilizarse.

Los operadores monarios tienen mayor precedencia que los operadores aritméticos y su asociatividad es de derecha a izquierda.

Existe el operador monario no-aritmético sizeof . Este operador devuelve el tamaño del operando (variable o tipo de datos) en bytes. Por ejemplo, si se solicita el tamaño en bytes de un entero en alguna máquina en particular, este operador devolverá el número de bytes realmente ocupados por la variable.

1.10.3 Operadores relacionales

En lenguaje C existen cuatro operadores relacionales:

Operador Significado < menor que

<= menor o igual que > mayor que

>= mayor o igual que == Igual que != No igual que (distinto)

Todos estos operadores tienen el mismo nivel de precedencia, que es menor al de los operadores monarios y aritméticos. La asociatividad es de izquierda a derecha.

En (cuenta == 10) si el valor de la variable cuenta es 10 el resultado será verdadero , de lo contrario será falso . Se debe tener especial cuidado en el uso del operador == pues se lo


10

confunde con el operador de asignación =, y para evitar este error se suele utilizar la expresión anterior en la forma (10 == cuenta) .

Estos seis operadores se emplean para formar expresiones lógicas que pueden resultar verdaderas o falsas. El valor resultante de una de estas expresiones es de tipo entero ya que todo valor lógico, en el lenguaje C, está representado por un valor entero:

Verdadero � distinto de 0

Falso � igual a 0.

1.10.4 Operadores lógicos.

Además de los operadores relacionales y de igualdad, C posee tres operadores lógicos, que son los que se muestran en la siguiente tabla:

Operador Significado && Producto lógico (AND) || Suma lógica (OR) ! Negación lógica (NOT)

Los operadores lógicos actúan sobre operandos lógicos. La operación lógica && (Y ó AND) será verdadera si y solo si los dos operandos son verdaderos. En cambio la operación lógica || (O u OR) será verdadera si alguno de los operandos es verdadero.

Los operadores lógicos tienen precedencia propia. La Y lógica tiene mayor precedencia que la O lógica. La precedencia de estos operadores se encuentra por debajo de la de los operadores de igualdad.

El operador lógico monario que niega el valor de una expresión lógica es el ‘!’ , también llamado NO o NOT.

Las expresiones lógicas compuestas unidas por los operadores lógicos && y || se evalúan de izquierda a derecha, pero sólo hasta que se establece el valor verdadero o falso de la expresión completa . Esta particularidad se denomina evaluación en cortocircuito , e implica que puede suceder que no se evalúe la expresión completa. Por ejemplo, en la siguiente expresión lógica: (error > 0.001) && (cuenta < 100)

Si error no es mayor que 0.001, toda la expresión es falsa y no se evaluará si cuenta es menor que 100.

Por otro lado, la expresión: (error > 0.001) || (cuenta < 100)

si error es mayor 0.001, la expresión completa será cierta independientemente del valor de la variable cuenta , y esta última no será evaluada.

1.10.5 Operadores de asignación

El operador de asignación se utiliza para asignar el valor de una expresión a un identificador. El operador de asignación mas usado es el signo ‘=’ . Las expresiones de asignación son de la forma:

identificador = expresión


11

Si los dos operandos de una oración de asignación son de diferente tipo, el valor de la expresión de la derecha se convertirá automáticamente (dentro de ciertos límites) al tipo del identificador de la izquierda.

En lenguaje C están permitidas las asignaciones múltiples de la forma: identificador_1 = identificador_2 = expresión

lo cual es equivalente a: identificador_1 = (identificador_2 = expresión)

Además existen cinco operadores de asignación más, que son los siguientes: += -= *= /= %=

y por ejemplo, la expresión de asignación expresión_1 += expresión_2

será equivalente a: expresión_1 = expresión_1 + expresión_2

La siguiente tabla resume la forma de trabajo de estos operadores de asignación,

Expresión Equivalente i += 5 i = i + 5 f -= g f = f - g j *= (i - 3) j = j * (i - 3) f /= 3 f = f / 3 i %= (j - 2) i = i % (j - 2)

Los operadores de asignación tienen menor precedencia que el resto de los operadores anteriores.

1.10.6 Operador condicional

Este operador permite realizar operaciones condicionales simples, reemplazando a la tradicional estructura if-else y tiene la forma:

expresión_1 ? expresión_2 : expresión_3

Cuando se ejecuta el operador condicional, primero se evalúa expresión_1 , si es cierta, se procesa expresión_2 . Si expresión_1 es falsa se procesa expresión_3 . De esta forma queda fijada su precedencia.

Por ejemplo, la estructura z = (a > b) ? a : b; es equivalente a z = max(a,b) ;

1.10.7 Precedencia y orden de evaluación

El siguiente cuadro resume los operadores listados en orden de precedencia con su correspondiente asociatividad.

Operadores Asociatividad Monarios - ++ -- sizeof() D � I

Prod, Div y resto * / % I � D Suma y resta + - I � D Relacionales < <= > >= I � D

Igualdad == != I � D


12

Prod. Lógico && I � D Suma Lógica || I � D Condicional ? : D � I

Asignación = += -=

*= /= %= D � I

1.11 Estructuras de control En la Programación Estructurada, el control del flujo de ejecución de un programa se lleva a cabo por medio de las “estructuras de control ”, que en el lenguaje C están materializadas por las siguientes construcciones:

1.11.1 Estructura while

Esta oración se utiliza para generar bucles o lazos. La sintaxis de esta estructura es, while (expresión) {

oraciones

}

La oración incluida entre llaves se ejecutará repetidamente mientras el valor de la expresión no sea falso, y esta estructura puede ser simple o compuesta. A modo de ejemplo, la visualización en pantalla de los dígitos del 0 al 9 podría realizarse de la siguiente forma:

#include <stdio.h>

int main( ) {

int digito = 0;

while(digito <=9) {

printf("%d\n",digito);

++digito;

}

return 0;

}

La primera instrucción que aparece en el programa permite incluir el archivo de cabecera stdio.h que proporciona información sobre las funciones de la biblioteca de entrada/salida estándar (en este caso printf ). Así mismo la instrucción int main() debe colocarse en todo programa. Estos dos temas serán tratados con posterioridad.

En el tercer renglón se declara la variable entera dígito y se inicializa en cero. El bucle while ejecuta una estructura compuesta visualizando el dígito y posteriormente incrementándolo. Esto se ejecuta hasta tanto la variable dígito no supere el valor 9.

Este programa puede realizarse en forma más concisa como se muestra a continuación: #include <stdio.h>

int main() {

int digito = 0;

while(digito <=9) {

printf("%d\n",digito++);

}

return 0;

}


13

En este caso el lazo contiene una oración simple, se imprime el dígito y posteriormente se incrementa con el operador monario "++" .

En el siguiente ejemplo se calcula el promedio de una lista de n números. #include <stdio.h>

int main( ) {

int n,cont = 1;

float dato, media, suma = 0;

printf("Cuántos números va a promediar?");

scanf("%d", &n);

while(cont <= n) {

printf("Dato= ");

scanf("%f",&dato);

suma += dato;

++cont;

}

media = suma/n;

printf("Valor medio = %f\n",media);

return 0;

}

donde la función scanf permite leer datos introducidos a través del teclado. Esta función se estudiará más adelante.

1.11.2 Estructura do - while

La estructura while vista anteriormente realiza la evaluación de la condición antes de ejecutar cada ciclo, pero hay situaciones donde se requiere que el test se realice al final de cada ciclo, y la estructura do-while permite esto. Su sintaxis es:

do {

oraciones

} while(expresión);

Como puede observarse, el bloque oraciones se ejecutará al menos una vez. Los mismos ejemplos anteriores pero usando esta nueva estructura de control quedarán:

• Impresión de los dígitos del 0 al 9 #include <stdio.h>

int main( ) {

int digito = 0;

do {


} while(digito <= 9);

return 0;

}

• Cálculo del promedio #include <stdio.h>

int main( ) {

int n,cont = 1;


printf("Cuantos números va a promediar?");


14

scanf("%d", &n);

do {

printf("Dato= ");

scanf("%f",&dato);

suma += dato;

++cont;

} while(cont <= n);

media = suma/n;


return 0;

}

1.11.3 Estructura for

Esta es una de las estructuras de control más utilizadas y expresivas. Su forma general es: for(expresión_1; expresión_2; expresión_3) {

oraciones

}

Donde expresión_1 se utiliza para inicializar un parámetro (una variable) que se denomina índice y que controla la repetición del bucle. Expresión_2 representa una condición que debe ser satisfecha para que se continúe con la iteración y expresión_3 se utiliza para modificar el valor del parámetro inicialmente asignado por expresión_1 . Cuando esta estructura se ejecuta, la expresión lógica expresión_2 se evalúa y se comprueba antes de cada ciclo, mientras que expresión_3 se evalúa al final del mismo. La estructura for es equivalente a: expresión_1;

while( expresión_2 ) {

oraciones;

expresion_3;

}

Desde el punto de vista sintáctico, en la estructura for no es obligatoria la presencia de las tres expresiones, aunque es requisito indispensable la presencia de los puntos y coma ‘;’ . Las expresiones primera y tercera pueden omitirse siempre y cuando la variable índice se inicialice y/o modifique de alguna forma. La segunda expresión, si se omite, se asume igual a 1 y el lazo iterará infinitamente a menos que se use algún mecanismo para detenerlo. Este último caso se verá a posteriori.

Nota: Este tipo de estructura, se usa principalmente cuando se conoce el número de veces que el lazo se debe repetir, pero dado que es también una estructura while “camuflada”, es posible utilizarla como tal aprovechando su notación más compacta.

Operador coma ( , )

El Operador " , " se utiliza principalmente en la estructura for , y permite que aparezcan dos o más expresiones en situaciones en donde se utilizaría sólo una expresión. La forma general es la siguiente: for( expresión_1a , expresión_1b ; expresión_2 ; expresión_3a, expresión_3b ) {

oración

}

En este caso se inicializan y procesan dos índices dentro de la instrucción for .


15

A continuación se muestran los ejemplos anteriores haciendo uso de la estructura for .

• Impresión de los dígitos del 0 al 9 #include <stdio.h>

int main( ) {

int digito;

for(digito = 0; digito <=9; digito++) {

printf("%d\n",digito);

}

return 0;

}

• Cálculo del promedio #include <stdio.h>

int main( ) {

int n,cont;


printf("Cuántos números va a promediar?");

scanf("%d", &n);

for(cont = 0; cont < n;++cont) {

printf("Dato= ");

scanf("%f",&dato);

suma += dato;

}

media = suma/n;


return 0;

}

• Impresión del 0 al 9 obviando la primera y tercera expresión. #include <stdio.h>

int main( ) {

int digito = 0;

for(;digito <=9;) {


}

return 0;

}

1.11.4 Repeticiones anidadas

Los bucles se pueden definir uno dentro del otro (anidar), es decir se puede poner una estructura de control dentro de otra. Es esencial que un bucle se encuentre completamente incluido dentro de otro, y además, cada bucle debe ser controlado por un índice diferente.

Por ejemplo: Válido Inválido while(bandera == 0){ for(i=0; i< 100;i++){ ............ } //fin del for }// fin del while

while(bandera == 0){ for(i=0; i< 100;i++){ ............ } // fin del while } // fin del for


16

1.11.5 Estructura if-else.

Esta estructura se utiliza para realizar una toma de decisión a través de la evaluación de una expresión y llevar a cabo una de dos posibles acciones dependiendo de su valor verdadero o falso . La forma general de esta estructura es:

if(expresión_lógica) {

oración

}

La expresión_lógica siempre se debe encontrar entre paréntesis. La oración sólo se ejecutará si la expresión es verdadera. Existe también una forma más general que incluye la cláusula else .

if(expresión_lógica) {

oración_1

} else {

oración_2

}

Si expresión_lógica tiene un valor verdadero se ejecutará la oración_1 pero si es falsa se ejecutará la oración_2 .

• Ejemplo 1:

if(x < 100) {

printf("X= %d",x);

}

• Ejemplo 2:

if(indicador !=0) {

printf("Se han Producido: %d Iteraciones",indicad or);

valor = 0;

}

• Ejemplo 3:

if(j != 0) {

suma+=78.9;

--z;

}

else {

printf("Acumulado %f",suma);

z=0;

k+=3;

}

1.11.6 Estructura switch

Esta estructura permite seleccionar un grupo de oraciones entre varios grupos disponibles. La selección se basa en el valor de una expresión entera que se incluye en la estructura switch. La forma general de esta estructura es:


17

switch( expresión_entera ) {

oración

}

Expresión_entera debe evaluar necesariamente a un tipo o subtipo entero.

oración generalmente es una secuencia de posibles opciones a seguir . Para cada opción, la oración del grupo debe ser precedida por una o mas etiquetas case . Las etiquetas case identifican los diferentes grupos de oraciones y distinguen una de otras. Cada grupo de oraciones se escribe de forma general como: case expresión:

oración 1

...

oración N

o en el caso de varias etiquetas case: case expresión 1:

case expresión 2:

case expresión 3:

oración 1

case expresión 4:

oración 2

La palabra reservada default identifica uno de los grupos de oraciones dentro de switch. Esta etiqueta se utiliza si ninguna de las etiquetas case coincide con el valor de expresión .

Por ejemplo, el siguiente programa cuenta la ocurrencia de dígitos, espacios en blanco y todos los otros caracteres.

#include <stdio.h>

int main( ) {

int c, i, nblancos, notros, ndigitos[10];

nblancos = notros = 0;

for(i = 0; i < 10; i++) {

ndigitos[i] = 0;

}

while((c = getchar()) != EOF) {

switch(c) {

case '0':

case '1':

case '2':

case '3':

case '4':

case '5':

case '6':

case '7':

case '8':

case '9':

ndigitos[c - '0']++;

break;

case ' ':

case '\n':

case '\t':


18

nblancos++;

break;

default:

notros++;

break;

}

} /* fin while */

printf("Digitos =");

for(i=0; i < 10; i++) {

printf(" %d", ndigitos[i]);

}

printf("\nEspacios en blanco = %d, otros = %d\n",n blancos, notros);

return 0;

}

Nota: La oración break puede ser utilizada para finalizar la ejecución de cada etiqueta de la estructura switch.

1.11.7 Oración break

Se utiliza para terminar la ejecución de bucles o salir de una estructura switch. Se puede utilizar dentro de una estructura while , do-while , for o switch . La forma general de esta estructura es:

break;

Ejemplo 1: switch(variable) {

case 1:

printf("Valor: %d",i);

break;

case 2:

printf("Valor: %d",i);

break;

}

Ejemplo 2: switch(eleccion = getchar()) {

case 'r':

case 'R':

printf("Rojo\n");

break;

case 'v':

case 'V':

printf("Verde\n");

break;

. . .

default:

printf("Desconocido\n");

}


19

1.11.8 Oración continue

Es utilizada para obviar el resto de las instrucciones de un lazo. Un lazo no termina cuando se encuentra una oración continue sino que no se ejecutan las oraciones que se encuentran a continuación de ella, saltando a la siguiente repetición del bucle.

Ejemplo: do {

scanf("%f",&x);

if (x < 0) {

printf("Valor Negativo\n");

continue;

}

suma=suma+x;

} while( x<=100 );

En este ejemplo no se sumarán los valores negativos de x y el lazo se ejecutará hasta tanto no se lea un valor de x mayor o igual a 100.

1.12 Tabla de conversión de operadores de LPP a C.

LPP Lenguaje C Comentario Operadores + + Suma

- - Resta * * Multiplicación / / División mod % Módulo (resto de división entera) > > Mayor que >= >= Mayor o igual a < < Menor que <= <= Menor o igual a <> != Distinto a = == Igual a

Asignación � = Asignación i �i+1 i++ ó ++i incremento i �i-1 i-- ó --i decremento i �i+n i+=n incremento en n i �i-n i-=n decremento en n i �i*n i*=n producto por n i �i/n i/=n divido por n con n<>0 i �i%n i%=n módulo por n

Tipos de datos

entero int

entero sin signo

unsigned int

entero doble long int real float real doble double caracter char


20

LPP Lenguaje C Comentario

Arreglos Arreglo[100]

de tipo A A[100]

Los arreglos comienzan con índice 0 en la posición 0 y no en la uno como

otros lenguajes.

Matrices Arreglo[100]

[100] de tipo A

A[100][100] El índice de la izq. varía más lentamente

1.13 Tabla de conversión de estructuras de control de LPP a lenguaje C

LPP Lenguaje C Comentario si (condición) entonces

Acciones 1

sino

Acciones 2

fin si

if (condición) {

Acciones 1

} else {

Acciones 2

}

Estructura de selección

si-entonces-sino-finsi

Repetir

Acciones

Hasta que(condición)

do {

Acciones

} while(!(condición));

Estructura de repetición

repetir-hasta que

Observar que la condición es distinta.

Mientras (condición) hacer

Acciones

fin mientras

while(condición) {

Acciones

}


mientras-hacer-fin mientras

para V desde V0 hasta Vn paso p

hacer

Acciones

fin para

for(v=v0;v<vn;v+=p) {

Acciones

}


para-hacer-fin para

Caso ( q )

x1: ........

............

xn: ........

sino: .........

fin caso

switch( q ) {

case x1: ....

break;

..........

case xn: ....

break;

default: .....

break;

}

Reemplaza a un conjunto de estructuras si anidadas para

condiciones por igualdad.

La restricción es que debe evaluar a un número entero.

1.14 Entrada y salida de datos

1.14.1 Algunas funciones de la biblioteca estándar

A lo largo de los diversos ejemplos se han utilizado algunas funciones predefinidas del lenguaje C, en particular la función de salida printf . Ahora se analizarán específicamente algunas de las funciones de entrada/salida más usadas, en particular las funciones getchar , putchar , scanf , printf , gets y puts .

Se puede acceder a una de estas funciones desde cualquier lugar de un programa con solo escribir su nombre, seguido de una lista de argumentos entre paréntesis. Los argumentos son


21

los datos que se envían a la funcion para que esta lleve a cabo su trabajo. Algunas funciones no necesitan argumentos, pero lo mismo estarán presentes los paréntesis, aunque vacíos.

Otro aspecto importante a considerar, es que la mayoría de las versiones de C incluyen una colección de archivos (bibliotecas estándar) llamados de cabecera que proporcionan la información necesaria para las distintas funciones de biblioteca. Estos archivos se incluyen en un programa mediante la oración #include al comienzo del programa. El archivo cabecera requerido para entrada/salida estándar se llama stdio.h .

#include <stdio.h>

1.14.2 Entrada de un caracter - Función getchar

Esta función permite el ingreso de un caracter a través del teclado y es parte de la biblioteca estándar del C. La misma devuelve el caracter leído desde el dispositivo estándar de entrada (normalmente el teclado). No requiere argumentos y su forma general es:

variable_caracter = getchar();

Donde variable_caracter es alguna variable previamente definida.

Si se encuentra una condición de fin de archivo cuando se está leyendo un caracter con la función getchar , la misma devolverá el valor de la constante simbólica EOF (End Of File � final de archivo). Esta constante también está definida en el archivo de cabecera stdio.h y normalmente tiene el valor -1 .

1.14.3 Salida de un caracter - Función putchar

Esta función es el complemento de la función getchar y permite visualizar un caracter. Al igual que la función anterior es parte de la biblioteca estándar del C. Su forma es:

putchar(variable_caracter);

Donde variable_caracter hace referencia a una variable tipo caracter previamente definida.

A continuación se muestra un programa que hace uso de estas dos funciones. El mismo lee caracteres desde el teclado hasta que encuentra un caracter de final de línea (\n ). Todos los caracteres leídos los va almacenando en un arreglo denominado letras . Posteriormente se imprimen los caracteres leídos pero convertidos a mayúsculas (función toupper , biblioteca ctype.h ).

#include <stdio.h>

#include <ctype.h>

int main( ) {

char letras[80];

int aux, cont;

for(cont = 0; (letras[cont]=getchar())!='\n'; ++c ont)

; /* el for no tiene estructura */

aux=cont;

for(cont =0; cont < aux;++cont) {

putchar(toupper(letras[cont]));

}

return 0;

}


22

1.14.4 Función scanf

Esta función también llamada función de entrada con formato permite introducir cualquier combinación de valores numéricos, caracteres y cadena de caracteres. Esta función devuelve la cantidad de datos que se han conseguido introducir correctamente.

Su forma general es: scanf(cadena_de_control, arg1, arg2,.., argn);

En donde cadena_de_control hace referencia a una cadena de caracteres que contiene información sobre el formato de los datos y arg1 , arg2 ,..., argn son argumentos que representan direcciones de memoria en donde se encuentran los datos.

En la cadena de control se incluyen grupos de caracteres de control, siendo necesario un grupo por cada dato de entrada. En su forma más sencilla, un grupo de caracteres estará formado por el signo % seguido de un caracter de conversión que indica el tipo del dato correspondiente. Dentro de la cadena de control no se permite la inclusión de mensajes, tales como carteles de aclaración de que tipo de información requiere el programa.

Dentro de la cadena de control se pueden encontrar varios caracteres seguidos o pueden estar separados por caracteres de espaciado (espacios en blanco, tabuladores, etc).

Los argumentos pueden ser variables o arreglos y sus tipos deben coincidir con los indicados por los grupos de caracteres correspondientes en la cadena de control. Cada nombre de variable debe ser precedido por el caracter & ya que los argumentos son en realidad punteros que indican donde están situadas las variables en memoria, a menos que la variable sea un puntero (los punteros se analizará más adelante).

Ejemplos: #include <stdio.h>

int main( ) {

char letras[20];

int entero;

float flotante;

. . . . . . . . scanf("%s %d %f”, letras, &entero, &flotante);

. . . . . . . .

return 0;

}

La cadena de control es en este caso "%s %d %f " . Contiene tres grupos de caracteres. El primer grupo de caracteres, %s indica que el primer argumento (letras) representa una cadena de caracteres y como se verá más adelante el nombre de un arreglo es un puntero y por lo tanto no se debe colocar el símbolo &. Además cuando se lee una cadena de caracteres como en el ejemplo se debe tener en cuenta que no se permiten espacios en blanco. El segundo grupo, %d, indica que el segundo argumento (&entero) representa un valor entero decimal, y el tercer grupo, %f, indica que el tercer argumento (&flotante) representa un valor de coma flotante.

Otro ejemplo, #include <stdio.h>

int main( ) {

char letras[80];


23

scanf("%[ ABCDEFGHIJKLMNOPQRSTUWXYZ]", línea);

...... ...... }

Dado que el proceso de lectura de la función scanf analiza expresiones regulares, es posible proporcionar una de ellas como cadena_de_control y personalizar así el proceso de lectura de acuerdo a la necesidad. En el ejemplo anterior, se especifica una expresión regular que solo permite la lectura de caracteres en blancos y letras del abecedario en mayúsculas.

También es posible limitar el número de caracteres especificando una longitud de campo . El dato puede estar compuesto por menos caracteres que los que especifique la longitud de campo, pero no se leerán los que se encuentran mas allá de este valor. Estos caracteres sobrantes pueden ser interpretados de forma incorrecta como los componentes del siguiente dato.

Ejemplo: #include <stdio.h>

int main( ) {

char letras[20];

int entero;

float flotante;

scanf("%s %3d %5f”,letras,&entero,&flotante);

..... ..... }

1.14.5 Función printf

Como ya se ha visto esta función permite escribir datos en el dispositivo estándar de salida, es análoga en su uso a la función scanf . En términos generales, la función se escribe como:

printf(cadena_de_control, arg1, arg2,..., argn);

Donde cadena_de_control hace referencia a una cadena de caracteres que contiene información sobre el formato de la salida y arg1 , arg2 ,..., argn son argumentos que representan los datos de salida. Los argumentos pueden ser constantes, variables simples o nombres de arreglos, o expresiones mas complicadas. En contraste con la función scanf, los argumentos de printf no representan direcciones de memoria y por lo tanto no deben ser precedidos por el símbolo &. Básicamente la cadena de control tiene una estructura igual a la cadena de control de la función scanf. La lista de caracteres de conversión para esta función se muestra en la tabla.

Caracter Significado c El dato es visualizado como un caracter. d El dato es visualizado como un entero decimal con signo. e El dato es visualizado como un valor en coma flotante con exponente. f El dato es visualizado como un valor en coma flotante sin exponente. g El dato es visualizado como un valor en coma flotante. i El dato es visualizado como un entero con signo. o El dato es visualizado como un entero octal, sin el cero inicial. s El dato es visualizado como una cadena de caracteres. u El dato es visualizado como un entero decimal sin signo. x El dato es visualizado como un entero hexadecimal sin el prefijo 0x .


24

En esta función puede especificarse el número de decimales a imprimir. Un número de coma flotante se redondeará si se debe recortar para ajustarse a la precisión especificada. Además de la longitud, la precisión y el caracter de conversión, cada grupo puede incluir un indicador que afecta la forma en que aparecerán los datos en la salida, y este indicador debe colocarse inmediatamente a continuación del signo %. Algunos compiladores permiten que aparezcan dos o más indicadores seguidos dentro del mismo grupo de caracteres. En la siguiente tabla aparecen los indicadores de uso más común.

Indicador Significado

+ Cada dato numérico es precedido por un signo + o -. Sin este indicador solo se muestra el signo - en el dato que corresponda.

- El dato se ajusta a la izquierda dentro del campo. 0 En lugar de espacios vacíos se muestran ceros. # Hace que los datos Octales y Hexadecimales sean precedidos por 0 o 0x.

El siguiente programa permite visualizar un número en coma flotante con distintas precisiones. #include <stdio.h>

int main( ) {

float x = 123.456;

printf("%7f %7.3f %7.1f\n\n", x, x, x);

printf("%12e %12.5e %12.3e", x, x, x);

return 0;

}

Cuando se ejecuta este programa, se genera la siguiente salida: 123.456000 123.456 123.5

1.234560e+002 1.23456e+002 1.235e+002

1.14.6 Funciones gets y puts

Estas funciones aceptan un solo argumento. El mismo debe ser un dato que represente una cadena de caracteres. La misma puede contener espacios. Estas funciones son alternativas sencillas para la lectura de cadenas de caracteres respecto al uso de scanf y printf respectivamente. #include <stdio.h>

int main( ) {

char linea[80];

gets( linea );

puts( linea );

return 0;

}

1.15 Estructura general de un programa en C Un programa en C posee un conjunto de bloques que se pueden estructurar de la siguiente manera:

• Inclusión de bibliotecas (archivos .h) • Declaración de funciones globales • Declaración de variables globales • Declaración de constantes simbólicas


25

• Definición de funciones (declaradas previamente)

int main( ) { /* Una de tantas posibilidades de declarar la func ión main */

• Declaración de Variables locales

• • • • Cuerpo ejecutable del programa en C • • •

} // fin del programa

1.16 Ejercitación con estructuras de control Ejercicio Nº 1: Leer el radio de una circunferencia, calcular su perímetro y el área del círculo. Mostrar los resultados.

#include <stdio.h>

#define PI 3.1416 /* DEFINICION DE LA CONSTANTE SIM BOLICA PI */

int main( ) {

float radio, perimetro, area; /* DEFINICION DE VA RIABLES */

printf("\nIngresar RADIO ");

scanf("%f",&radio); /* ENTRADA DE DATOS */

perimetro = 2 * PI * radio; /* CALCULO DEL PERIM ETRO */

area = PI * radio * radio; /* CALCULO DEL AREA * /

printf("Perímetro = %f \n",perimetro); /* SALIDA D E RESULTADOS */

printf("Area = %f",area); /* SALIDA DE RESULTADO S */

return 0; /* valor genérico entregado por main * /

}

Ejercicio Nº 2: Calcular el salario de un empleado, teniendo en cuenta el número de horas trabajadas y el valor de la hora de trabajo. Mostrar el valor obtenido.

#include <stdio.h>

int main( ) {

float nhoras, valor, salario;

printf("\nIngrese Nro. de horas trabajadas: ");

scanf("%f",&nhoras);

printf("\nIngrese valor hora");

scanf("%f",&valor);

salario = nhoras * valor;

printf("\nEl salario es = %f",salario);

return 0; /* valor genérico entregado por main */

}

Ejercicio Nº 3: Leer dos números enteros y mostrar el cociente, el producto, la suma, la diferencia y la media entre ellos.


26

#include <stdio.h>

int main( ) {

int a, b, sum, dif, prod;

float coc, media;

printf("\nIngrese A ");

scanf("%i",&a);

printf("\nIngrese B distinto de cero");

scanf("%i",&b);

sum = a + b;

dif = a - b;

prod = a * b;

coc = a / (float) b;

media = (float) sum / 2;

printf("\nSuma = %i",sum);

printf("\nDiferencia = %i",dif);

printf("\nProducto = %i",prod);

printf("\nCociente = %f",coc);

printf("\nMedia = %f",media);


}

Ejercicio Nº 4: Leer números naturales e ir sumándolos hasta que el total supere 10.000, mostrar la cantidad de números acumulados.

#include <stdio.h>

int main( ){

unsigned int n, total = 0, contador = 0;

while(total < 10000) {

printf("\nIngrese número");

scanf("%i",&n);

total += n;

++contador;

}

printf("\nTotal de números ingresados: %i", contado r);


}

Ejercicio Nº 5: Se toma una evaluación a los alumnos de Informática II. Teniendo en cuenta que la nota aprobatoria es 6, mostrar el porcentaje de alumnos aprobados, reprobados y ausentes sobre un total de 80 alumnos.

#include <stdio.h>

int main( ) {

int apro = 0, rep = 0, aus = 0, i = 0;

float nota, papro, prep, paus;

for(i = 1 ; i <= 80; ++i) {

printf("\nIngrese nota: ");

scanf("%f",&nota);

switch(nota) {

case 0:


27

case 1:

case 2:

case 3:

case 4:

case 5:

++rep;

break;

case 6:

case 7:

case 8:

case 9:

case 10:

++apro;

break;

default:

++aus;

break;

}

}

papro = (float) apro / 80 * 100;

prep = (float) rep / 80 * 100;

paus = (float) aus / 80 * 100;

printf("\nCant de alumnos ausentes = %i", aus);

printf("\nPorcentaje de aprobados = %f", papro);

printf("\nPorcentaje de reprobados = %f", prep);

printf("\nPorcentaje de ausentes = %f", paus);


}

Ejercicio Nº 6: En una estación meteorológica se realizan N mediciones de la presión atmosférica por día. Leer las mediciones y mostrar los valores máximo, mínimo y promedio.

#include <stdio.h>

int main( ) {

int n, k;

float acum = 0, vmax, vmin, presion, promedio;

printf("\nIngrese cantidad de mediciones");

scanf("%i",&n);

printf("\nIngrese el valor de presión");

scanf("%f",&presion);

/* El primer valor de presion se asigna a vmax y vm in para tomar

una referencia y poder comparar con los valores sig uientes.*/

vmax = vmin = presion;

for(k = 1; k <= n-1; ++k) {

printf("\nIngrese el valor de presión \n");

scanf("%f",&presion);

if(presion > vmax) {

vmax = presion;

}


28

if(presion < vmin) {

vmin = presion;

}

acum += presion;

}

promedio = acum / (float) n;

printf("\nEl valor máximo es: %f",vmax);

printf("\nEl valor mínimo es: %f",vmin);

printf("\nEl promedio es: %f",promedio);


}

Ejercicio Nº 7: Dado un número natural, determinar si es par o impar. #include <stdio.h>

int main() {

int n;

printf("\nIngrese el número (0 - 32.767): ");

scanf("%i",&n);

while(n >= 1) {

n -= 2;

}

if( n == 0 ) {

printf("Número par");

} else {

printf("Número impar");

}


}

Ejercicio Nº 8: Leer un número natural y comprobar si es múltiplo de 3. #include <stdio.h>

int main( )

int n;

printf("\nIngrese el número (0 - 32767): ");

scanf("%i",&n);

while(n >= 1) {

n -= 3;

}

if(n == 0) {

printf("Número múltiplo de tres");

} else {

printf("No es múltiplo de tres");

}


}

Ejercicio Nº 9: Calcular el producto de 2 números naturales mediante sumas sucesivas. Mostrar el resultado.


29

#include <stdio.h>

int main( ) {

int a, b, k, prod = 0;

printf("\nIngresar primer número: ");

scanf("%i",&a);

printf("\nIngresar segundo número: ");

scanf("%i",&b);

for(k = 0; k < a; ++k) {

prod += b;

}

printf("\nEl producto es: %i", prod);


}

Ejercicio Nº 10: Escribir la suma de los primeros 20 números naturales pares. #include <stdio.h>

int main( ) {

int k, suma = 0;

for(k = 0; k <=20; ++k)

suma += (k * 2);

printf("/nSuma de los primeros 20 números pares = %i", suma);


}

Ejercicio Nº 11: Leer dos números naturales A y N. Escribir la suma de los N primeros múltiplos impares de A.

#include <stdio.h>

int main( ) {

int a, b, k, suma = 0;

printf("\nIngresar primer número: ");

scanf("%i",&a);

printf("\nIngresar segundo número: ");

scanf("%i",&b);

for(k = 1; k <= b;)

suma += (a * (2 * k++ - 1));

printf ("/nSuma de los %i primeros múltiplos impare s de A = %i", b, suma);


}

Ejercicio Nº 12: Leer un número natural y calcular el cuadrado o el factorial según sea par o impar respectivamente. En ambos casos mostrar el resultado obtenido.

#include <stdio.h>

int main( ) {

int n, x, paridad, factorial;

printf("Número = ? ");

scanf("%d", &n);

paridad = n;

while(paridad > 0) {

paridad -= 2;

}


30

if(paridad == 0) {

n *= n;

printf("N es par y el cuadrado de N es = %d", n);

} else {

factorial = 1;

for(x = n; x >= 1; --x) { {

factorial *= x;

}

printf("N es impar y su factorial es = %d", facto rial);

}


}

Ejercicio Nº 13: Leer las longitudes de los tres lados de un triángulo y mostrar un mensaje indicando si es equilátero, isósceles o escaleno.

#include <stdio.h>

int main( ) {

int a, b, c;

printf("/nIngrese los números A, B, C = ?");

scanf("%d %d %d", &a, &b, &c);

if(a == b) {

if(b == c) {

printf("/nTriángulo equilatero");

} else {

printf("/nTriángulo isosceles");

}

} else {

if(b == c) {


} else {

if(a == c) {


} else {

printf("/nTriángulo escaleno");

}

}

}


}

Ejercicio Nº 14: Leer N números reales y mostrar el promedio de los mayores que cero. #include <stdio.h>

int main( ) {

int n, x, numero, contador = 0, promedio = 0;

printf("\nCantidad de nros. a promediar ? ");

scanf("%d", &n);

for(x = 1; x <= n; ++x) {

printf("\nNúmero = ? ");

scanf("%d", &numero);

if(numero > 0) {


31

promedio += numero;

++ contador;

}

}

promedio /= contador;

printf("\nPromedio de %d números positivos = %d", contador, promedio);


}

1.17 Ejercicios propuestos Ejercicio Nº 15: Leer los coeficientes de una ecuación de segundo grado y escribir sus raíces, considerando todos los casos posibles.

Ejercicio Nº 16: Leer tres números y escribirlos en orden ascendente.

Ejercicio Nº 17: Leer las coordenadas de un punto en el plano y mostrar un mensaje que indique si el punto pertenece o no a la circunferencia con centro en el origen y radio 4.

Ejercicio Nº 18: Leer cinco variables numéricas y escribir la mayor y la menor de ellas.

Ejercicio Nº 19: Leer números enteros hasta ingresar el valor cero. Escribir la suma de ellos si todos fueran negativos y en caso contrario escribir el promedio.

Ejercicio Nº 20: Leer ternas de números naturales hasta encontrar una cuyos elementos sean números impares consecutivos. Mostrar los elementos de dicha terna.

Ejercicio Nº 21: En una bodega se cuenta con la siguiente información:

• Cantidad de viñateros

• Cantidad de uva cosechada por cada viñatero

• Código del tipo de uva: moscatel, comunes, blancas, tintas

Teniendo en cuenta que cada viñatero cosecha sólo un tipo de uva se pide:

1) total de uva entregada a la bodega por todos los viñateros.

2) Porcentaje que representan los tipos de uva moscatel y blanca (juntas) respecto del total.

3) Cantidad de kilos cosechados del tipo de uvas tintas.

Ejercicio Nº 22: Dado un intervalo abierto, leer sus límites A y B. Luego leer datos hasta detectar diez que pertenezcan al intervalo y calcular la suma de los mismos.

facultad de ingenieríadea.unsj.edu.ar/.../recursos/apuntes/capitulo-01.pdf · 2019-07-01 · todo...

Documents