apunte lenguaje c - universidad nacional de misionesapunte lenguaje c. parte 1. - 11 - 2.2.4....

FACULTAD DE INGENIERÍAUNIVERSIDAD NACIONAL DE MISIONES

Apunte Lenguaje CParte 1

Año 2017

APUNTE LENGUAJE C. Parte 1. - 1 -

PRÓLOGO

El objetivo de este apunte es que sirva de guía para aprender a programar bajo el Entorno Gráfico del Sistema Operativo Linux en Lenguaje C. Para ello, luego de varios intentos y pruebas sobre las aplicaciones a utilizar en el ámbito del Software Libre, me incliné por la Distribución de Linux Ubuntu y, como interface de IDE (Integrated Development Environment), elegí Zinjai.

Este apunte está destinado a los alumnos de los cursos de Taller de Informática , Informática y Computación de la Facultad de Ingeniería de Oberá.

Tengo que aclarar que este apunte fue realizado mediante la compilación / edición de material encontrado en Internet fundamentalmente. En algunos casos con modificaciones parciales y, en otros, modificaciones totales. Otro aporte utilizado, sobre todo en la organización de los temas, fue obtenido de Libros; finalmente, se utilizaron ejemplos de guías y apuntes de las Cátedras de años anteriores. En conclusión, este apunte es el resultado del trabajo de muchas personas, organizado de la manera que me pareció más apropiada para el dictado de las materias y para poder conseguir los objetivos propuestos en las mismas.

Los ejemplos de código de este apunte fueron probados sobre:

Ubuntu , Lubuntu o Xubuntu. Zinjai http://zinjai.sourceforge.net/

El libro se divide en partes, la Parte 1 incluye los capítulos que se desarrollan en la Materia Taller de Informática / Informática. La Parte 2 y 3 son los temas que conjuntamente con la Parte 1 deben ser vistos en la Materia Computación. El material que consideramos puede ser importante como consulta o complemento fue dispuesto en los Apéndices.


Imágenes utilizadas a lo largo del texto

Links o enlaces de utilidad.

Ejercicios o actividades recomedadas.

Información interesante o destacada.

Apéndices o material complementario.


CAPITULO 1. INTRODUCCIÓN

EL lenguaje C fue creado por Dennis Ritchie en los laboratorios de la Bell Telephone en 1972. El mismo fue pensado para desarrollar un Sistema Operativo llamado UNIX. Este lenguaje es el sucesor del lenguaje llamado B (de allí el nombre C).

Debido a la flexibilidad y poder de programación, se extendió rápidamente y empezaron a surgir distintas versiones. Como consecuencia de esto nace un comité llamado ANSI (American National Estándar Institute) el cuál define lo que se conoce como Standard C o como Estándar ANSI C.

¿Por qué usar C?

Es poderoso y flexible: dadas las características del lenguaje, permite el desarrollo de proyectos como sistemas operativos, procesadores de texto, hojas de cálculo, etc.

Es un lenguaje común: como está muy difundido su uso, existe una amplia variedad de compiladores y accesorios útiles para el programador.

Es transportable: se puede correr en cualquier tipo de computadora, esta ventaja se ve aumentada con el Estándar C.

Posee pocas palabras clave: la base sobre la cual está construida la funcionalidad del lenguaje tiene pocas palabras claves.

Es modular: el código puede y debe ser escrito en módulos llamado funciones que pueden ser utilizadas y re-utilizadas por otras aplicaciones o programas.

El lenguaje C++ es una versión mejorada del C, lo que significa que tiene todo lo que tiene el Estándar C más agregados para la Programación Orientada a Objetos.


¿Que diferencia hay entre C y C++? C++ es súper conjunto de C, es decir que C es un conjunto de C o C está contenido por C++.

El C++ incorpora nuevas características sin comprometer ninguna de las bondades del C, entre las cosas que se agregó son el concepto de clases, herencia, funciones virtuales del lenguaje Simula67 y sobrecarga de operadores del Algol68 (características que veremos en detalle en el curso).-

¿Quien creó y cuando el C++? El C++ fue desarrollado por Bjarne Strousrup, en los laboratorio de Bell a principios de los 80, esto es 10 años después que el Lenguaje C.

¿Son compatibles los programas de C con C++? Uno de los grandes aciertos de C++, fue mantener la compatibilidad con C, de este modo cualquier programa hecho en C puede ser considerado también como un programa de C++.

¿Hay un Estándar para el C++? Sí. En forma resumida, el ANSI define un conjunto de reglas; cualquier compilador de C o de C++ debe cumplir esas reglas, si no, no puede considerarse un compilador de C o C++. Estas reglas definen las características de un compilador en cuanto a palabras reservadas del lenguaje, comportamiento de los elementos que lo componen, funciones externas que se incluyen, etc. Un programa escrito en ANSI C o en ANSI C++, podrá compilarse con cualquier compilador que cumpla la norma ANSI. Se puede considerar como una homologación o etiqueta de calidad de un compilador.

¿Hay características no estándares en C++? Si, todos los compiladores incluyen, además del ANSI, ciertas características no ANSI, por ejemplo librerías para gráficos. Pero mientras no usemos ninguna de esas características, sabremos que nuestros programas son transportables, es decir, que podrán ejecutarse en cualquier ordenador y con cualquier sistema operativo. Por eso es probable que el desarrollo de un programa bajo, por ejemplo Dev C++ de Bloodshed, podría no compilarse bajo Zinjai.

ENLACES ÚTILES:

http://www.conclase.net/c/curso/index.php


http://www.conclase.net/c/curso/index.php?cap=900

CAPITULO 2. LENGUAJE C

Para poder crear un programa en lenguaje C debemos realizar una serie de pasos que nos permitirán pasar de nuestro programa escrito en código fuente a nuestro archivo ejecutable.

El lenguaje C es compilado, esto significa que un programa compilador lee el código fuente completo escrito por el programador, lo convierte en código objeto también conocido como código binario o código máquina. Una vez compilado, el linker enlazará las librerías dentro de su código objeto y así obtendrá, finalmente el programa ejecutable.

Veamos en detalle cada uno de estos conceptos.

2.1. Operaciones básicas de programación

2.1.1. Creación del fichero fuente

Los programas en C y C++ se escriben con la ayuda de un editor de textos (pico ó vi) del mismo modo que cualquier texto corriente.

Los ficheros que contienen programas en C o C++ en forma de texto se conocen como ficheros fuente, y el texto del programa que contiene se conoce como programa fuente.

Nosotros siempre escribiremos programas fuente y los guardaremos en ficheros fuente.

Los programas fuente no pueden ejecutarse. Son ficheros de texto, pensados para que los comprendan los seres humanos, pero incomprensibles para los ordenadores.


2.1.2. Creación del fichero objeto

Para obtener un programa ejecutable hay que seguir algunos pasos.

El primer paso es compilar o traducir el programa fuente a su código objeto equivalente. Este es el trabajo que hacen los compiladores de C y C++.

Consiste en obtener un fichero equivalente a nuestro programa fuente comprensible para el ordenador, este fichero se conoce como fichero objeto, y su contenido como código objeto.

Los compiladores son programas que leen un fichero de texto que contiene el programa fuente y generan un fichero que contiene el código objeto.

El código objeto no tiene ningún significado para los seres humanos, al menos no directamente. Además es diferente para cada ordenador y para cada sistema operativo.

Por lo tanto, existen diferentes compiladores para diferentes sistemas operativos y para cada tipo de ordenador.

Estas tareas las realizaremos, como dijimos antes, con Zinjai, pero se podrían realizar en modo consola, utilizando el compilador por ejemplo g++.

2.1.3. Creación del fichero ejecutable

2.1.3.1. Uso de librerías

Junto con los compiladores de C y C++, se incluyen ciertos ficheros llamados librerías.

Las librerías contienen código objeto de programas que permiten hacer cosas comunes como, por ejemplo, leer desde el teclado, escribir en pantalla, manejar números, realizar funciones matemáticas, etc.

Las librerías están clasificadas por el tipo de trabajos que hacen, hay librerías de entrada y salida, matemáticas, de manejo de memoria, de manejo de textos, etc.

Hay un conjunto de librerías muy especiales, que se incluyen con todos los compiladores de C y de C++. Son las librerías ANSI o estándar. Pero también hay librerías no estándar, y dentro de éstas hay librerías públicas y comerciales.


En este curso sólo usaremos librerías ANSI.


2.1.3.2. Ficheros ejecutables y enlazadores

Cuando obtenemos el fichero objeto, aún no hemos terminado el proceso.

El fichero objeto, a pesar de ser comprensible para el ordenador, no puede ser ejecutado.

Hay varias razones para eso:

1. Nuestros programas usaran, en general, funciones que estarán incluidas en librerías externas, ya sean ANSI o no. Es necesario combinar nuestro fichero objeto con esas librerías para obtener un ejecutable.

2. A menudo, nuestros programas estarán compuestos por varios ficheros fuente y, de cada uno de ellos, se obtendrá un fichero objeto. Es necesario unir, todos los ficheros objeto más las librerías, en un único fichero ejecutable.

3. Hay que dar ciertas instrucciones al ordenador para que cargue en memoria el programa y los datos y para que organice la memoria de modo que se disponga de una pila de tamaño adecuado. La pila es una zona de memoria que usa el programa para intercambiar datos con otros programas o con otras partes del propio programa. Veremos esto con más detalle durante el curso.

Existe un programa que hace todas estas cosas, se trata del "link", o enlazador.

El enlazador toma todos los ficheros objeto que componen nuestro programa, los combina con los ficheros de librería que sea necesario y crea un fichero ejecutable.

Una vez terminada la fase de enlazado, ya podremos ejecutar nuestro programa.

2.2. Manejo de Errores

Por supuesto, somos humanos, y por lo tanto nos equivocamos. Los errores de programación pueden clasificarse en varios tipos, dependiendo de la fase en que se presenten.

Pueden ser:


Errores de sintaxis

Warnings o avisos

Errores de enlazado

Errores de ejecución

Errores de diseño

2.2.1. Errores de sintaxis

Los errores de sintaxis son errores en el programa fuente. Pueden deberse a palabras reservadas, palabras mal escritas, expresiones erróneas o incompletas, variables no definidas, etc.

Los errores de sintaxis se detectan en la fase de compilación. El compilador, además de generar el código objeto, nos dará una lista de errores de sintaxis. De hecho nos dará sólo una cosa o la otra, ya que si hay errores no es posible generar un código objeto.

2.2.2. Warnings o Avisos

Además de errores, el compilador puede dar también avisos o warnings.

Los avisos son errores, pero no lo suficientemente graves como para impedir la generación del código objeto. No obstante, es importante corregir estos avisos, ya que el compilador tiene que decidir entre varias opciones, y sus decisiones no tienen por qué coincidir con lo que el programador pretende. Las decisiones se basan en las directivas que los creadores del compilador decidieron durante su creación.

2.2.3. Errores de enlazado

El programa enlazador también puede encontrar errores que normalmente se refieren a funciones que no están definidas en ninguno de los ficheros objetos ni en las librerías.

Puede que hayamos olvidado incluir alguna librería, algún fichero objeto o que hayamos olvidado definir alguna función o variable, o lo hayamos hecho mal.


2.2.4. Errores de ejecución

Aunque se haya obtenido un fichero ejecutable, es posible que se produzcan errores.

En el caso de los errores de ejecución normalmente no obtendremos mensajes de error, sino que simplemente el programa terminará bruscamente. Estos errores son más difíciles de detectar y corregir.

Existen programas auxiliares para buscar estos errores, son los llamados depuradores o debuggers. Estos programas permiten detener la ejecución de nuestros programas, inspeccionar variables y ejecutar nuestro programa paso a paso. Esto resulta útil para detectar excepciones, errores sutiles, y fallos que se presentan dependiendo de circunstancias distintas.

2.2.5. Errores de diseño

Finalmente los errores más difíciles de corregir y prevenir.

Si nos hemos equivocado al diseñar nuestro algoritmo, no habrá ningún programa que pueda ayudar al programador a corregir los errores de diseño. Contra estos errores sólo cabe practicar, pensar. Puede ayudar a solucionar este tipo de errores la opción depurar que generalmente poseen los compiladores del lenguaje C.


CAPITULO 3. Estructura de un programa

Los programas de computadoras varían sustancialmente en cuanto al propósito, estilo y complejidad. Pero la mayoría debe: ingresar y almacenar datos, procesar los datos para almacenar los resultados deseados y mostrar, almacenar o imprimir los resultados obtenidos.

Cada dato utilizado durante la ejecución del programa deberá ser descrito para que el compilador lo reconozca, sepa cómo almacenarlo y recuperarlo; se deberá reservar memoria para que pueda almacenar la cantidad de datos necesarios.

Una vez almacenados los datos, éstos deberán procesarse. El proceso varía según el propósito del programa.

Finalmente, los datos procesados deberán ponerse a disposición del usuario.

Cuando se utiliza el lenguaje C para escribir un programa se debe tener en cuenta que:

Todos los programas poseen una función main() que indica el punto donde se inicia la ejecución. La ejecución finaliza cuando se encuentra el final de main.

Debe declarar todas las variables antes de usarlas.

Las partes más importantes de un programa en C son:

directivas del pre-procesador: #include y #define

declaración de variables globales

prototipos de funciones

declaración de clases

función main


definición de funciones

definición de clases

3.1. Directivas del preprocesador

Las líneas que comienzan con el símbolo # son indicaciones para el compilador o directivas del preprocesador.

Sintaxis:

#include

La directiva include le indica al compilador que lea y compile el contenido del archivo con extensión .h que contiene las descripciones de las funciones de librería utilizadas a lo largo del programa.

Por ejemplo:

#include

le indica al compilador que compile el contenido del archivo stdio.h.

Sintaxis:

#define nombre valor

La directiva define determina un reemplazo o sustitución. La directiva le indica al compilador que cada vez que en el programa aparezca nombre sea reemplazado por valor. Esta sentencia resulta útil cuando son programas largos y nombre se utiliza varias veces ya que, si cambia el valor de nombre se debe modificar una sola vez al principio del programa.

Por ejemplo:

#define NUMERO 5.3

le indica al compilador que cada vez que aparezca NUMERO en el programa sea sustituido por 5.3.


3.2. Declaración de variables globales

Las expresiones que permiten realizar cálculos dentro de los programas están formadas por variables, constantes y operadores.

Las variables se deben declarar antes de ser utilizadas en el programa, ya que el compilador debe conocer qué tipo de dato es una variable antes de poder compilar cualquier sentencia que la use.

El lugar donde se declara una variable afecta mucho la manera en que otras partes del programa pueden utilizarla.

Las reglas que determinan cómo se puede usar una variable basada en el lugar en que fue declarada se llaman reglas de alcance del lenguaje.

Si la variable se declara en ésta zona del programa, fuera de todas las funciones, incluyendo la función main(), se denomina variable global y se puede utilizar en cualquier parte del programa.

3.3. Prototipos de funciones

Antes de utilizar una función en el programa, ésta se debe definir.

En esta porción del programa se definen las funciones a utilizar indicando el nombre de la función, el número y tipos de argumentos que utilizará durante la ejecución. Finaliza cada sentencia con punto y coma (;).

Esta definición se realiza mediante los prototipos de funciones.

3.4. Función main()

Todos los programas escritos en C poseen una función llamada main(). Es la función que se ejecuta en primer lugar cuando comienza a funcionar el programa. El programa posee una sola función main().


En la siguiente línea aparece una llave { que indica el grupo de instrucciones que definen lo que sucederá cuando se ejecute el programa. Cada grupo de sentencias finaliza con una llave}.

3.5. Definición de funciones

Esta zona contiene el código para cada función declarada. El encabezamiento de la definición será exactamente igual a la declaración, excepto que no finaliza con punto y coma (;).


CAPITULO 4. Datos, var iables y constantes

4.1 Datos

Como se había mencionado en el capítulo 3, “Cada dato utilizado durante la ejecución del programa deberá ser descrito para que el compilador lo reconozca, sepa cómo almacenarlo y recuperarlo; se deberá reservar memoria para que pueda almacenar la cantidad de datos necesarios.”

La declaración de cada ítem de datos consiste en indicar qué tipo de dato es y darle un nombre que lo identifique.

En C hay tipos básicos de datos: carácter (character), entero (integer), punto flotante (floating point) y puntero (point); aunque, en cada versión del lenguaje, pueden aparecer más o menos tipos de datos.

Por ejemplo, en C sólo existen cinco tipos fundamentales y los tipos enumerados, C++ añade un séptimo tipo, el bool, y el resto de los tipos son derivados de ellos.

Los números son los datos fundamentales utilizados por los programas de computadoras. El contenido de la memoria consiste en números binarios almacenados en grupos de 8 bits (1 byte) o 16 bits (2 bytes o 1 word). Aún cuando un programa de computadora trabaje con letras o gráficos, básicamente está involucrando una serie de números almacenados en memoria.

Los diferentes tipos de datos dependen, en realidad, de la cantidad de bytes que ocupen en memoria.

INFORMACIÓN A TENER EN CUENTA


Para obtener información más detallada acerca de los tipos de datos, la cantidad de memoria reservada remitirse al

APENDICE Tipos de datos

Cuando se desea definir ítems de datos que almacenen palabras (dos o más caracteres) nos encontramos ante el tipo de dato “string” o cadena de caracteres.

Por ejemplo:

`hola´

´Juan Pérez´

Este tipo de datos merece un desarrollo especial por ello se verá en el capítulo 9 que estudia el tema de arreglos.

4.2. Variables

El ítem de dato llamado variable, se refiere a un espacio de memoria cuyo contenido se modificará de acuerdo a las circunstancias durante la ejecución del programa.

Cada variable utilizada en el programa deberá ser declarada antes de ser utilizada.

La declaración de una variable le indica al lenguaje que se pretende utilizar una variable particular y qué tipo de dato almacenará. La declaración se forma por un tipo de dato seguido de uno o más nombres de variables.

La inicialización de una variable significa asignarle al espacio de memoria reservado un valor particular. Resulta conveniente realizarlo porque cuando se declara una variable, el espacio de memoria reservado, podrá contener cualquier valor.

4.2.1. Identificadores

Un identificador es el nombre que permite identificar un espacio de memoria mediante un nombre válido para el lenguaje.


El lenguaje C es flexible pero posee ciertas reglas que debemos respetar cuando definimos identificadores para las variables que utilizaremos en el programa.

Reglas para dar nombre a las variables:

Sólo se pueden usar letras (mayúsculas o minúsculas), números y ciertos caracteres no alfanuméricos, como el '_', pero nunca un punto, coma, guión, comillas o símbolos matemáticos o interrogaciones.

El primer carácter no puede ser un número.

C y C++ distinguen entre mayúsculas y minúsculas, de modo que los identificadores número y Número son diferentes.

Los primeros 32 dígitos son significativos, esto significa que La_cantidad_total_de_dinero_en_mi_cuenta y La_cantidad_total_de_dinero_en_mi_banco serán consideradas como la misma variable.

4.2.2. Declaración de variables

Una característica del C es la necesidad de la declaración de las variables que se usarán en el programa. Aunque esto resulta chocante para los que se aproximan al C desde otros lenguajes de programación, es en realidad una característica muy importante y útil de C, ya que ayuda a conseguir códigos más compactos y eficaces, y contribuye a facilitar la depuración, la detección y corrección de errores.

Sintaxis:

[tipo] [lista_de_identificadores];

Tipo debe ser un tipo de datos válido y lista_de_identificadores puede ser uno o más identificadores separados por coma (,). La declaración de variables puede considerarse como una sentencia. Desde este punto de vista, la declaración terminará con un ";".

Por ejemplo:

int numero;

float promedio, final;


char letra;

También es posible inicializar las variables dentro de la misma declaración. Por ejemplo:

int a = 1234;

bool seguir = true, encontrado;

char letra = ‘k’;

Declararía las variables "a", "seguir", "encontrado" y “letra”; y además iniciaría los valores de "a" en 1234, “seguir” en "true" y “letra” con ‘k’.

En C, contrariamente a lo que sucede con otros lenguajes de programación, las variables no inicializadas tienen un valor indeterminado, contienen lo que normalmente se denomina "basura", también en esto hay excepciones como veremos más adelante.

4.2.2.1. Declaración de una variable de tipo entero (integer)

[signed|unsigned] [short|long|long long] int [signed|unsigned] long long [int] [signed|unsigned] long [int] [signed|unsigned] short [int]

4.2.2.2. Declaración de una variable de tipo punto flotante (float)

float

4.2.2.3. Declaración de una variable de tipo punto flotante de doble precisión (double)

[long] double

4.2.2.4. Declaración de una variable sin tipo (void)

void

Este es una variable especial que indica la ausencia de tipo. Se usa en funciones que no devuelven ningún valor, también en funciones que no


requieren parámetros, aunque este uso sólo es obligatorio en C, y opcional en C++, también se usará en la declaración de punteros genéricos.

4.2.2.5. Declaración de una variable de tipo enumerado (enum)

enum [] { [= ], ...} [lista_de_variables];

Este tipo nos permite definir conjuntos de constantes, normalmente de tipo int, llamados datos de tipo enumerado. Las variables declaradas de este tipo sólo podrán tomar valores entre los definidos.El identificador de tipo es opcional, y nos permitirá declarar más variables del tipo enumerado en otras partes del programa. La lista de variables también es opcional. Sin embargo, al menos uno de los dos componentes opcionales debe aparecer en la definición del tipo enumerado. Varios identificadores pueden tomar el mismo valor, pero cada identificador sólo puede usarse en un tipo enumerado.

Por ejemplo:

enum tipohoras {una=1, dos, tres, cuatro, cinco, seis, siete, ocho, nueve, diez, once, doce, trece=1, catorce, quince, dieciseis, diecisiete, dieciocho, diecinueve, veinte, veintiuna, veintidós, veintitrés, veinticuatro = 0};

En este caso, una y trece valen 1, dos y catorce valen 2, etc. Y veinticuatro vale 0. Como se ve en el ejemplo, una vez se asigna un valor a un elemento de la lista, los siguientes toman valores correlativos. Si no se asigna ningún valor, el primer elemento tomará el valor 0.

4.2.2.6. Declaración de una variable de tipo boleana (boolean)

bool

Las variables de este tipo sólo pueden tomar dos valores "true" o "false". Sirven para evaluar expresiones lógicas.

Este tipo de variables se puede usar para almacenar respuestas, por ejemplo: ¿Posees carné de conducir? O para almacenar informaciones que sólo pueden tomar dos valores, por ejemplo: qué mano usas para escribir. En


estos casos debemos acuñar una regla, en este ejemplo, podría ser diestro->"true", zurdo->"false".

4.2.3. Inicialización de variables

En C se pueden asignar valores a la mayoría de las variables a la vez que se las declara.

La inicialización de una variable se realiza poniendo un signo igual y una constante después del identificador.

Sintaxis:

[tipo] [identificador = constante];

Por ejemplo:

char a = ‘p’; int num = 0;

4.2.4. Ejercicios sobre Variables

1)¿Cuáles de los siguientes son tipos válidos de variables?

a) unsigned char

Sí No

b) long char

Sí No

c) unsigned float

Sí No

d) double char

Sí No

e) signed long


Sí No

f) unsigned short

Sí No

g) signed long int

Sí No

h) long double

Sí No

i) enum dia {lunes, martes, miercoles, jueves, viernes, sabado, domingo};

Sí No

j) enum color {verde, naranja, rojo}; enum fruta {manzana, fresa, naranja, platano};

Sí No

k) long bool

Sí No

4.3. Constantes

Las constantes son muy similares a las variables, con la diferencia que éstas solo pueden tomar un valor en el momento de la declaración, luego cualquier intento de modificación será tomado como un error por parte del compilador.

Las constantes se declaran del mismo modo que las variables, solamente se debe anteponer la sentencia “const” antes del tipo de dato.

Por ejemplo:const int mayor = 25;


4.3.1. Normas para la notación

Veremos las reglas que rigen la escritura de las constantes en C según diversos sistemas de numeración y que uso tiene cada uno.

¿Por qué es necesaria la notación? En todos los casos, especificar el tipo de la constante tiene como objetivo evitar que se realicen conversiones de tipo durante la ejecución del programa, obligando al compilador a hacerlas durante la fase de compilación.

Por ejemplo:E

float x = 0.0;

if(x

Según el ejemplo el número 0x7f, donde "0x" es el prefijo que indica que se trata de un número en notación hexadecimal, sería el número 7F, es decir, 7*16+15=127. Del mismo modo que el número 127 en notación decimal sería, 1*10²+2*10+7=127. En octal se usa como prefijo el dígito 0. El número 0177 equivale a 1*8²+7*8+7=127.


Hay que tener mucho cuidado con las constantes numéricas, en C y C++ no es el mismo número el 0123 que el 123, aunque pueda parecer otra cosa. El primero es un número octal y el segundo decimal.

La ventaja de la numeración hexadecimal es que los valores enteros requieren dos dígitos por cada byte para su representación. Así un byte puede tomar valores hexadecimales entre 0x00 y 0xff, dos bytes entre 0x0000 y 0xffff, etc. Además, la conversión a binario es casi directa, cada dígito hexadecimal se puede sustituir por cuatro bits, el '0x0' por '0000', el '0x1' por '0001', hasta el '0xf', que equivale a '1111'. En el ejemplo el número 127, o 0x7f, sería en binario '01111111'.

Con la numeración octal es análogo, salvo que cada dígito agrupa tres bits. Así un byte se puede tomar valores octales entre 0000 y 0377, dos bytes entre 0000000 y 0177777, etc. Además, la conversión a binario es casi directa, cada dígito octal se puede sustituir por tres bits, el '0' por '000', el '1' por '001', hasta el '7', que equivale a '111'. En el ejemplo el número 127, o 0177, sería en binario '01111111'.

De este modo, cuando trabajemos con operaciones de bits, nos resultará mucho más sencillo escribir valores constantes usando la notación hexadecimal u octal.

Por ejemplo, resulta más fácil predecir el resultado de la siguiente operación:

A = 0xaa & 0x55;

Que:

A = 170 & 85;

En ambos casos el resultado es 0, pero en el primero resulta más evidente, ya que 0xAA es en binario 10101010 y 0x55 es 01010101, y la operación


"AND" entre ambos números es 00000000, es decir 0. Ahora se propone al alumno intentarlo con los números 170 y 85.-

4.3.1.2. Constantes "long"

Para trabajar con valores constantes "long" debemos usar el sufijo "L". Esto resulta conveniente, sobre todo, al utilizar las constantes en expresiones condicionales y, por coherencia, también en expresiones de asignación.

Por ejemplo:

long x = 123L;

if(x == 0L) cout

Como cuando se utilizan constantes long, a menudo recibiremos errores del compilador cuando usemos constantes long long sin añadir el sufijo LL.

Por ejemplo:

if(x == 16575476522787) cout

Por ejemplo:

unsigned long long x = 123456534543ULL;

if(x == 3124232ULL) cout

Las constantes de tipo "char" se representan entre comillas sencillas, por ejemplo 'a', '8', 'F'.


4.3.2. Recomendaciones en el uso de la notación

4.3.2.1. Constantes enteras

En general podemos combinar los prefijos "0" y "0x" con los sufijos "L", "U", y "UL". Aunque es indiferente usar los sufijos en mayúsculas o minúsculas, es preferible usar mayúsculas, sobre todo con la "L", ya que la 'l' minúscula puede confundirse con un uno '1'.

4.3.2.2. Constantes punto flotante

Se recomienda añadir el .0, cuando la constante se pueda confundir con un entero.

Usar la notación exponencial

También podemos usar notación exponencial, donde el formato exponencial consiste en un número, llamado mantisa, que puede ser entero o con decimales, seguido de una letra 'e' o 'E' y por último, otro número (entero) que es el exponente de una potencia de base 10.

Por ejemplo:

double x = 10e4;

double y = 4.12e2;

double pi = 3.141592e0;

Los valores anteriores se representarían:

x = 10 x 104 = 100000

y = 4,12 x 102 = 412

pi = 3.141592 x 100 = 3.141592


Al igual que con los enteros, es indiferente usar los sufijos en mayúsculas o minúsculas, pero es preferible usar mayúsculas, sobre todo con la "L", ya que la 'l' minúscula puede confundirse con un uno '1'.


4.3.3 Constantes carácter. Un comentario adicional.

Si has pensado que una constante char se representa con 'k', tal vez, después de un rato te preguntes ¿cómo se representa la constante que consiste en una comilla sencilla?

Bien, te lo voy a contar … aunque no lo hayas pensado.

Existen ciertos caracteres, entre los que se encuentra la comilla sencilla, que no pueden ser representados con la norma general. Para eludir este problema existe cierto mecanismo, llamado secuencias de escape. En el caso comentado, la comilla sencilla se define como '\'', y antes de que preguntes te diré que la barra descendente se define como '\\'.

Además de estos caracteres especiales existen otros.

4.3.3.1. Código ASCII

El código ASCII es el conjunto de caracteres que puede ser representado por el tipo "char", consta de 128 o 256 caracteres.

El código ASCII de 128 caracteres utiliza 7 bits, actualmente ha quedado prácticamente obsoleto ya que no admite caracteres como la 'ñ' o la 'á' pero, aún se usa en ciertos equipos antiguos donde el octavo bit se usa como bit de paridad en las transmisiones serie.

El código ASCII de 256 caracteres utiliza los 8 bits y, si recordamos, el tipo "char" tiene siempre un byte (8 bits) y esto no es por casualidad.

En este conjunto existen, además de los caracteres alfabéticos, en mayúsculas y minúsculas, los numéricos, los signos de puntuación y los caracteres internacionales, ciertos caracteres no imprimibles, como el retorno de línea, el avance de línea, etc.

Veremos estos caracteres y cómo se representan como secuencia de escape, en hexadecimal, el nombre ANSI y el resultado o significado.

Escape Hexadecimal ANSI Nombre o resultado

0x00 NULL Carácter nulo

\a 0x07 BELL Sonido de campanilla

\b 0x08 BS Retroceso

\f 0x0C FF Avance de página


\n 0x0A LF Avance de línea

\r 0x0D CR Retorno de línea

\t 0x09 HT Tabulador horizontal

\v 0x0B VT Tabulador vertical

\\ 0x5c \ Barra descendente

\' 0x27 ' Comilla sencilla

\" 0x22 " Comillas

\? 0x3F ? Interrogación

\O cualquiera O=tres dígitos en octal

\xH cualquiera H=número hexadecimal

\XH cualquiera H=número hexadecimal

Los tres últimos son realmente comodines para la representación de cualquier carácter.

El \nnn sirve para la representación en notación octal. Para la notación octal se usan tres dígitos. Hay que tener en cuenta que, análogamente a lo que sucede en la notación hexadecimal, en octal se agrupan los bits de tres en tres. Por lo tanto, para representar un carácter ASCII de 8 bits, se necesitarán tres dígitos. En octal sólo son válidos los símbolos del '0' al '7'. Según el ejemplo anterior, para representar el carácter 127 en octal usaremos la cadena '\177', y en hexadecimal '\x7f'. También pueden asignarse números decimales a variables de tipo char.

Por ejemplo:

char A;

A = 'a';

A = 97; //El valor decimal de Ascii que representa la A

A = 0101 ; //El valor Octal de Ascii que representa la A

A = 0x61; // Ver que va el cero y x antes !!

A = '\x61';

A = '\141';

En este ejemplo todas las asignaciones son equivalentes y válidas.

Veamos un ejemplo de código:


#include

using namespace std;

int main()

{char opc0='A'; //Ascii de A expresado como Caracter

char opc1=65 ; //Ascii de A expresado en Decimal

char opc2= 0101; //Ascii de A expresado en Octal

char opc3 = 0x41; //Ascii de A expresado en Hexadecimal

cout

a) '\x37'

char

long

int

float

b) 123UL

unsigned

int

long

unsigned long

c) 34.0

int

double

float

long

d) 6L

int

long

double

char

e) 67

char

unsigned

int

float

f) 0x139


char

unsigned

int

float

g) 0x134763df23LL

long

unsigned

int

long long

MATERIAL COMPLEMENTARIO

Para la creación de identificadores en la escritura del código fuente se recomienda ver APENDICE ESTILOS DE NOTACIÓN.


CAPITULO 5. Operadores

Los operadores son elementos que disparan ciertos cálculos cuando son aplicados a variables o a otros objetos en una expresión.

Un operador es un símbolo que le dice al compilador que realice manipulaciones matemáticas o lógicas específicas.

El lenguaje C tiene las siguientes clases de operadores: aritméticos, relacionales, lógicos y sobre bits.

Hay varios tipos de operadores, clasificados según el tipo de objetos sobre los que actúan.

Los tipos de operadores que veremos son:

Operadores aritméticos

Operadores relacionales

Operadores lógicos

Operadores de asignación

Operador sizeof

Operador condicional

Operador coma

5.1. Operadores aritméticos

Los operadores aritméticos se utilizan para crear expresiones matemáticas.

5.1.1. Operadores aritméticos unitarios


Los operadores aritméticos unitarios que utiliza el C son: '+', '-','++', '--'

Sintaxis:

+

-

++ /* post-incremento */

++ /* pre-incremento */

-- /* post-decremento */

-- /* pre-decremento */

5.1.1.1. Operadores '+' y '-'

Los operadores aritméticos unitarios '+' y '-' asignan valores positivos o negativos a la expresión a la que se aplican.

5.1.1.2. Operadores '++' y '--'

Los otros dos operadores unitarios '++' y '--' son un tanto especiales, ya que sólo pueden trabajar sobre variables, pues implican una asignación.

El primero ('++') incrementa el valor del operando y el segundo ('--') lo decrementa, ambos en una unidad.

Existen dos modalidades, dependiendo de que se use el operador en la forma de prefijo o de sufijo.

En su forma de prefijo, el operador es aplicado antes de que se evalúe el resto de la expresión; en la forma de sufijo, se aplica después de que se evalúe el resto de la expresión.

Por ejemplo:

en las siguientes expresiones "a" vale 100 y "b" vale 10:

c = a + ++b;

En este primer ejemplo primero se aplica el pre-incremento, y b valdrá 11 a continuación se evalúa la expresión "a+b", que dará como resultado 111, y por último se asignará este valor a c, que valdrá 111.


c = a + b++;

En este segundo ejemplo primero se avalúa la expresión "a+b", que dará como resultado 110, y se asignará este valor a c, que valdrá 110. Finalmente se aplica en post-incremento, y b valdrá 11.

Los operadores unitarios sufijos (post-incremento y post-decremento) se evalúan después de que se han evaluado el resto de las expresiones.

En el primer ejemplo primero se evalúa ++b, después a+b y finalmente c =.

En el segundo ejemplo, primero se evalúa a+b, después c = y finalmente b++.


Es muy importante no pensar o resolver las expresiones C como ecuaciones matemáticas, NO SON EXPRESIONES MATEMATICAS.

No veas estas expresiones como ecuaciones, NO SON ECUACIONES.

5.1.2. Operadores aritméticos binarios

Los operadores binarios que utiliza el lenguaje C son: '+', '-', '*', '/', %''

Sintaxis:

+ /*Sintaxis de operador suma */

- /* Sintaxis de operador resta */

* /* Sintaxis de operador multiplicación */

/ /* Sintaxis de operador división */

% /* Sintaxis de operador resto */

Evidentemente se trata de las conocidísimas operaciones aritméticas de suma, resta, multiplicación y división y los operadores se comportan como en cualquier lenguaje de computadoras.


Debemos tener en cuenta, por ejemplo, que el operador división (/) aplicado a un entero truncará cualquier resto.

Por ejemplo:

10 / 3 será igual a 3 para la división entera.

El operador módulo '%', devuelve el resto de la división entera del primer operando entre el segundo. Por esta razón no puede ser aplicado a operando en coma flotante (ya que al ser números de punto flotante no hay resto!!).

5.2. Operadores relacionales

Los operadores relacionales permiten determinar las relaciones que un valor o cantidad puede tener con otro.

Aquí resulta clave la idea de verdadero o falso. En C cualquier valor distinto de cero es verdadero, y cero (0) es falso. Así, las expresiones que utilizan operadores relacionales devolverán como resultado 0 si es falsa y 1 si es verdadera la expresión.

A continuación mostramos los operadores relacionales y su sintaxis:

Operador Significado Sintaxis

> mayor que >

< menor que <

>= mayor o igual que >=


Es un error frecuente utilizar el “=” en lugar del “==”, observar que el “=” es para ASIGNAR; y el “==” es para COMPROBAR LA IGUALDAD.


5.3. Operadores lógicos

Los operadores lógicos conforman expresiones lógicas y se utilizan para determinar cómo se presentan las relaciones entre las expresiones involucradas.

La siguiente tabla presenta los operadores lógicos y su sintaxis:

Operador Sintaxis Significado

&& && AND o Y

|| || OR u O

! ! NOT

5.3.1. Operador && o AND

El operador "&&" equivale al "AND" o "Y"; devuelve "true" sólo si las dos expresiones evaluadas son "true" o distintas de cero, en caso contrario devuelve "false" o cero. Si la primera expresión evaluada es "false", la segunda no se evalúa.

Generalizando, con expresiones AND con más de dos expresiones, la primera expresión falsa interrumpe el proceso e impide que se continúe la evaluación del resto de las expresiones. Esto es lo que se conoce como "cortocircuito", y es muy importante, como veremos posteriormente.

El operador && se usa según la siguiente tabla de verdad, donde se representa “true” con 1 y “false” con 0.

Expresión1 Expresión2 &&

true 1 true 1 true 1

Trae 1 false 0 false 0

False 0 true 1 false 0

False 0 false 0 false 0


5.3.2. Operador || u OR

El operador "||" equivale al "OR" u "O inclusivo"; devuelve "true" si cualquiera de las expresiones evaluadas es "true" o distinta de cero, en caso contrario devuelve "false" o cero. Si la primera expresión evaluada es "true", la segunda no se evalúa.

El operador || se usa según la siguiente tabla de verdad, donde se representa “true” con 0 y “false” con 1.

Expresión1 Expresión2 Expresión1 || Expresión2

true 1 ignorada true 1

false 0 true 1 true 1

false 0 false 0 false 0

5.3.3. Operador ! o NOT

El operador "!" es equivalente al "NOT", o "NO", y devuelve "true" sólo si la expresión evaluada es "false" o cero; en caso contrario devuelve "false".

La expresión "!E" es equivalente a (0 == E).

El operador ! se usa según la siguiente tabla de verdad, donde se representa “true” con 0 y “false” con 1.

Expresión1 !Expresión1

true 1 false 0

false 0 true 1

5.4. Operadores de asignación

La asignación consiste en un nombre de variable, seguido de un signo igual y el valor a ser asignado.

Por ejemplo: a = 14;


El operador asigna el valor de la izquierda (14) a la variable (a) que está a la derecha del operador asignación (=).

Existen varios operadores de asignación, el más evidente y el más usado es el "=", pero no es el único.

Los operadores de asignación y sus diferentes usos se describen a continuación:


Operador Descripción Uso Equivalente a

+= Suma y asignación x+=y x=x+y

-= Resta y asignación x-=y x=x-y

*= Multiplicación y asignación x*=y x=x*y

/= División y asignación x/=y x=x/y

%= Resto y asignación x%=y x=x%y

5.5. Operador "sizeof"

El operador “sizeof” es un operador del tiempo de compilación.

Este operador tiene dos usos diferentes. Devuelve el tamaño de la variable o tipo que está como operando. Si el operador funciona sobre un tipo de dato, éste deberá ir entre paréntesis.

Sintaxis:

sizeof

sizeof (nombre_de_tipo)

En ambos casos, el resultado es una constante entera que da el tamaño en bytes del espacio de memoria usada por el operando, que es determinado por su tipo.

El espacio reservado por cada tipo depende de la plataforma.

En el primer caso, el tipo del operando es determinado sin evaluar la expresión, y por lo tanto sin efectos secundarios.

Por ejemplo:

si el operando es de tipo "char", el resultado es 1.

A pesar de su apariencia, sizeof() NO es una función, sino un OPERADOR.


5.6. Operador condicional (?)

El operador "?:", se trata de un operador ternario (es decir tiene TRES operandos)

Sintaxis:

? :

En la expresión E1? E2:E3, primero se evalúa la expresión E1, si el valor es verdadero ("true"), se evaluará la expresión E2 y E3 será ignorada, si es falso ("false"), se evaluará E3 y E2 será ignorada.

Hay ciertas limitaciones en cuanto al tipo de los argumentos:

E1 debe ser una expresión lógica.

E2 y E3 deben ser de tipo aritmético.

E2 y E3 deben ser de estructuras o uniones compatibles.

E2 y E3 deben ser de tipo "void".

Por ejemplo:

max = (a >=b) ? a : b;

A la variable max se le asigna el mayor valor.

#define max (a,b) (((a) > (b)) ? (a) : (b))

De este ejemplo sólo nos interesa la parte de la derecha. La interpretación es: si "a" es mayor que "b", se debe evaluar "a", en caso contrario evaluar "b", en resumen, evalúa siempre el máximo!!

5.7. Operador coma (,)

El operador coma se utiliza para encadenar diversas expresiones. Provoca una secuencia de operaciones a realizar, se puede pensar como “hacer esto y luego esto”.


Tiene una doble función:

separa elementos de una lista de argumentos de una función.

puede ser usado como separador en expresiones "de coma".

Ambas funciones pueden ser mezcladas, pero hay que añadir paréntesis para resolver las ambigüedades y prevenir errores, ya que el operador coma tiene precedencia más baja, por ejemplo, que el operador de asignación.

Sintaxis:

E1, E2, ... , En

En una expresión "de coma", cada operando es evaluado como una expresión, pero los resultados obtenidos se tienen en cuenta en la próxima evaluación.

Por ejemplo:

x = (y=3,y+1);

En primer lugar asigna el valor 3 a la variable y, y después asigna el valor 4 a la variable x.


CAPITULO 6. Expresiones

La combinación de variables, constantes definidas o números con uno o más operadores dan como resultado un valor. Esta combinación recibe el nombre de expresión.

Una expresión es, según el diccionario, un "conjunto de términos que representan una cantidad", entre nosotros es cualquier conjunto de operadores y varios operando, que dan como resultado una cantidad.

Operando es cada una de las cantidades, constantes, variables o expresiones que intervienen en una expresión.

Existe una división, en los operadores, atendiendo al número de operando que afectan. Según esta clasificación pueden ser unitarios, binarios o ternarios, los primeros afectan a un solo operando, los segundos a dos y los ternarios como era de esperar a tres.

Las variables y constantes se pueden procesar utilizando operaciones y funciones adecuadas a sus tipos.

Cada expresión toma un valor que se determina tomando los valores de las variables y constantes implicadas y la ejecución de las operaciones indicadas.

Las expresiones se pueden clasificar, según los tipos de objetos que manipulan, en:

Aritméticas: cuyo resultado sería de tipo numérico.

Lógicas: cuyo resultado sería de tipo lógico.

Carácter: cuyo resultado sería de tipo carácter.

6.1. Expresiones aritméticas


Una expresión aritmética es un conjunto de variables y/o constantes unidas o relacionadas por paréntesis y operadores aritméticos.

Son análogas a las fórmulas matemáticas. Las variables y constantes son numéricas (enteras o punto flotante) y las operaciones son aritméticas.

Por ejemplo:

sueldo = sueldo_base + 0.15 * monto_ventas

e = a*b*b / 3 + (a*a + b) / (b + c)

Cuando se utilizan expresiones aritméticas se debe tener en cuenta que:

Si en una operación ambos operando son enteros, entonces el resultado de la operación es un entero.

Si en una operación uno o ambos operando son reales, entonces el resultado de la operación es un real.

El operador “/” produce un cociente entero si los dos operando son enteros. Esto significa que se pierde la parte decimal si la división no es exacta. Esta es una consecuencia de la nota 1.

El operador “/” produce un cociente float si uno o los dos operando son float. Esta es una consecuencia de la nota 2.

Por ejemplo:

7 / 2 es igual a 3 y no 3.5 como lo es matemáticamente. Esto debido a que 7 y 2 son enteros y al dividir dos enteros se pierde la parte fraccionaria, no se redondea.

En cambio:

7.0 / 2 es igual a 3.5 ya que si uno o los dos operando son reales, entonces el resultado es real. En este caso 7.0 es real.

6.1.1. Reglas de Precedencia

Las expresiones que tienen dos o más operando requieren reglas matemáticas que permitan determinar el orden de las operaciones.

Las Reglas de Prioridad o Precedencia son las reglas matemáticas que permiten determinar el orden de las operaciones.

Son:


Las operaciones que están encerradas entre paréntesis se evalúan primero. Si aparecen varios paréntesis anidados, se evalúan primero los paréntesis interiores.

En caso de coincidir varios operadores de igual prioridad, el orden se determina de izquierda a derecha.

Las operaciones aritméticas dentro de una expresión suelen seguir el siguiente orden de prioridad:

Orden (se evalúa...) Operadores

1ero. Operadores exponenciales (^ , **, )

2do. Operadores * , /

3ero. Operadores DIV , MOD

4to. Operadores +, -

INFORMACIÓN COMPLEMENTARIA

Para más detalle sobre operadores y reglas de precedencia ver

APENDICE. Precedencia de Operadores.

6.2. Expresiones lógicas

Una expresión lógica o booleana es un conjunto de variables y/o constantes unidas mediante operadores lógicos y operadores relacionales.

Las expresiones lógicas se forman combinando constantes lógicas, variables lógicas y otras expresiones lógicas, utilizando operadores lógicos y relacionales; y su valor siempre es verdadero o falso.

Una expresión lógica solo puede tomar uno de dos valores: verdadero o falso.

Las expresiones lógicas son ampliamente utilizadas en las estructuras selectivas y las estructuras repetitivas.


6.2.1. Expresiones comparativas

El formato general para las comparaciones es:

operador de relación

y el resultado será verdadero o falso.

Por Ejemplo:

Si A = 4 y B = 3

A > B da como resultado Verdadero

(A – 2) < (B – 4) da como resultado Falso.

Los operadores de relación se pueden aplicar a los tipos de datos estándar: entero, punto flotante, carácter ó lógico.

6.2.1.1. Aplicación en datos tipo carácter

La aplicación en valores numéricos es evidente; pero cuando deba comparar datos de tipo carácter, se requiere de una secuencia de ordenación de los caracteres, similar al orden creciente o decreciente.

La ordenación suele ser alfabética y se recurre al código normalizado ASCII, donde:

‘0’ < ‘1’ < ‘2’ < ‘3’ ....

‘A’ < ‘B’ < ‘C’ ....

‘a’ < ‘b’ < ‘c’ ....

6.2.1.2. Aplicación en datos tipo lógico

Cuando se utilizan los operadores de relación con valores lógicos, Falso < Verdadero.

Por ejemplo:

Si tenemos la expresión Falso < Verdadero, dará como resultado Verdadero


6.2.1.3. Aplicación en datos tipo punto flotante

Cuando se utilizan los operadores = ó en valores punto flotante, es importante recordar que estos valores no se pueden almacenar exactamente, debido a la precisión aritmética limitada de las computadoras.

Así, lo aconsejable es excluir a los valores punto flotante en este tipo de comparaciones.

6.2.2. Expresiones lógicas

En las expresiones lógicas se pueden mezclar operadores de relación y lógicos.

Por Ejemplo:

(1 < 5) and (5 < 10) da como resultado Verdadero.

(5 < 10) or (‘A’ < ‘B’) da como resultado Verdadero.

INFORMACIÓN COMPLEMENTARIA

Para más detalle sobre operadores y reglas de precedencia ver

APENDICE. Precedencia de Operadores.

Al igual que en las expresiones aritméticas, los paréntesis se podrán utilizar y tendrán prioridad sobre cualquier operación.

Por Ejemplo:

not 4 > 6 da como resultado ERROR, ya que el operador NOT no se aplica sobre el 4.

not(4 > 6) da como resultado Verdadero

6.3. Ejercicios con operadores y expresiones


1) Suponiendo los siguientes valores iniciales para las variables: x = 2; y = 6; z = 9; r = 100; s = 10; a = 15; b = 3; ¿Cuáles son los valores correctos en cada expresión?

a) x += 10;

12

10

11

b) s *= b;

9

13

30

c) r /= 0;

infinito

1

error

d) y += x + 10;

8

12

18

e) z -= a*b;

-36

-18

36

2) Usar expresiones equivalentes para las siguientes, usando operadores mixtos.

a) x = 10 + x - y;

x += 10-y


x -= y+10

x += 10+y

b) r = 100*r;

r *= 100*r

r *= 100

r += 100

c) y = y/(10+x);

y /= 10*x

y /= 10 + y/x

y /= 10+x

d) z = 3 * x + 6;

z += 6

z *= 3

no es posible

3) Evaluar las siguientes expresiones. Siendo:x = 10; y = 20; z = 30;

a) z = x - y, t = z - y;

z=-10, t=-30

t=10

z=30, t=-30

b) (x < 10) && (y > 15)

true

false

c) (x

d) !(x+y < z)

true

false

e) (x+y != z) && (1/(z-x-y) != 1)

true

false

error


CAPITULO 7. Instrucciones

El elemento que nos está faltando para poder comenzar a escribir nuestros propios programas son las sentencias o instrucciones.

Un programa contiene las acciones o instrucciones que resolverán el problema. Las instrucciones describen la secuencia de pasos con el que se quiere solucionar el problema planteado.

Existen instrucciones de diversos tipos que nos permitirán enfrentarnos a todas las situaciones posibles en programación.

Los tipos de sentencias son:

Bloques

Expresiones Llamadas a función Asignación Nula

Bucles while do while for

Etiquetas Etiquetas de identificación case default

Selección if...else switch

Saltos


break continue goto ( NO se usa en nuestro curso) return

Veamos cada una de ellas.

7.1. Bloques

Una sentencia compuesta o un bloque es un conjunto de sentencias, que puede estar vacía, encerrada entre llaves "{}".

Sintácticamente, un bloque se considera como una única sentencia.

También se usa en variables compuestas, como veremos en el capítulo de variables II, y en la definición de cuerpo de funciones.

Los bloques pueden estar anidados hasta cualquier profundidad.

7.2. Expresiones

Una expresión seguida de un punto y coma (;), forma una sentencia de expresión.

La forma en que el compilador ejecuta una sentencia de este tipo es evaluando la expresión. Cualquier efecto derivado de esta evaluación se completará antes de ejecutar la siguiente sentencia.

Sintaxis:

;

7.2.1. Llamadas a función

La sentencia de llamada a función es la manera de ejecutar las funciones que se definen en otras partes del programa o en el exterior de éste, ya sea una librería estándar o particular.

La llamada a función se forma con el nombre de la función, una lista de parámetros entre paréntesis y un ";".


7.2.2. Asignación

Una instrucción de asignación consiste en dar a una variable el valor de una expresión, el valor de otra variable o el valor de una constante.

La sentencia de asignación se utiliza para almacenar valores a variables o constantes.

Es una operación que sitúa un valor determinado en una posición de memoria.

Sintaxis:

;

La expresión de la derecha es evaluada y el valor obtenido es asignado a la variable o constante de la izquierda. El tipo de asignación dependerá del operador utilizado, estos operadores ya los vimos en el capítulo anterior.

En la parte izquierda de la asignación se pone el nombre de la variable que se quiere modificar. La parte derecha contiene una expresión que le dará el nuevo valor a la variable, y por lo tanto debe tener el mismo tipo que la variable.

7.2.3. Nula

La sentencia nula consiste en un único ";". Sirve para usarla en los casos en los que el compilador espera que aparezca una sentencia, pero en realidad no pretendemos hacer nada. Veremos ejemplos de esto cuando lleguemos a los bucles.

7.3. Bucles

Un bucle es la estructura de control que permite la repetición de una serie determinada de sentencias. Es importante tener en cuenta cuántas veces se repite el bucle y cuál es el cuerpo del bucle.

El cuerpo del bucle lo constituyen la serie de sentencias que pueden ser de cualquier tipo (secuencial, de decisión o repetitivo) las cuales serán repetidas n veces, pudiendo ser n conocido o desconocido. Cuando n es desconocido, el número de veces que debe repetirse el cuerpo del bucle estará condicionado por una expresión lógica.


Un bucle no es más que una serie de instrucciones que se repiten.


A la hora de utilizar un bucle, sea del tipo que sea, debemos ir con cuidado y pensar cuando debe acabar ya que si no tuviéramos en cuenta esto podríamos entrar en un bucle sin fin, iríamos repitiendo las mismas líneas teniendo que abortar la aplicación, para poder finalizar la ejecución del programa.

Por esto, es de suma importancia que pensemos, antes de hacer nada, en qué momento, cómo, dónde y por qué debe acabar el bucle.

7.3.1. Bucle "while"

Es la sentencia de bucle más sencilla, y sin embargo es tremendamente potente.

Sintaxis:

while () ;

La sentencia o el grupo de sentencias es ejecutado repetidamente mientras la condición sea verdadera, ("while" en inglés significa "mientras").

Si no se especifica condición se asume que es "true", y el bucle se ejecutará indefinidamente.

Si la primera vez que se evalúa la condición resulta falsa, la/s sentencia/s no se ejecutarán ninguna vez.

Por ejemplo:

while (x < 100) x = x + 1;

Se incrementará el valor de x mientras x sea menor que 100.


Este ejemplo puede escribirse, usando el C con propiedad y elegancia, de un modo más compacto:

while (x++ < 100);

Aquí vemos el uso de una sentencia nula, observa que el bucle simplemente se repite, y la sentencia ejecutada es ";", es decir, nada.

7.3.2. Bucle "do while"

Esta sentencia va un paso más allá que el "while".

Sintaxis:

do while();

La/s sentencia/s es ejecutada repetidamente mientras la condición resulte verdadera.

Si no se especifica condición se asume que es "true", y el bucle se ejecutará indefinidamente.

A diferencia del bucle "while", la evaluación se realiza después de ejecutar la sentencia, de modo que se ejecutará al menos una vez.

Por ejemplo:

do

x = x + 1;

while (x < 100);

Se incrementará el valor de x hasta que x valga 100.

7.3.3. Bucle "for"

Por último, el bucle "for", es el más elaborado.

Sintaxis:

for ( []; [] ; [] )


La/s sentencia/s es ejecutada repetidamente hasta que la evaluación de la condición resulte falsa.

Antes de la primera iteración se ejecutará la iniciación del bucle, que puede ser una expresión o una declaración.

En este apartado se iniciarán las variables usadas en el bucle. Estas variables pueden ser declaradas en este punto, pero en ese caso tendrán validez sólo dentro del bucle "for".

Después de cada iteración se ejecutará el incremento de las variables del bucle.

Todas las expresiones son opcionales, si no se especifica la condición se asume que es verdadera.

Por ejemplo:

for (int i = 0; i < 100; i = i + 1);

Como las expresiones son opcionales, podemos simular bucles "while":

for(;i < 100;) i = i +1;

for(;i++ < 100;);

O bucles infinitos:

for(;;);

7.4. Etiquetas

Los programas C y C++ se ejecutan secuencialmente, aunque esta secuencia puede ser interrumpida de varias maneras.

Las etiquetas son la forma en que se indica al compilador en qué puntos será reanudada la ejecución de un programa cuando haya una ruptura del orden secuencial.

7.4.1. Etiquetas de identificación


Las etiquetas de identificación sirven como puntos de entrada para la sentencia de salto "goto".

Sintaxis:

:

Estas etiquetas tienen el ámbito restringido a la función dentro de la cual están definidas.

Veremos su uso con más detalle al analizar la sentencia "goto".

7.4.2. Etiquetas "case" y "default"

Estas etiquetas se circunscriben al ámbito de la sentencia "switch", y se verá su uso cuando estudiemos ese apartado.

Sintaxis:

switch()

{

case : [][break;]

. . .

[default: []]

}

7.5. Sentencias de Selección

Las sentencias de selección permiten controlar el flujo del programa, seleccionando distintas sentencias en función de diferentes valores.

7.5.1. Sentencia "if...else"

Implementa la ejecución condicional de una sentencia.

Sintaxis:


if () ;

if () ; else ;

Si la condición es "true" se ejecutará la sentencia1, si es "false" se ejecutará la sentencia2.

El "else" es opcional, y no pueden insertarse sentencias entre la sentencia1 y el "else".

Se pueden declarar variables dentro de la condición.

Por ejemplo:

if ( int val = func(arg))...

En este caso, la variable "val" sólo estará accesible dentro del ámbito de la sentencia "if" y, si existe, del "else".

7.5.2. Sentencia "switch"

Cuando se usa la sentencia switch el control se transfiere al punto etiquetado con el "case" cuya expresión constante coincida con el valor de la variable del "switch".

A partir de ese punto todas las sentencias serán ejecutadas hasta el final del "switch", es decir hasta llegar al "}". Esto es así porque las etiquetas sólo marcan los puntos de entrada después de una ruptura de la secuencia de ejecución, pero no marcan las salidas.

Esta característica nos permite ejecutar las mismas sentencias para varias etiquetas distintas, y se puede eludir usando la sentencia de ruptura "break" al final de las sentencias incluidas en cada "case".

Si no se satisface ningún "case", el control parará a la siguiente sentencia después de la etiqueta "default". Esta etiqueta es opcional y si no aparece se abandonará el "switch".

No te preocupes, con un ejemplo se aclarará.

Sintaxis:

switch ()

{


case : [] [break;]

. . .

[default : []]

}

Por ejemplo:

switch(letra)

{

case 'a':

case 'e':

case 'i':

case 'o':

case 'u':

EsVocal = true;

break;

default:

EsVocal = false;

}

En este ejemplo letra es una variable de tipo "char" y EsVocal de tipo "bool". Si el valor de entrada en el "switch" corresponde a una vocal, EsVocal saldrá con un valor verdadero, en caso contrario, saldrá con un valor falso.

El ejemplo ilustra el uso del "break", si letra es 'a', se cumple el primer "case", y la ejecución continúa en la siguiente sentencia, ignorando el resto de los "case" hasta el "break".

Otro ejemplo:

Menor1 = Menor2 = Menor3 = Mayor3 = false;

switch (numero)

{

case 0:

Menor1 = true;

case 1:


Menor2 = true;

case 2:

Menor3 = true;

break;

default:

Mayor3 = true;

}

Veamos qué pasa en este ejemplo si número vale 1.

Directamente se reanuda la ejecución en "case 1:", con lo cual Menor2 tomará el valor "true", lo mismo pasará con Menor3.

Después aparece el "break" y se abandona el "switch".

7.6. Sentencias de salto

Las sentencias de salto permiten romper la ejecución secuencial de un programa.

7.6.1. Sentencia de ruptura "break"

El uso de esta sentencia dentro de un bucle pasa el control a la primera sentencia después de la sentencia de bucle.

Un ejemplo de aplicación es dentro de la sentencia "switch".

Sintaxis:

break

Ejemplo:

y = 0;

x = 0;

while (x < 1000)

{

if (y == 1000) break;


y++;

}

x = 1;

En este ejemplo el bucle no terminaría nunca si no fuera por la línea del "break", ya que x no cambia. Después del "break" el programa continuaría en la línea "x = 1".

7.6.2. Sentencia “continue"

El uso de la sentencia continue dentro de un bucle permite pasar el control al final de la sentencia de bucle, justo al punto donde se evalúa la condición para la permanencia en el bucle.

Sintaxis:

continue

Ejemplo:

y = 0;

x = 0;

while (x < 1000)

{

x++;

if (y >= 100) continue;

y++;

}

En este ejemplo la línea "y++" sólo se ejecutaría mientras "y" sea menor que 100, en cualquier otro caso el control pasa a la línea "}", con lo que el bucle volvería a evaluarse.

7.6.3. Sentencia de salto "goto" ( NO se usa en esta materia)


Con el uso de la sentencia goto el control del programa se transfiere directamente al punto etiquetado con el identificador especificado. Esta NO SE USA en nuestro curso, ya que el "goto" es un mecanismo que está en guerra permanente, y sin cuartel, con la programación estructurada.

En caso de que el alumno utilice esta sentencia ,consideraremos que está mal.

7.6.4. Sentencia de retorno "return"

La sentencia return sale de la función donde se encuentra y devuelve el control a la rutina que la llamó, opcionalmente con un valor de retorno.

Sintaxis:

return []

Ejemplo:

int Paridad(int x)

{

if (x % 2) return 1;

return 0;

}

Este ejemplo ilustra la implementación de una función que calcula la paridad de un parámetro. Si el resto de dividir el parámetro entre 2 es distinto de cero, implica que el parámetro es impar, y la función retorna con valor 1. El resto de la función no se ejecuta. Si por el contrario el resto de dividir el parámetro entre 2 es cero, el parámetro será un número par y la función retornará con valor cero.

7.6.5. Sobre las sentencias de salto y la programación estructurada

En general, NO ES BUENA NORMA USAR LAS SENTENCIAS DE SALTO. Lo dicho para la sentencia "goto" es válido en general para todas las sentencias de salto, salvo el "return" y el "break", este último tiene un poco más de tolerancia, sobre todo en las sentencias "switch", donde resulta imprescindible.

7.7. Comentarios


Los comentarios ayudan a seguir el funcionamiento del programa durante la depuración o en la actualización del programa, además de documentarlo.

No se trata propiamente de un tipo de sentencias, pero me parece que es el lugar adecuado para introducir este concepto.

En C pueden introducirse comentarios en cualquier parte del programa, Los comentarios en C se delimitan entre /* y */, cualquier cosa que escribamos en su interior será ignorada por el compilador, sólo está prohibido su uso en el interior de palabras reservadas o en el interior de identificadores.

Por ejemplo:

main(/*Sin argumentos*/void) está permitido

ma/*función*/in(void) es ilegal

La función de los comentarios es aclarar y documentar, no entorpecer el código.

En C++ se ha incluido otro tipo de comentarios, que empiezan con //. Estos comentarios no tienen marca de final, sino que terminan cuando termina la línea.

Por ejemplo:

void main (void) // Esto es un comentario

{

}

Las llaves {} no forman parte del comentario.

7.8. Ejercicios con sentencias

1) Mostrar los sucesivos valores de la variable x en los siguientes bucles:

a)

int x=0;

while(x < 5) x += 2;

0,2,4,6

0,2,4

0,2,4,6,8


b)

int x=10;

do x++; while(x < 10);

10

10,11

11

c)

bool salir = false;

int x = 13;

while(!salir) {

x++;

salir = x%7;

}

13,14

13,14,15

13

d)

int x = 6;

do {

switch(x%3) {

case 0: x=10; break;

case 1: x=17; break;

case 2: x=5; break;

}

} while(x != 5);

6,10,17

6,10,17,5

6,10,17,10,5


e)

int x=0, y=0;

do {

if(x>4) { x %= 4; y++; }

else x++;

} while(y < 2);

0,1,2,3,4,5,1,2,3,4,5,1

0,1,2,3,4,5,1,2,3,4,5

0,1,2,3,4,5,1,2,3,4,5,1,2

f)

int x=0, y=1;

while(y != 3) {

x++;

if(x

CAPITULO 8. Funciones

Las funciones son un conjunto de instrucciones que realizan una tarea específica. En general toman unos valores de entrada, llamados parámetros y proporcionan un valor de salida o valor de retorno; aunque tanto unos como el otro pueden no existir.

Al igual que con las variables, las funciones pueden declararse y definirse.

Una declaración es simplemente una presentación.

Una definición contiene las instrucciones con las que realizará su trabajo la función.

8.1. Declaración de función. El Prototipo.

La declaración de una función se realiza mediante una sentencia conocida con el nombre de prototipo.

Un prototipo consiste en una definición de la función sin cuerpo y terminado con un ";".

Sintaxis:

func ();

Por ejemplo:

int Intervalo(int a, int b); /*Prototipo de la función Intervalo */

El prototipo sirve para indicar al compilador los tipos de datos de retorno y los tipos de datos de los parámetros que recibe la función, de modo que


compruebe si son del tipo correcto cada vez que se use esta función dentro del programa, o para hacer las conversiones de tipo cuando sea necesario.

Los nombres de los parámetros son opcionales, y se incluyen como documentación y ayuda en la interpretación y comprensión del programa.

El ejemplo de prototipo anterior sería igualmente válido y se podría poner como:

int Intervalo (int,int); /*Prototipo de la función Intervalo */

El prototipo del ejemplo indica que en algún lugar del programa se definirá una función "Intervalo" que admite dos parámetros de tipo "int" y que devolverá un valor de tipo "int". No es necesario escribir nombres para los parámetros, ya que el prototipo no los usa. En otro lugar del programa habrá una definición completa de la función.


Normalmente aconsejo:

Copiar el prototipo de la función y pegar como una definición eliminando el “;” del final de línea de esta manera no se comenten errores.

PERO si hacemos esto utilizando la última forma de indicar el prototipo de la función (es decir sin dar nombres a las variables) no sirve, ya que en la definición de la función necesitamos dar un nombre a la variable para poder usarla.

Las funciones se declaran como prototipos dentro del programa, o se incluyen estos prototipos desde un fichero externo, (usando la directiva "#include")

La definición de la función se hace más adelante; lo habitual es hacerlo después de la función "main".

Los programas complejos se escriben normalmente usando varios ficheros fuente. Estos ficheros se compilan separadamente y se enlazan juntos. Esto es una gran ventaja durante el desarrollo y depuración de grandes programas, ya que las modificaciones en un fichero fuente sólo nos obligarán


a compilar ese fichero fuente, y no el resto, con el consiguiente ahorro de tiempo.

La definición de las funciones puede hacerse dentro de los ficheros fuente o enlazarse desde librerías precompiladas. La diferencia entre una declaración y una definición es que la definición posee un cuerpo de función.


En C++ es obligatorio el uso funciones prototipo, y aunque en C no lo es, resulta altamente recomendable.

8.1.1. Funciones extern y static

Hay funciones que son "extern" por defecto. Esto quiere decir que son accesibles desde cualquier punto del programa, aunque se encuentren en otros ficheros fuente del mismo programa.

En contraposición las funciones declaradas "static" sólo son accesibles dentro del fichero fuente donde se definen.

8.2. Definición de función

La definición de una función se compone de las siguientes secciones, aunque pueden complicarse en ciertos casos:

Tipo de almacenamiento

Tipo de valor de retorno

Modificadores opcionales

Nombre de la función

Lista de parámetros (entre paréntesis)

Cuerpo de la función

8.2.1. Tipo de almacenamiento


Opcionalmente, una palabra que especifique el tipo de almacenamiento, puede ser "extern" o "static". Si no se especifica es "extern".

8.2.2. Tipo de valor de retorno

El tipo del valor de retorno puede ser "void" si no necesitamos valor de retorno.

En C, si no se establece, por defecto será "int", aunque en general se considera de mal gusto omitir el tipo de valor de retorno.

En C++ es obligatorio indicar el tipo del valor de retorno.

8.2.3. Modificadores opcionales

Los modificadores tienen un uso muy específico, de momento no entraremos en este particular, lo veremos en capítulos posteriores.

8.2.4. Nombre de la función

Para el nombre de la función, resulta muy útil y recomendable, poner nombres que indiquen, lo más claramente posible, qué es lo que hace la función, y que permitan interpretar qué hace el programa con sólo leerlo. Cuando se precisen varias palabras para conseguir este efecto existen varias reglas aplicables de uso común. Una consiste en separar cada palabra con un "_", la otra, que yo prefiero, consiste en escribir la primera letra de cada palabra en mayúscula y el resto en minúsculas.

Por ejemplo, si hacemos una función que busque el número de teléfono de una persona en una base de datos, podríamos llamarla "busca_telefono" o "BuscaTelefono".

8.2.5. Lista de parámetros

Entre paréntesis se deben incluir las declaraciones de parámetros separados por coma (,).

Los parámetros de una función son los valores de entrada (y en ocasiones también de salida).

Para la función se comportan exactamente igual que variables, y de hecho cada parámetro se declara igual que una variable.


Una lista de parámetros es un conjunto de declaraciones de parámetros separados con comas. Puede tratarse de una lista vacía.

En C es preferible usar la forma "func(void)" para listas de parámetros vacías.

En C++ este procedimiento se considera obsoleto, se usa simplemente "func()".

8.2.6. Cuerpo de función

El cuerpo de función representa el código que será ejecutado cuando se llame a la función.

El cuerpo de la función se encierra entre llaves "{}"

8.3. Función main()

Una función muy especial es la función "main".

Se trata de la función de entrada, y debe existir SIEMPRE. Será la función que tome el control cuando se ejecute un programa en C.

Existen reglas para el uso de los valores de retorno y de los parámetros de la función "main", pero de momento la usaremos como "int main()" o "int main(void)", con un entero como valor de retorno y sin parámetros de entrada.

En Linux la función main() DEBERÁ retornar un valor sino el compilador indicará un error.

Ejemplo de función:

/* Esta función devuelve el mayor de dos números */

# include


int Mayor (int a, int b); /* Prototipo de función Mayor */


int main()

{int x,y; /*variables locales x e y*/

cout x;

cout y;

cout

Las variables declaradas fuera de las funciones, normalmente antes de definir las funciones, en la zona donde se declaran los prototipos, serán accesibles desde todas las funciones.

Diremos que esas variables serán globales o de ámbito global.

Por ejemplo:

int EnteroGlobal; // Declaración de una variable global

int Funcion1(int a); // Declaración de un prototipo

int main()

{ // Declaración de una variable local de main:

int EnteroLocal;

// Acceso a una variable local:

EnteroLocal = Funcion1(10);

// Acceso a una valiable global:

EnteroGlobal = Funcion1(EnteroLocal);

return 0;

}

int Funcion1(int a)

{ char CaracterLocal; // Variable local de funcion1

// Desde aquí podemos acceder a

// EnteroGlobal, y también a CaracterLocal

// pero no a EnteroLocal

if (EnteroGlobal != 0)

return a //EnteroGlobal;

else

return 0;

}

De modo que en cuanto a los ámbitos locales tenemos varios niveles:

funcion(parámetros) // (1)


{

var; // (2)

for( var;...) // (3)

...

return var;

}

(1) los parámetros tienen ámbito local a la función.

(2) las variables declaradas aquí, también.

(3) las declaradas en bucles, son locales al bucle.

Es una buena costumbre inicializar las variables locales.

Cuando se trate de variables estáticas se inicializan automáticamente a cero.

8.5. Funciones cin y cout

8.6. cout

Aunque este puede no ser el lugar adecuado para hacer referencia a estas funciones ya que recién estamos empezando explicaremos algunos detalles de como operan las mismas y de algunas alternativas.Tanto cout como cin son funciones que están incluidas en la biblioteca iostream.

La función "cout

cout z;

cout

{char z[10];

cout z;

cout


int main(void)

{

char msg[TAMANIO];

cout

return 0;

}

Veamos como se vería la ejecución y el ingreso..

Ingrese un nro que llamamos x:

4 23 235

x vale :4

lo que quedó en el buffer es: 23 235

Como vemos en la ejecución solo el nro. 4 fué asignado a x , el resto luego del espacio quedó en el buffer y en caso de que se realice otro cin pordía terminar con cualquier valor inesperado

8.6. Ejercicios 1) En el siguiente ejemplo, ¿qué ámbito tiene cada una de las variables?:

float s,i;

int main()

{

int x;

x=10;

for(int i=0; i0) {

i *= 10.3;

x--;

}

return 0;

a) La variable de tipo float s tiene ámbito


global

local en main

local en bucle

b) La variable de tipo int i tiene ámbito

global

local en main

local en bucle

c) La variable de tipo float i tiene ámbito

global

local en main

local en bucle

d) La variable de tipo int x tiene ámbito

global

local en main

local en bucle

2)¿Cuáles de los siguientes prototipos son válidos?

a) Calcular(int, int, char r);

Sí No

b) void Invertir(int, unsigned char)

Sí No

c) void Aumentar(float valor);

Sí No

d) float Negativo(float int);

Sí No


e) int Menor(int, int, int);

Sí No

f) char Menu(int opciones);

Sí No

3) Preguntas sobre la estructura de un programa.

a) ¿Entre qué zonas harías las declaraciones de variables globales?

Antes de la zona de las directivas del preprocesador

Entre la zona de las directivas del preprocesador y las declaraciones de prototipos

Después de la definición de la función "main"

b) ¿Qué aparecería normalmente justo después de la definición de la función "main"?

Las directivas del preprocesador

Los prototipos de funciones

Las definiciones de funciones

4) Identifique las siguientes partes de las funciones:

Encabezado o Definición de la Función.

Cuerpo de la Función ó Enunciados de la Función.

Prototipo de la Función.

Argumentos de la Función.

Tipos de Argumentos de la Función.

Tipo de Argumento retornado por la Función.

5-Escribir el código fuente de un programa que tenga una función que reciba un entero y devuelva P si es POSITIVO y N si es NEGATIVO.-


6-Escribir el código fuente de un programa que desde main se llame a una función que recibe un par de argumentos enteros y devuelve un valor booleano, siendo TRUE si el mayor argumento es divisible por el menor o FALSE si el mayor argumento no es divisible por el mayor.

7-Escribir el código fuente de un programa que desde main se llame a una función que recibe como argumento dos números reales, y retorna el menor que es mostrado desde main.

8-Escribir el código fuente de un programa que desde main se llame a una función pasando como argumento un entero, esta función calcula la serie de Fibonacci y retorna la suma de los términos que son mostrado desde main. La cantidad de términos a sumar está dada por el argumento que recibe la función.

9-Escribir el código fuente de un programa que permita definir tres funciones, una que detecta si un carácter es una Vocal , otra que detecta si es Consonante y otra si es un Dígito, todas devuelven el valor TRUE o FALSE y desde main se debe indicar si el tipo de char ingresado es : vocal, consonante ó dígito.

Se puede suponer en principio para simplificar que los caracteres ingresados son TODO minúsculas. Sugerencia Mirar la tabla de caracteres ASCII.

10-Escribir el código fuente de un programa que desde main se llame a una función la cual recibe un par de números y retorna el resto de la división del mayor dividido el menor. Sugerencia usar el operador () ? : .

11-Escribir el código fuente de un programa que desde main se llame a una función que recibe como argumento un nro. entero, calcula y muestra desde la misma función los divisores de ese nro. retornando un valor TRUE, si el nro no es primo y FALSE si es primo.

12-Se dice que un número entero es perfecto, si la suma de sus divisores incluyendo el 1 es igual a sí mismo.

Ej: 6 = 3 + 2+ 1 , ver que 3,2,1 son divisores de 6.

Escribir una función que reciba un entero, y retorne TRUE para el caso de que el número sea “entero perfecto”.


13-Escribir el código fuente de un programa que desde main se llame a una función menú que no recibe ningún argumento y que retorne la opción de menú elegida, ésta se mostrará desde main. Los ítems del menú deberían ser por ej. 1,2,3,4 y 5 para salir, o A,B, y F para Finalizar. Controlar que sólo se salga con la op

apunte lenguaje c - universidad nacional de misionesapunte lenguaje c. parte 1. - 11 - 2.2.4....

Documents