\chapter[Tipos]{Tipos de datos, constantes, operadores y expresiones}

\section{Nombre de variables, tipos de datos}


En nuestro primer ejemplo escribíamos un texto en pantalla, pero este texto estaba prefijado dentro de nuestro programa. Esto no es lo habitual: normalmente los datos que maneje nuestro programa serán el resultado de alguna operación matemática o de cualquier otro tipo. Por eso, necesitaremos un espacio en el que ir almacenando valores temporales y resultados.

En casi cualquier lenguaje de programación podremos reservar esos ``espacios'', y asignarles un nombre con el que acceder a ellos. Esto es lo que se conoce como ``variables''.

Por ejemplo, si queremos que el usuario introduzca dos números y el ordenador calcule la suma de ambos números y la muestre en pantalla, necesitaríamos el espacio para almacenar al menos esos dos números iniciales (en principio, para la suma no sería imprescindible, porque podemos mostrarla en pantalla nada más calcularla, sin almacenarla previamente en ningún sitio).  Los pasos a dar serían los siguientes:

\begin{itemize}
    \item Pedir al usuario que introduzca un número.
    \item Almacenar ese valor que introduzca el usuario (por ejemplo, en un espacio de memoria al que podríamos asignar el nombre ``primerNumero'').
    \item Pedir al usuario que introduzca otro número.
    \item Almacenar el nuevo valor (por ejemplo, en otro espacio de memoria llamado segundoNumero)
    \item Mostrar en
pantalla el resultado de sumar primerNumero y segundoNumero.
\end{itemize}

Pues bien, en este programa estaríamos empleando dos variables llamadas primerNumero y segundoNumero. Cada una de ellas sería un espacio de memoria capaz de almacenar un número.

Los nombres de las variables en C siempre comienzan con una letra del alfabeto  o el carácter \verb"_", seguido de letras, números y el mismos carácter \verb"_". Así tendremos que nombres validos de variables son:

\verb"Temperatura"
\verb"Calor"
\verb"Tiempo_1"
\verb"Tiempo_2"

El espacio de memoria que hace falta ``reservar'' será distinto según la precisión que necesitemos para ese número, o según lo grande que pueda llegar a ser dicho número. Por eso, tenemos disponibles diferentes ``tipos de variables''.

Por ejemplo, si vamos a manejar números sin decimales (``números enteros'') de como máximo 9 cifras, nos interesaría el tipo llamado int (abreviatura de integer, que es entero en inglés). Este tipo de datos consume un espacio de memoria de 4 bytes (1 Mb es cerca de 1 millón de bytes). Si no necesitamos guardar datos tan grandes (por ejemplo, si nuestros datos va a ser números inferiores a 1.000), podemos emplear el tipo de datos llamado short (entero corto).

Los tipos de datos numéricos disponibles en C son los siguientes:

\tiny {
 \begin{center}
\begin{tabular}{|c|c|c|c|c|c|} \hline
         & Admite    &Valor &Valor & &\\
  Nombre & decimales & min & max & Presición & ocupa\\
  \hline
char & no & -128 & 127 &  -&  1 byte \\
unsigned char & no & 0 & 255 &  -&  1 byte \\
short int & no & -32768 & 32767 & - & 2 bytes \\
int & no & -2147483648 & 2147483647 &  - & 4 bytes \\
long int & no & -9223372036854775808 & 9223372036854775807 &  - &  8  bytes \\
float &  sí & 1.401298E-45 &  3.402823E38 &  6-7 cifras &  4 bytes\\
double & sí & 4.94065645841247E-324 &  1.79769313486232E308 &
14-15 cifras & 8 bytes\\ \hline
\end{tabular}
\end{center}}
\normalsize

La forma de declarar variables de estos tipos es la siguiente:

\begin{verbatim}
	int numeroEntero;    // La variable numeroEntero será un número de
	tipo "int" short distancia;     // La variable distancia guardará
	números "short" long gastos;         // La variable gastos es de
	tipo "long" byte edad;           // Un entero de valores
	"pequeños" float porcentaje;    // Con decimales, unas 6 cifras de
	precisión double numPrecision; // Con decimales y precisión de unas 14 cifras
\end{verbatim}

\noindent
(es decir, primero se indica el tipo de datos que guardará la variable y después el nombre que queremos dar a la variable).

Se pueden declarar varias variables del mismo tipo a la vez:

\begin{verbatim}
	int primerNumero, segundoNumero;    // Dos enteros
\end{verbatim}

\noindent
y también se puede dar un valor a las variables a la vez que se declaran:

\begin{verbatim}
	int a = 5;            // "a" es un entero, e inicialmente vale 5
	short b=-1, c, d=4;   // "b" vale -1, "c" vale 0, "d" vale 4
\end{verbatim}

Los nombres de variables pueden contener letras y números (y algún otro símbolo, como el de subrayado, pero no podrán contener otros muchos símbolos, como los de las distintas operaciones matemáticas posibles, ni podrán tener vocales acentuadas o eses).

Un ejemplo sencillo de declaración de tipos es:
\begin{verbatim}
/* 
 * File:   tipos.c
 * Author: felix
 *
 * Created on 22 de agosto de 2011, 19:36
 */


/*
 * Este programa muestra ejemplo utilizando los diferentes tipos de datos 
 * basicos en C
 */
# include <stdio.h>

int main() {
    
    // Tipo de dato Entero
    
    int a = 1;
    unsigned int b = 10;
    signed long c = 5;
    signed long long d = 10000000;   
    
    printf("a = %d \n", a);
    
    // Tipo de dato Flotante
    
    float e;
    double f = 1e23;
    double g = 3.1416;
    float h = 4e-9;
    double i = -78;
    
    printf("%e en flotante es %10.10f en entero es %d\n", h, h, h);
    
    // tipo de dato caracter
    
    char j;
    char k = 's';
    char l = 48;
    
    printf("%c = %d en ascii \n", k, k);
 
    return (0);
}
\end{verbatim}

\noindent Ver tipos.c

Vamos a aplicarlo con un ejemplo sencillo en C que sume dos números:

\begin{verbatim}
/* 
 * File:   suma2.c
 * Author: felix
 *
 * Created on 13 de febrero de 2012, 12:18
 */

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char** argv) {

     int primerNumero = 56;    // Dos enteros con valores prefijados
     int segundoNumero = 23;

     printf( "La suma es: %d\n" , primerNumero+segundoNumero );
    
    return (EXIT_SUCCESS);
}

\end{verbatim}


Hay una importante diferencia entre las dos ordenes printf: la primera contiene comillas, para indicar que ese texto debe aparecer tal cual, mientras que la segunda no contiene comillas, por lo que no se escribe el texto primerNumero + segundoNumero, sino que se intenta calcular el valor de esa expresión (en este caso, la suma de los valores que en ese momento almacenan las variables primerNumero y segundoNumero, 56+23 = 89).

Lo correcto habría sido que los datos no los hubiéramos escrito nosotros en el programa, sino que fuera el usuario quien los hubiera introducido, pero esto es algo relativamente complejo cuando creamos programas en modo texto en C (al menos, comparado con otros lenguajes anteriores), y todavía no tenemos los conocimientos suficientes para crear programas en modo gráfico, así que más adelante veremos cómo podría ser el usuario de nuestro programa el que introdujese los valores que desea sumar.

Tenemos otros dos tipos básicos de variables, que no son para datos numéricos:
\noindent
char. Será una letra del alfabeto, o un dígito numérico, o un símbolo de puntuación y ocupa 1 byte. Estos ocho tipos de datos son lo que se conoce como tipos de datos primitivos (porque forman parte del lenguaje estándar, y a partir de ellos podremos crear otros más complejos). El código ASCCI se puede ver en la tabla \ref{tab:c2_codigoasccii}

\begin{table}[htdp]
\caption{Códigos ASCII}
\begin{center}
\begin{tabular}{||c|c|c||c|c|c||c|c|c||}
	\hline
	Dec	&	Hex	&	Rep	&	Dec	&	Hex	&	Rep	&	Dec	&	Hec	&	Rep	\\
	\hline	32	&	20	&	esp	&	64	&	40	&	@	&	96	&	60	&	`	\\
	33	&	21	&	!	&	65	&	41	&	A	&	97	&	61	&	a	\\
	34	&	22	&		&	66	&	42	&	B	&	98	&	62	&	b	\\
	35	&	23	&	\#	&	67	&	43	&	C	&	99	&	63	&	c	\\
	36	&	24	&	\$	&	68	&	44	&	D	&	100	&	64	&	d	\\
	37	&	25	&	\%	&	69	&	45	&	E	&	101	&	65	&	e	\\
	38	&	26	&	\&	&	70	&	46	&	F	&	102	&	66	&	f	\\
	39	&	27	&	'	&	71	&	47	&	G	&	103	&	67	&	g	\\
	40	&	28	&	(	&	72	&	48	&	H	&	104	&	68	&	h	\\
	41	&	29	&	)	&	73	&	49	&	I	&	105	&	69	&	i	\\
	42	&	2A	&	*	&	74	&	4A	&	J	&	106	&	6A	&	j	\\
	43	&	2B	&	+	&	75	&	4B	&	K	&	107	&	6B	&	k	\\
	44	&	2C	&	,	&	76	&	4C	&	L	&	108	&	6C	&	l	\\
	45	&	2D	&	-	&	77	&	4D	&	M	&	109	&	6D	&	m	\\
	46	&	2E	&	.	&	78	&	4E	&	N	&	110	&	6E	&	n	\\
	47	&	2F	&	/	&	79	&	4F	&	O	&	111	&	6F	&	o	\\
	48	&	30	&	0	&	80	&	50	&	P	&	112	&	70	&	p	\\
	49	&	31	&	1	&	81	&	51	&	Q	&	113	&	71	&	q	\\
	50	&	32	&	2	&	82	&	52	&	R	&	114	&	72	&	r	\\
	51	&	33	&	3	&	83	&	53	&	S	&	115	&	73	&	s	\\
	52	&	34	&	4	&	84	&	54	&	T	&	116	&	74	&	t	\\
	53	&	35	&	5	&	85	&	55	&	U	&	117	&	75	&	u	\\
	54	&	36	&	6	&	86	&	56	&	V	&	118	&	76	&	v	\\
	55	&	37	&	7	&	87	&	57	&	W	&	119	&	77	&	w	\\
	56	&	38	&	8	&	88	&	58	&	X	&	120	&	78	&	x	\\
	57	&	39	&	9	&	89	&	59	&	Y	&	121	&	79	&	y	\\
	58	&	3A	&	:	&	90	&	5A	&	Z	&	122	&	7A	&	z	\\
	59	&	3B	&	;	&	91	&	5B	&	[	&	123	&	7B	&	\{	\\
	60	&	3C	&	<	&	92	&	5C	&		&	124	&	7C	&	|	\\
	61	&	3D	&	=	&	93	&	5D	&	]	&	125	&	7D	&	\}	\\
	62	&	3E	&	>	&	94	&	5E	&		&	126	&	7E	&		\\
	63	&	3F	&	?	&	95	&	5F	&		&		&		&		\\
	\hline
\end{tabular}
\end{center}
\label{tab:c2_codigoasccii}
\end{table}%


\section [Operadores y expresiones]{Operadores y expresiones; aritméticos, lógicos, a nivel de bits y de asignación}

\subsection{Operaciones aritméticas básicas}

Hay varias operaciones matemáticas que son frecuentes. Veremos cómo expresarlas en  C, y también veremos otras operaciones menos frecuentes. Las más comunes son:

\begin{tabular}{|c|c|}
  \hline
  % after \\: \hline or \cline{col1-col2} \cline{col3-col4} ...
  Operación matemática & Símbolo correspondiente\\
  \hline
  Suma & + \\
  Resta & - \\
  Multiplicación & * \\
  División & / \\
  \hline
\end{tabular}

El siguiente código muestra una implementación para el manejo de operaciones.
\begin{verbatim}
/* 
 * File:   expresiones_aritmeticas.c
 * Author: felix
 *
 * Created on 22 de agosto de 2011, 19:48
 */

#include <stdio.h>
#include <stdlib.h>

/*
 * 
 */
int main() {
    
    float a = 10, b = 30, c;
    
    // Suma
    
    c = a + b;
    
    printf("La suma de %f y %f es %f\n", a, b, c);

    // Resta
    
    c = a - b;
    
    printf("La resta de %f y %f es %f\n", a, b, c);
    
    // Multiplicacion
    
    c = a * b;
    
    printf("La multiplicacion de %f y %f es %f\n", a, b, c);
    
    // Modulo. Calcula el reciduo de la division entera entre dos numeros
    
    int d = 10, e = 3, f;
    
    f = d % e;

    printf("El residuo de dividir %d entre %d es %d\n", d, e, f);

    return (0);
}
\end{verbatim}

Hemos visto un ejemplo de cómo calcular la suma de dos números; las otras operaciones se emplearían de forma similar y en el ejemplo anterior se muestra.

Otras operaciones matemáticas menos habituales. Esas son las operaciones que todo el mundo conoce, aunque no haya manejado computadoras. Pero hay otras operaciones que son frecuentes en los lenguajes de programación y no tanto para quien no ha manejado computadoras, pero que aun así deberíamos ver:

\begin{tabular}{|c|c|}
  \hline
  % after \\: \hline or \cline{col1-col2} \cline{col3-col4} ...
  Operación  & Símbolo \\
  \hline
  Resto de la división &  \% \\
  \hline
\end{tabular}

El resto de la división también es una operación conocida. Por ejemplo, si dividimos 14 entre 3 obtenemos 4 como cociente y 2 como resto, de modo que el resultado de  14 \% 3  sería 2. El siguiente ejemplo muestra como se aplica la operación de modulo o resto de la división y su diferencia con la división. Hay que recordar que la operación de modulo solamente se aplica en números enteros.

\begin{verbatim}
/* 
 * File:   division.c
 * Author: felix
 *
 * Created on 30 de agosto de 2011, 13:59
 */

#include <stdio.h>
#include <stdlib.h>

int main() {
    
    int Dividendo, Divisor, Cociente, Residuo;
    
    Dividendo = 120;
    Divisor = 33;
    Cociente = Dividendo/Divisor;
    Residuo = Dividendo%Divisor;
    
    printf("El resultado de dividir %d entre %d es %d y sobra %d\n", 
            Dividendo, Divisor, Cociente, Residuo);
    
    return (0);
}
\end{verbatim}

Otra aplicación del modulo o resto de la división es el calculo de múltiplos de un número, así por ejemplo cuando un numero $n$ es múltiplo de $m$ el resultado de la operación es cero 
$$
n\%m = 0
$$


\subsection{Incremento y asignaciones abreviadas}

Hay varias operaciones muy habituales, que tienen una sintaxis abreviada en  C. Por ejemplo, para sumar 2 a una variable a, la forma normal de conseguirlo sería:

a = a + 2;

pero existe una forma abreviada :

a += 2;

Al igual que tenemos el operador += para aumentar el valor de una variable, tenemos -= para disminuirlo, /= para dividirla entre un cierto número, *= para multiplicarla por un número, y así sucesivamente.  Por ejemplo, para multiplicar por 10 el valor de la variable ``b'' haríamos

b *= 10;



También podemos aumentar o disminuir en una unidad el valor de una variable, empleando los operadores de ``incremento'' (++) y de decremento (--). Así, para sumar 1 al valor de \textbf{a}, podemos emplear cualquiera de estas tres formas:

a = a +1; a += 1; a++;

Los operadores de incremento y de decremento se pueden escribir antes o después de la variable. Así, es lo mismo escribir estas dos líneas:

a++; ++a;

Pero hay una diferencia si ese valor se asigna a otra variable al mismo tiempo que se incrementa/decrementa:

int c = 5; int b = c++;

\noindent
da como resultado c = 6 y b = 5 (se asigna el valor a b antes de incrementar c) mientras que

int c = 5; int b = ++c;

\noindent
da como resultado c = 6 y b = 6 (se asigna el valor a b después de incrementar c).

Como ejemplo de aplicación tenemos el siguiente código en C, donde se aplican algunas de las expresiones de incremento.

\begin{verbatim}
/* 
 * File:   preincremento_postincremento.c
 * Author: felix
 *
 * Created on 23 de agosto de 2011, 8:28
 */

#include <stdio.h>

int main() {
    int c;
    
    c=5;
    printf("Post incremento\n");
    printf("%d\n", c);
    printf("%d\n", c++);
    printf("%d\n", c);

    c=5;
    
    printf("Pre incremento\n");
    printf("%d\n", c);
    printf("%d\n", ++c);
    printf("%d\n", c);

    c=5;
    printf("Post decremento\n");
    printf("%d\n", c);
    printf("%d\n", c--);
    printf("%d\n", c);

    c=5;
    
    printf("Pre decremento\n");
    printf("%d\n", c);
    printf("%d\n", --c);
    printf("%d\n", c);
    
    return (0);
}
\end{verbatim}

\subsection{Operaciones a nivel de bits}
Las operaciones a nivel de bits deberían ser habituales para los estudiantes de ciencias computacionales, pero quizás no tanto para quien no haya trabajado con el sistema binario. No entraré por ahora en más detalles, salvo poner un par de ejemplos para quien necesite emplear estas operaciones: para desplazar los bits de $a$ dos posiciones hacia la izquierda, usaríamos  $a << 2$; para invertir los bits de $c$ (complemento) usaríamos \verb"~"$c$;  para hacer una suma lógica de los bits de $d $ y $f$ sería  $d | f$. Estas operaciones son muy utilizadas por estudiantes de electrónica para poder realizar operaciones a nivel de lenguaje de máquina.

\begin{tabular}{|c|c|}
  \hline
  % after \\: \hline or \cline{col1-col2} \cline{col3-col4} ...
  Operación  & Símbolo \\
  \hline
  Desplazamiento de bits a la derecha & $>>$ \\
  Desplazamiento de bits a la derecha & $<<$ \\
  Desplazamiento rellenando con ceros & $>>>$ \\
  Producto lógico (and) & $\&$ \\
  Suma lógica (or) & $|$ \\
  Suma exclusiva (xor) & \verb"^" \\
  Complemento & \verb"~"  \\
  \hline
\end{tabular}

Para entender las operaciones and, or, exor y not es importante hacer uso de las tablas de verdad como se muestra enseguida.

\noindent And
\begin{tabular}{|c|c|c|}
  \hline
   x & y & x \& y \\
  \hline
  0 & 0 & 0 \\
  0 & 1 & 0 \\
  1 & 0 & 0 \\
  1 & 1 & 1\\
  \hline
\end{tabular}

\noindent Or
\begin{tabular}{|c|c|c|}
  \hline
   x & y & x  \verb"|" y \\
  \hline
  0 & 0 & 0 \\
  0 & 1 & 1 \\
  1 & 0 & 1 \\
  1 & 1 & 1\\
  \hline
\end{tabular}

\noindent Xor
\begin{tabular}{|c|c|c|}
  \hline
   x & y & x  \verb"^" y \\
  \hline
  0 & 0 & 0 \\
  0 & 1 & 1 \\
  1 & 0 & 1 \\
  1 & 1 & 0\\
  \hline
\end{tabular}

\noindent Not
\begin{tabular}{|c|c|c|}
  \hline
   x &  \verb"~" y \\
  \hline
  0 & 1 \\
  1 & 0 \\
  \hline
\end{tabular}



El siguiente programa es un ejemplo en C de como se utilizan las expresiones a nivel de bits

\begin{verbatim}
/* 
 * File:   Expresiones_bits.c
 * Author: felix
 *
 * Created on 13 de septiembre de 2011, 13:49
 */

#include <stdio.h>
#include <stdlib.h>

int main() {
    
    int mask = 0xFF;
    int a = 10, b = 8;
    
    // Operacion And  
    printf("AND a & b = %X\n", a&b);
    // Operacion Or   
    printf("OR  a | b = %X\n", a|b);
    // Operacion Xor    
    printf("XOR a ^ b = %X\n", a^b);
    // Operacion de complemento    
    printf("com   ~a = %X\n", (~a));
    
    printf("El entero mas grades es %u\n", ~0);
    
    return (0);
}
\end{verbatim}

\subsection{Operadores relacionales}

También podremos comprobar si entre dos números (o entre dos variables) existe una cierta relación del tipo ¿es a mayor que b? o ¿tiene a el mismo valor que b?. Los operadores que utilizaremos para ello son:

\begin{tabular}{|c|c|}
  \hline
  % after \\: \hline or \cline{col1-col2} \cline{col3-col4} ...
  Operación & Símbolo\\
  \hline
  Mayor que &  $>$ \\
  Mayor o igual que & $>=$\\
  Menor que & $<$ \\
  Menor o igual que & $<=$ \\
  Igual que & $==$ \\
  Distinto de & $!=$ \\
  \hline
\end{tabular}

Estas operaciones dan como resultado Cierto o Falso que en general se conoce como tipo Booleano. Sin embargo en C no existe tal tipo de datos y son remplazados por dos valores numéricos que son 0 para falso y 1 para verdadero. Esto da una posibilidad única a C, de tratar de manera indistinta expresiones lógicas y numéricas.

así, por ejemplo, para ver si el valor de una variable b es distinto de 5, escribiríamos algo parecido (veremos la sintaxis correcta un poco más adelante) a

\verb"    SI  b != 5 ENTONCES ... "

\noindent
o para ver si la variable a vale 70, sería algo como (nuevamente, veremos la sintaxis correcta un poco más adelante)

\verb"    SI  a == 70 ENTONCES ..."

Es muy importante recordar esta diferencia: para asignar un valor a una variable se emplea un único signo de igual, mientras que para comparar si una variable es igual a otra (o a un cierto valor) se emplean dos signos de igual.

Operadores lógicos. Podremos enlazar varias condiciones, para indicar qué hacer cuando se cumplan ambas, o sólo una de ellas, o cuando una no se cumpla. Los operadores que nos permitirán enlazar condiciones son:


\begin{tabular}{|c|c|}
  \hline
  % after \\: \hline or \cline{col1-col2} \cline{col3-col4} ...
  Operación & Símbolo \\
  \hline
  Y & \&\& \\
  O & $||$ \\
  No & ! \\
  \hline
\end{tabular}


Por ejemplo, la forma de decir si a vale 3 y b es mayor que 5, o bien a vale 7 y b no es menor que 4 en una sintaxis parecida a la de C (aunque todavía no es la correcta) sería:

\verb"    SI (a==3 && bb>5) || (a==7  && ! (b<4)) "

El siguiente es un ejemplo de como luce la implementación en C de las expresiones lógicas.

\begin{verbatim}
/* 
 * File:   Expresiones_logicas.c
 * Author: felix
 *
 * Created on 22 de agosto de 2011, 19:55
 */

#include <stdio.h>
#include <stdlib.h>

/*
 * Operadores Logicos 
 */
int main() {
    
    // == operador de igualdad en C
    // != operador de desigualdad
    // > mayor
    // < menor
    // >= mayor o igual
    // <= menor o igual 
    
    // && ( Y logico)
    // || (O logico)
    // ! (NO logico o negacion logica)
    
    int a = 10, b =30, c=5, d;
    
    printf("1 es cierto \n0 es falso\n\n");
    
    // And logico
    
    d = (a>b) && (b>c);
    
    printf("%d\n", d);

    // Or logico
    
    d = (a>b) || (b>c);
    
    printf("%d\n",  d);
      
    return (0);
}
\end{verbatim}


\subsection{Ejemplo}
Indique en que casos las siguientes sentencias son verdaderas o falsas dados los valores a=1 b = 2 y c = 5;

\begin{verbatim}
1.- d = (a*b) < (c-4);

2.- d = (a < b) && (c!=4);

3.- d = (a &b)>2;

4.- d = ((c *c) | 5) <=4;
\end{verbatim}

Las respuestas son false, true, false y false.

En virtud de que el resultado de las operaciones lógicas es 1 o 0, estos valores pueden ser introducidos dentro de expresiones aritméticas y representar un tipo de funciones a las que se llama discontinuas. Así por ejemplo la siguiente función es llamada función a pedazos y su definición es:

\begin{equation*}
	f(x) = \left \{
	\begin{matrix}
	si \hspace{1cm} x > 0 \hspace{1cm} x^2 \\
	si \hspace{1cm} no \hspace{1cm} x\\
	\end{matrix}
	\right .
\end{equation*}

\noindent
La implementación se muestra en el siguiente código donde además se hace una aplicación para determinar si una letra es mayúscula o minúscula.

\begin{verbatim}
/* 
 * File:   funcion_pedazos.c
 * Author: felix
 *
 * Created on 6 de septiembre de 2011, 12:46
 */

#include <stdio.h>
#include <stdlib.h>

int main() {
    
    double x = -3;
    
    double f = (x>=0)*x*x + (x<0)*x;
    printf("f(%f) = %f\n", x, f);

    x = 5;
    f = (x>=0)*x*x + (x<0)*x;
    printf("f(%f) = %f\n", x, f);
    
    printf("\n\n\n");
    char letra = 'A';
    char mayus = 's'*(letra>= 'A' && letra <='Z') + 'n'*(letra>= 'a' && letra <='z') ;
    printf("La letra %c es mayuscula %c\n", letra, mayus);
    
    letra = 'c';
    mayus = 's'*(letra>= 'A' && letra <='Z') + 'n'*(letra>= 'a' && letra <='z') ;
    printf("La letra %c es mayuscula %c\n", letra, mayus);
    
    return (0);
}
\end{verbatim}

\section {Precedencia de los operadores}

Las reglas de precedencia de operadores son una guía de acción, que le permiten a los lenguajes calcular expresiones en el orden correcto. La siguiente tabla presenta el orden de precedencia

\begin{tabular}{|c|c|c|}
  \hline
  % after \\: \hline or \cline{col1-col2} \cline{col3-col4} ...
  Operadores & Operaciones & Orden de cálculo \\
  \hline
  $( )$&  Paréntesis & Se calculan primero. \\
  $*, /, \%$ & Multiplicación, División y Modulo & Se evalúan en segundo lugar  \\
  $+, -$ & Suma o resta & Se calcula al último\\
  \hline
\end{tabular}

\subsubsection{Ejercicio}
Dada la ecuación $y=ax^3+7$, ¿cual de los que siguen, si es que existe alguno, son enunciados correctos correspondientes a esta ecuación?.

\begin{verbatim}

a) y = a * x * x * x + 7;

b) y = a * x * x * (x + 7);

c) y = (a * x) * x * (x + 7);

d) y = (a * x) * x * x + 7;

e) y = a * (x * x * x) + 7;

f) y = a * x * (x * x + 7);

\end{verbatim}


\subsubsection{Ejercicio}

Declare el orden de cálculo de los operadores en cada uno de los enunciados siguientes y muestre el valor de x una vez que se ejecute cada una de ellas.

\begin{verbatim}

a) x = 7 + 3 * 6 / 2 - 1;

b) x = 2 \% 2 + 2 * 2 - 2 / 2;

c) y = (3 * 9 * (3 + (9 * 3 / (3))));

\end{verbatim}


\subsection{Literales, Constantes y variable}

Con el objetivo de generalizar nuestros programa haremos uso de letras que representarán los valores que deseamos guardar para un procesamiento posterior en tiempo de ejecución. Las variables podrán ser de cualquiera de los tipos numéricos, de tipo carácter o los que tipos compuestos definidos por los usuarios.

Los nombres de las variables validos comienzan con una letra seguida de otras letras o el carácter $\_$. La longitud de los nombres no tiene limite y normalmente se sugiere, por facilidad de lectura, tengan relación con la variable que representa.

así por ejemplo\\
\verb"int a= 10;"\\
almacenara el número 10 en la variable a.

\verb"char a = 'a'"\\
\noindent
almacenara en la variable a el carácter a. Note que los caracteres se pondrán entre comillas a diferencia de los nombres de variables.

\section{ Cálculo del valor máximo de un tipo, overflow}

Dado que los tipos de datos tienen límites, debemos ser cuidadosos al realizar las operaciones ya que ocurrirán cosas raras. Un ejemplo es el caso de una variable de tipo char a la cual se le asigna el valor de 127 y se le suma un 1 el resultado no es 128 sino -128. Esto se debe a que ocurre un sobre flujo (overflow) y el número siguiente que se asigna no es el consecutivo que esperamos sino el del l\'imite inferior. 

El siguiente código muestra algunas operaciones que producen sobre flujo en los datos y para evitarlo debemos siempre tener en cuenta los rangos en los cuales las variables están definidas.

\begin{verbatim}
/* 
 * File:   rango_tipos.c
 * Author: felix
 * Operaciones para indicar el rango de los tipos de datos
 * Created on 7 de septiembre de 2011, 17:41
 */

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char** argv) {
    /* Tipo de dato caracter */
    
    char a = 127+1;
    printf("a = %d\n", a);
    
    unsigned char b = 127 +1;
    printf("b = %d\n", b);

    unsigned char c = 255 +1;
    printf("c = %d\n", c);
    
    /* Tipo de dato entero */ 
    
    unsigned int y = 0;
    printf("y = %u\n", y-1);
    
    int d = 2147483648 +1;
    printf("d = %d\n", d);
        
    unsigned e = 2*d;
    printf("e = %d\n", e);
    
    long f = d+1;
    printf("f = %d\n", f);
    
    unsigned long g = 2*d;
    printf("g = %d\n", g);
    
    
    int x = 10 >> 2; 
    printf("%d\n", x);
    
    return (EXIT_SUCCESS);
}
\end{verbatim}

\section {Instrucciones secuenciales}

Una manera de realizar un sencillo programa es utilizando una serie de instrucciones de forma consecutiva (secuencial o en secuencia) que permita realizar una tarea. Algunos ejemplos de ellos se presentan en las siguientes tareas.

\section{Ejemplos} \label{sec:ejemplos_areas}

\subsection {Calculo de áreas y volúmenes de figuras geométricas regulares} 

Dada la siguiente información, hacer un programa que permita calcular el área de un triángulo, de un cuadrado, y de un rectángulo, así como los volúmenes de un cilindro y de un cono.

El triángulo es un polígono formado por tres lados y tres ángulos. La suma de todos sus ángulos siempre es 180 grados. Para calcular el área se emplea la siguiente fórmula:

\begin{center}
\textbf{Área del triángulo = (base * altura) / 2}
\end{center}


El cuadrado es un polígono de cuatro lados, con la particularidad de que todos ellos son iguales. Además sus cuatro ángulos son de 90 grados cada uno. El área de esta figura se calcula mediante la fórmula:

\begin{center}
\textbf{Área del cuadrado = lado al cuadrado}
\end{center}

El rectángulo es un polígono de cuatro lados, iguales dos a dos. Sus cuatro ángulos son de 90 grados cada uno. El área de esta figura se calcula mediante la fórmula:

\begin{center}
\textbf{Área del rectángulo = base * altura}
\end{center}

El cilindro es el sólido engendrado por un rectángulo al girar en torno a uno de sus lados. Para calcular su área lateral, su área total así como para ver su desarrollo pulsar sobre la figura anterior Para calcular su volumen se emplea la siguiente fórmula:

\begin{center}
\textbf{Volumen del cilindro = área de la base * altura}
\end{center}

El cono es el sólido engendrado por un triángulo rectángulo al girar en torno a uno de sus catetos. Para calcular su área lateral, su área total así como para ver su desarrollo pulsar sobre la figura anterior Para calcular su volumen se emplea la siguiente fórmula:

\begin{center}
Volumen del cono = (área de la base * altura) / 3
\end{center}

\textbf{La implementación en C es:}
\begin{verbatim}
// Ejemplo ec021.cpp
include <stdio.h>

/**
 * Title: Calculo de areas y volumenes
 * Calcula utilizando simples sentencias las áreas y volúmenes de figuras
 * 2005
 * Company: UMSNH
 * @author Dr. Felix Calderon Solorio
 * @version 1.0
 */

int main()
 {

    // datos

  double base = 10, altura = 5, radio = 2;

  // areas

  double Atriangulo  = (base * altura) / 2.0;
  double Acuadrado   = base*base;
  double Arectangulo = base * altura;

  // volumenes

  double Abase       = 3.1416*radio*radio;
  double Vcilindro   = Abase * altura ;
  double Vcono       = Abase * altura / 3.0;

  printf("Area de triangulo  = %f\n", Atriangulo);
  printf("Area de cuadrado   = %f\n", Acuadrado);
  printf("Area de rectangulo = %f\n", Arectangulo);
  printf("Volumen cilindro   = %f\n", Vcilindro);
  printf("Volumen cono       = %f\n", Vcono);

  return 0;
}
\end{verbatim}

\subsection {Ley de ohm y Análisis básico de transistores} \label{sec:transistores}

Para el circuito mostrado en la figura \ref{fig:transistor}, determinar la ganancia de voltaje de un transistor en configuración de base común.

\begin{figure}[!htp]
   \centering
   \centerline{\psfig{figure=figuras/transistor.eps,width=8.0cm}}
   \caption{Ejemplo de transistores.}
   \label{fig:transistor}
\end{figure}


La Solución en C queda como:

\begin{verbatim}

// Ejemplo ec023.cpp

#include <stdio.h>

/**
 * Title: Calculo de la ganancia de voltaje para un transistor
 * Description: Programa para determinar ganancias de voltaje
 * Copyright: Copyright (c) 2005
 * Company: UMSNH
 * author Dr. Felix Calderon Solorio
 * version 1.0
 */

int main() {

  double Vi = 200e-3, Re = 100, Rc = 100e+3, R = 5e3;
  double I, Il, Vl, Av;

  // calculo de la corriente de emisor.

  I = Vi/Re;
  printf("I = %f\n", I);

  // Asumiendo una ganacia alpha = 1 y que Ic = Ie

  Il = I;
  printf("Il = %f\n", Il);

  // el voltaje en la resistencia R es

  Vl = Il*R;
  printf("Vl = %f\n", Vl);


  // finalmente la ganacia de voltaje es

  Av = Vl/Vi;
  printf("Av = %f\n", Av);

}
\end{verbatim}




