Libro LenguajeC Javier Inicial Version 201504

Versin 201504 Javier Rambaldo

IndiceIntroduccin............................................................................................................................4

Prerequisitos......................................................................................................................4A quin est dirigido este libro..........................................................................................4

Lenguaje C..............................................................................................................................5La funcin main()...............................................................................................................5Comentarios.......................................................................................................................6Palabras Clave....................................................................................................................6Sentencias de Programa....................................................................................................7Directivas...........................................................................................................................8Compilador.........................................................................................................................9Tipos de Datos Primarios..................................................................................................10Identificadores..................................................................................................................11Tipos de Datos.................................................................................................................12

Enteros (int).................................................................................................................12Nmeros en Punto Flotante (float)...............................................................................12Caracteres (char).........................................................................................................12

Literales............................................................................................................................13Literales enteros......................................................................................................13

Inicializando Variables y el Operador de Asignacin........................................................13Imprimiendo Contenidos de Variables.............................................................................14

Especificadores de conversin.....................................................................................14Constantes.......................................................................................................................15Estilos de Convencin de Programas...............................................................................16

El sangrado y los espacios en blanco..........................................................................16Convencin de nombres de las variables....................................................................16

Identificar los tipos de datos con prefijos................................................................17Usar maysculas y minsculas apropiadamente....................................................17Dar a las variables nombres significativos..............................................................18

Aritmtica en C................................................................................................................19Precedencia de operadores.........................................................................................20

Condiciones......................................................................................................................20Expresiones y Operadores Condicionales........................................................................21Estructura IF Simple.........................................................................................................22Estructura IF Anidada.......................................................................................................23Introduccin al Algebra Booleana....................................................................................24

Operador AND..............................................................................................................24Operador OR................................................................................................................24Operador NOT..............................................................................................................24Orden de Operaciones.................................................................................................24

Estrucuras IF Compuestas................................................................................................24Operador &&................................................................................................................25Operador ||...................................................................................................................25Operador !....................................................................................................................25Chequeando maysculas y minsculas.......................................................................25Chequeando un rango de valores................................................................................26

Operador Ternario ?:........................................................................................................26Estructura Switch...Case..................................................................................................26Estructuras de Lazo..........................................................................................................27Estructura While...............................................................................................................27Estructura For...................................................................................................................28Estructura Do...While.......................................................................................................28Bucles infinitos.................................................................................................................29

Bucle infinito con for....................................................................................................29Bucle infinito con while................................................................................................29

Sentencias Break y Continue...........................................................................................29Operadores (Continuacin)..............................................................................................30


Operadores de auto-incremento / decremento...........................................................30Operadores +=, -=, *=, /=..........................................................................................31

Operadores de Bits...........................................................................................................31El operador AND (&).....................................................................................................32El operador OR (|)........................................................................................................32El operador XOR (^)....................................................................................................32El operador de complemento (~)................................................................................32Los operadores de desplazamiento (>)...........................................................33Ejemplos:.....................................................................................................................33

Programacin estructurada y modular.................................................................................35Introduccin.....................................................................................................................35

Diseo top-down y botton-up.......................................................................................35Reusabilidad de cdigo................................................................................................35Ocultamiento de informacin......................................................................................36

Prototipos de funciones....................................................................................................36Definicin de funciones....................................................................................................37Alcance de las variables...................................................................................................37

Alcance local................................................................................................................37Alcance global..............................................................................................................38


Introduccin

C es un potente lenguaje de programacin desarrollado en 1972 por Denis Ritchie en los pasillos de los laboratorios Bell. El llenguaje de programacin C fue desarrollado originalmente para el uso con plataformas UNIX y se ha extendido a muchos otros sistemas y aplicaciones. C ha influido en varios lenguajes de programacin, incluyendo el C++ y el Java.Programadores principiantes, especialmente aquellos matriculados en ciencias de la computacin y estudiantes de ingeniera, necesitan construir una base slida de sistemas operativos, hardware y conceptos de desarrollo de aplicaciones. Numerosas instituciones de aprendizaje logran esto mediante la enseanza a sus estudiantes a programar en lenguaje C para que puedan progresar en conceptos avanzados y otros lenguajes construidos sobre C.Muchos estudiantes de C admiten -y con razn- que no es un lenguaje fcil de aprender, pero afortunadamente este libro ayudar a comprender lo bsico del lenguaje con una visin profesional.

PREREQUISITOSPara poder seguir el libro debers debers tener instalado un compilador de C en tu PC. Pods optar por una interfaz con un editor grfico y un compilador en lnea de comandos, o un completo editor/compilador llamado IDE. Recomendaciones: a- Como editor en lnea te recomiendo para linux el gcc (que ya existe por defecto instalado) o para entornos Windows el MinGW (http://www.mingw.org/). Como editor pods usar el que viene por defectoen cualquier sistema operativo, pero para windows te recomiendo el Notepad++ (http://notepad-plus-plus.org/).b- Como entorno de desarrollo o IDE te recomiendo el DevC++ (http://www.bloodshed.net/dev/devcpp.html)

A QUIN EST DIRIGIDO ESTE LIBROEste libro est pensado para personas que se inician en la programacin en C. No est pensado para programadores con experiencia en C ni en bsqueda de estructuras de datos complejas ni programacin orientada a objetos (OOP o C++).Para aprender a programar se debe adquirir una progresin de habilidades. Si nunca has programado en absoluto, es probable que te resulte ms fcil ir por los captulos en orden. La programacin no es una habilidad que se puede aprender mediante la lectura. Para aprender debs escribir muchos programas.Sin embargo, si prefers pods usar este libro como una gua o ayuda rpida.


Lenguaje C

LA FUNCIN MAIN()Primero debemos aclarar que es una funcin, y es un algoritmo, procedimiento o rutina encargada de una tarea especfica. Las funciones nos permiten agrupar una serie lgica de actividades o sentencias de programa bajo un nombre.Por ejemplo, supongamos una funcin llamada HacerPastel. Nuestro algoritmo para hacer el pastel sera asi:

Mezcle los ingredientes hmedos en un bolCombine los ingredientes secosPrepare el moldehornee la torta a 350 grados durante 40 minutos

Cualquiera que lea nuestra funcin entender que se trata de hacer un pastel y no solo por su nombre.Pero a esta funcin le falta la lista de ingredientes, en este caso los llamaremos parmetros, y la misma funcin nos entregar como resultado el pastel, al cual llamaremos valor de retorno.

Los parmetros de una funcin y el valor de retorno no son obligatorios en las funciones. Pueden prescindir de ellos segn sean necesarios o no.

En el caso de la funcin main() es como cualquier otra funcin que pueda hacer el programador, perosta es especial, porque es la funcin principal de todo programa en C. Es la funcin que llamar el sistema operativo (en caso de tener un SO) o es la llamada principal del microprocesador en caso de no tener un SO, como en el caso de sistemas embebidos en microcontroladores.

Usaremos la funcin main() sin parmetros ni valores de retorno. Pero podr encontrar otros ejemplos que si los utilizan.

IMPORTANTE: El lenguaje C es sensible a maysculas y minsculas. Por ejemplo, la funcin main(), Main() y MAIN() no son la misma. Se recomienda usar siempre minsculas.

main(){}

Como en el ejemplo anterior, la funcin main comienza con la palabra main y es seguida de dos parntesis (). Los parntesis son usados para encerrar los parmetros pasados a la funcin main. En este caso no vemos parmetros.

Seguido de los parntesis hay dos llaves {}. La primera llave { es la que indica que comienza el bloque de cdigo, y la ltima llave } indica el fin del bloque.Cada funcin implementada requiere que usemos llave de inicio { y llave de fin }.

El siguiente cdigo de programa nos muestra un simple pero completo programa en C. A partir de este cdigo aprenderemos como una cantidad de sentencias simples se unen para formar un programa completo en C.


/* Mi primer programa en C */

#include

main() { printf("Hola Mundo\n"); }

Cuando se compile y se corra este programa veremos en la consola el texto Hola Mundo.

Ahora analizaremos lnea a lnea el programa anterior:

COMENTARIOS/* Mi primer programa en C */

Todo bloque de texto que se encierre con los caracteres /* y */ no ser analizado por el compilador, ya es es solo un texto o comentario til solo para el programador.

Son muy necesarios los comentarios en un programa ya que indican lo que el programador pens y analiz en el momento de escribir el cdigo. Es la documentacin casi obligatoria de todo programa y no solo le es til al que lo escribi, sino a cualquier otra persona que quiera entender el programa para corregirlo o buscar algn error.

Tambin es vlido un comentario de varias lneas como este:


O puede estar en el medio de una sentencia:

main(/*aqui no hay parmetros*/)

En este caso el compilador no ver el comentario por lo tanto solo ver el main().

En algunos compiladores de C mas modernos se acepta el uso de comentarios de C++ que son comentarios de una sola lnea. Por ejemplo:

// Mi primer programa en Cmain() // funcion principal

El comentario comienza luego de los caracteres // y sigue hasta el final de la lnea.

PALABRAS CLAVEExisten 32 palabras definidas como palabras clave en el lenguaje de programacin estndar ANSI-C. Estas palabras clave tienen usos predefinidos y no pueden ser usadas para ningn otro propsito en un programa en C. Estas palabras son usadas por el compilador para construir el programa. Ntese que estas palabras deben ser escritas en minsculas.


Palabra clave Descripcin

auto Define una variable como variable con vida local

break Pasa el control fuera de la estructura

case Parte de la estructura de control switch

char Tipo de dato bsico

const Valor constante

continue Pasa el control al siguiente lazo

default Parte de la estructura de control switch

do Estructura de control do-while

double Tipo de dato numrico de precisin

else Sentencia condicional if-else

enum Define un grupo de constantes de tipo entero

extern Indica un identificador definido en otra parte

float Tipo de dato numrico

for Estructura de control

goto Transfiere el control del programa incondicionalmente

if Sentencia condicional

int Tipo de dato entero

long Modificador de tipo de dato

register Guarda la variable en un registro del microprocesador

return Sale de una funcin

short Modificador de tipo de dato

signed Modificador de tipo de dato

sizeof Devuelve el tamao de un tipo de dato

static Conserva el valor de la variable despus que su mbito deaplicacin termina

struct Agrupa variables en un registro simple

switch Control de bifurcacin

typedef Crea un nuevo tipo de dato

union Agrupa variables que ocuparn el mismo espacio de almacenamiento

unsigned Modificador de tipo de dato

void Tipo de dato nulo

volatile Permite a una variable que pueda cambiar

while Repite la ejecucin del programa mientras la condicin sea verdadera

Hay que tener en cuenta que, adems de las palabras de esta tabla, el compilador que estemos utilizando puede tener definidas ms palabras clave. Si es as, deberamos tener la documentacin del compilador usado.


SENTENCIAS DE PROGRAMAMuchas lneas de los programas en C se consideran sentencias de programa, que sirven para control, ejecucin y funcionalidad del programa. Muchas de estas sentencias de programa deben terminar con una declaracin de fin de sentencia. Estas son simplemente un punto y coma (;). La lnea siguiente lnea de cdigo, que incluye una funcin printf(), demuestra una sentencia con su terminador.

printf("Hola Mundo\n");

Algunas sentencias comunes que no requieren una terminacin con (;) son las siguientes:

Comentarios Directivas de preprocesador (por ejemplo, #include o #define) Comienzo y fin de bloques de programas ({}) Comienzo de definicin de funciones (por ejemplo, main())

La funcin ms comnmente usada para mostrar datos en la pantalla es la funcin printf(). Esta funcin requiere valores como parmetros, y por ahora veremos el parmetro mas comn de la funcinprintf() que es un texto para imprimirlo en la pantalla. Este texto requiere estar encerrado entre comillas.

printf("Hola Mundo\n");

Aparte del texto Hola Mundo vemos que aparecen los caracteres \n que no se ven en la pantalla. Estos forman parte de los llamados secuencias de escape, y son una forma de pasar caracteres no imprimibles dentro del mismo texto entre comillas. Por ejemplo el \n significa que le agregue una nuevalnea o ENTER luego del texto. As la prxima palabra que se imprima en la pantalla aparecer debajo.Estas secuencias pueden aparecer en cualquier lugar de la cadena de texto.

Secuencia de escape Significado

\n Crea una nueva lnea

\t Mueve el cursor hasta el prximo Tabulado

\r Mueve el cursor hasta el principio de la lnea actual

\\ Inserta un carcter \

\ Inserta una comilla

\' Inserta una comilla '

Ejemplo:

#include main(){

printf("\t\t\"Septiembre\"");printf("\nDom\tLun\tMar\tMie\tJue\tVie\tSab\n"); printf("\t\t\t\t1\t2\t3\n"); printf("4\t5\t6\t7\t8\t9\t10\n"); printf("11\t12\t13\t14\t15\t16\t17\n"); printf("18\t19\t20\t21\t22\t23\t24\n"); printf("25\t26\t27\t28\t29\t30\t31\n");

}


DIRECTIVASAqu tenemos nuevamente nuestro primer programa:


#include

main() { printf("Hola Mundo\n"); }

Observemos la sentencia que comienza con el numeral (#):

#include

Cuando se compile el cdigo, previamente se analizarn todas las lneas que contengan el sigo numeral (#) y se ejecutarn las acciones que correspondan, segn la directiva usada.En el ejemplo anterior, le decimos al compilador que incluya la librera sdtio.h en mi programa.

El nombre stdio.h es un archivo llamado as por Standard Input Output Header File. Este archivo contiene enlaces a varias funciones de libreras estndar de C, como la funcin printf(). Existen muchas libreras que veremos ms adelante, y tambin como podemos construir las nuestras.

NOTA: Porqu tenemos que incluir una librera para imprimir en pantalla?Si nos detenemos a pensar que un programa est hecho para que lo ejecute un microprocesador, y a su vez que un microprocesador puede estar incorporado en muchos aparatos electrnicos que no tienen porqu ser una computadora, y ni siquiera tienen obligacin tener una pantalla o un display, entonces una librera que muestre en una pantalla no tendra sentido en, por ejemplo, un sensor de temperatura inalmbrico microprocesado. En ese caso si tendra ms sentido que la salida estndar no sea la pantalla, sino alguna lnea de comunicacin o transmisin.Es por este motivo que las libreras son todas opcionales, y nosotros podemos incluir la que necesitemos, dependiendo del contexto donde estar corriendo el programa.

COMPILADORExisten muchos compiladores de C que podemos usar, pero todos los compiladores siguen una serie de pasos antes de obtener un programa ejecutable. Algunos de los pasos ms comunes son:

Preprocesa el cdigo del programa y busca las directivas. Genera una lista de mensajes y cdigos de error. Compila el cdigo del programa en un cdigo objeto y crea un archivo ejecutable y lo guarda

en el disco.

Aqu tenemos una lista de los compiladores mas conocidos, que se generan ejecutables para PC bajo Windows o en Linux:

Compilador Descripcin

Dev-C++ de Bloodshed Software Editor y compilador para aplicaciones Windows y de consola,


Compilador Descripcinbasado en GCC (Mingw). http://www.bloodshed.net/

Borland C++ o Borland Turbo C++

Cygwin (GNU C++) http://www.cygwin.com/

Digital Mars http://www.digitalmars.com/

MINGW - "Minimalist GNU for Windows" http://www.mingw.org/

DJ Delorie's C++ Development system for DOS/Windows (GNU C++) para Intel 80386 (and higher) PCs running DOShttp://www.delorie.com/djgpp

GNU GCC http://www.gnu.org/software/gcc/

Intel C++ for non-commercial development

http://software.intel.com/en-us/articles/non-commercial-software-development/

RELO Editor de cdigo C/C++ para aplicaciones Windows, que utiliza los compiladores Borland C++ o MingW/GCC.http://www.fifsoft.com/relo/

Visual C++ Express Edition Versin gratuita de Microsofthttp://www.microsoft.com/express/Downloads/

Ahora a trabajar: Crear los siguientes programas, compilar, encontrar los errores (si hay alguno) y correrlos.

1- Crea un programa que imprima tu nombre.2- Crea un programa que use la secuencia de escape \\ e imprima el siguiente texto

correspondiente a una estructura de directorios: C:\Archivos de programa\MinGW\bin\logs.3- Escribe un programa que imprima un rombo con asteriscos como aqu:

* * * * * * * *

4- Crea un calendario del mes en curso similar al siguiente:

Septiembre 1966

lun mar mie jue vie sb dom 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

TIPOS DE DATOS PRIMARIOSAhora veremos los conceptos esenciales de la memoria de la computadora y cmo obtener


informacin de los usuarios y almacenarla en la memoria, utilizando los tipos de datos del lenguaje C. Adems veremos cmo utilizar la funcin printf() para manipular los diferentes tipos de datos almacenados en la memoria, utilizando aritmtica bsica. En concreto trataremos los siguientes temas:

Variables Tipos de datos Inicializando variables y el operador de asignacin Imprimiendo contenidos de variables Constantes Estilos de convencin de programas scanf() Aritmtica en C Precedencia de operadores

IDENTIFICADORESLos identificadores son nombres arbitrarios usados para designar objetos del lenguaje como etiquetas, variables, funciones y constantes. Los identificadores pueden contener letras, nmeros y el caracter _ o guin bajo. El primer caracter no puede ser un nmero y la mayora de los compiladores son sensibles a maysculas y minsculas, es decir, no es lo mismo usar el nombre Sum que sum.

Algunos identificadores vlidos:

Temperatura_V1contadorno_pulsadoSUM3_vtext

Aqu hay identificadores NO vlidos:36temperatura%mayoriff23.09.99

Cuando hablamos de variables nos referimos a datos que el sistema almacenar en la memoria voltil,ms comnmente llamada memoria RAM. La RAM esta compuesta por celdas de un determinado tamao que estn referenciadas por una direccin. Los programadores generalmente hacen referenciaa estas celdas de memoria mediante el uso de variables. Existen varios tipos de variables, que dependen del lenguaje de programacin, pero todas las variables comparten las mismas caractersticas, como se describe en la siguiente tabla:

Atributo de la variable Descripcin

Nombre Nombre de la variable usado para hacer referencia al dato en el cdigo del programa.

Tipo El tipo de datos de la variable (nmero, carcter, etc)Valor El valor del dato asignado a la memoria.Direccin La direccin asignada a la variable, que apuntar a la celda

de memoria de datos.

Usando estos atributos veremos unos ejemplos usando tipos de datos comunes. Tengamos en cuenta que las letra y nmeros en la columna Direccin de memoria son nmeros hexadecimales. El sistema


numrico hexadecimal en muy comn usarlo en programacin avanzada en lenguaje C para referenciar una direccin de memoria especfica.

Nombre de lavariable

Valor Tipo Direccin dememoria

Operando1 29 entero FFF4Resultado 756,21 flotante (decimal) FDD6Inicial M caracter F03A

TIPOS DE DATOSEn programacin avanzada en C descubriremos muchos tipos de datos diferentes, tales como nmeros, fechas, cadenas de caracteres, booleanos, matrices, objetos y estructuras de datos. Pero ahora nos centraremos solo en los tipos simples: enteros, nmeros en punto flotante y caracteres.

Enteros (int)Los integer son nmeros enteros que representan nmeros positivos y negativos, tales como -2, -1, 0, 1, 2, 3, pero no nmeros decimales o fraccionarios.Los tipos de datos enteros pueden tener un tamao mximo de 4 bytes de informacin y son declarados con la palabra clave int, como vemos en el siguiente cdigo:

int x;

En C podemos declarar ms de una variable en la misma lnea usando una sola declaracin int:

int x, y, z;

El ejemplo anterior declara 3 variables llamadas x, y, z de tipo entero. Recordemos que cada lnea en lenguaje C debe terminar con (;).

Nmeros en Punto Flotante (float)Los nmeros en punto flotante son todos nmeros, incluidos los que tienen signo como los que no, los decimales y los fraccionarios. Nmeros con signo incluyen tanto a los positivos como a los negativos mientras que los nmeros sin signo solo son los positivos. Algunos ejemplos de nmeros en punto flotante:

0.7421341234.02112.981273-234.78-554683.0001

En C, para declarar nmeros con punto flotante se usa la palabra clave float as como se muestra en el siguiente cdigo:

float operando1;float operando2;float resultado;

Caracteres (char)Los tipos de datos de caracter (chars) son representaciones de nmeros enteros conocidos como


cdigos de carcter. Por ejemplo el cdigo 90 representa la letra Z y el cdigo 112 representa la z (en minscula).Los caracteres no solo representan las letras del alfabeto, tambin representan los nmeros del 0 al 9, caracteres especiales como el * o el # $ o las teclas del teclado como el Escape o la tecla Delete. En total existen 128 caracetres comunes (del 0 al 127) que representan los caracteres comnmente usados en el teclado.En C se usa la palabra clave char para declarar un tipo de datos de caracter. Ejemplo:

char primeraLetra;char ultimaLetra;char otraLetra;

Importante: No se puede asignar una cadena de caracteres a una variable de tipo char. Para eso se utilizan arrays o strings y esto lo veremos en un curso ms avanzado.

LITERALESLos literales son cadenas que representan nmeros fijos o valores de caracteres. El compilador identifica el tipo de dato dependiendo de como se escriba ese literal.

Literales enteros Pueden escribirse en hexadecimal (base 16), decimal (base 10), octal (base 8) o binario (base

2). Los literales que comienzan con 0x son considerados hexadecinales. Por ejemplo: 0x8F. En la notacin decimal, los literales son representados como una secuencia de dgitos, sin

comas ni puntos ni espacios , con un prefijo opcional + o -. Los literales decimales que no tengan este prefijo se consideran positivos. Por ejemplo, el nmero 2345 es equivalente al +2345.

Los literales que comienzan en 0 (cero) se consideran nmeros octales. Por ejemplo 0231. Los literales que comienzan en 0b se consideran binarios. Ejemplo 0b01101001.

Ejemplos de literales:

0x11 // literal hexadecimal equivalente al decimal 1711 // literal decimal011 // literal otal equivalente al decimal 90b11 // literal binario equivalente al decimal 3

Estos son ejemplos de literales no reconocidos por el compilador. Puedes descubrir porqu?

0b0201101101870x85H1+123.1

Literales en punto flotanteLos literales en punto flotante consisten en:

enteros decimales punto decimal fraccin decimal, y


e o E y un exponente entero con signo (opcional).Aqu hay algunos ejemplos:

0. // = 0.0-1.23 // = -1.23 23.45e6 // = 23.45 * 10^62e-5 // = 2.0 * 10^-53E+10 // = 3.0 * 10^10.09E34 // = 0.09 * 10^34

Literales de caracterUn literal de caracter es un caracter ASCII encerrado entre comillas simples.Ejemplos: 'a' 'Z'

Cadena de LiteralesUna cadena de literales representa una secuencia de caracteres encerrados entre comillas dobles. Estas cadenas pueden contener espacios. El largo de una cadena depende de la cantidad de caracteres que contenga. Existe un caracter adicional al final de toda cadena de caracteres llamado NULL o nulo, y es el ASCII cero. Este no est includo en el clculo del largo total de una cadena. Una cadena vaca se representa con dos comillas seguidas () y el largo total es cero.

Algunos ejemplos:Viva Ritchie! // cadena de 13 caracteres // dos espacios, largo 2 caracteresC // letra, largo 1 caracter // cadena nula o vaca, largo = 0

DesambiguacinPodra surgir una ambiguacin cuando se usan secuencias de escape en cadenas. Veamos este ejemplo:

printf(\x091.0 Intro);Esta cadena se interpretara como \x09 y 1.0 Intro. Algunos compiladores interpretan mal la secuencia de escape como: \x091 y .0 IntroPara anular este efecto, se debe colocar de la siguiente forma la cadena:

printf(\x09 1.0 Intro);

INICIALIZANDO VARIABLES Y EL OPERADOR DE ASIGNACINCuando las variables se declaran por primera vez, el programa asigna el nombre de la variable a una posicin de memoria disponible. Nunca es seguro asumir que este lugar est vaco. Es posible que la memoria tenga valores usados anteriormente (o basura). Para evitar que datos no deseados aparezcan en las variables recin creadas, debemos inicializarlas, como se muestra en el ejemplo:

/* declaracin de variables */int x;char letraInicial;

/* inicializacin de variables */x = 0;letraInicial = '\0';

Para asignar un valor a una variable se utiliza el carcter (=) y no olvidar el terminador final (;). Los


caracteres asignados a chars siempre llevan comillas simples (') para indicar que es un caracter. En este caso el '\0' indica un carcter nulo o de cdigo 0.Otra forma de inicializar una variable es en el mismo momento de su declaracin, como vemos en el siguiente ejemplo:

/* declaracin e inicializacin de variables */int x = 0;char letraInicial = '\0';

IMPRIMIENDO CONTENIDOS DE VARIABLESPara imprimir el contenido de una variable usaremos la funcin printf() con un nuevo formato como muestra el ejemplo:

#include main() {

/* declaracin de variables */int x; float y; char c; /* inicializacin de variables */x = -4443; y = 554.21; c = 'M'; /* imprimiendo variables en pantalla */printf("\nEl valor de la variable int es %d", x); printf("\nEl valor de la variable float es %f", y); printf("\nEl valor de la variable char es %c\n", c);

}

Primero declaramos 3 variables (entera, punto-flotante y carcter) y luego las inicializamos. Luego usamos la funcin printf() para mostrar su contenido en la pantalla.

Especificadores de conversinLa informacin que se almacena en la memoria de la computadora es ininteligible para los humanos. Por ello se necesita convertir estos datos a valores entendibles. Los programadores en C deben especificar como representarn estos datos en la pantalla. Por ejemplo, un valor almacenado en memoria 416 se podr representar como 01A0 en hexadecimal o 416 en decimal, segn se desee; o un valor 12.0512238 se podr representar solo por su valor entero 12 o con dos decimales 12.05 segn desee el programador.Para esto existen especificadores de conversin para la funcin printf(). Vemoslo con unos ejemplos:

#include main() {

int x = 416; float y = 12.0512238;

printf("\nEl valor de x en decimal es %d", x); printf("\nEl valor de x en hexadecimal es %X", x);


printf("\nEl valor entero de y es %2.0f", y); printf("\nEl valor de y con dos decimales es %.2f\n", y);

}

Como vemos, hemos utilizado el %d %X %.2f y en el ejemplo anterior el %c. Estos son los especificadores de conversin, y lo que hacen es convertir una variable en el formato que le especifiquemos para poder mostrarla en pantalla.Estos son algunos de los posibles especificadores de conversin:

Especificador de conversin

Descripcin

%d Muestra un valor entero%f%.2f

Muestra un valor en punto flotante. El agregado de n.m es para especificarcuantos nmeros se quiere para la parte entera, y cuntos para la parte decimal.

%c Muestra un caracter%X Muestra un valor entero en su representacin hexadecimal

Los nmeros en punto flotante pueden representarse con la precisin que se desee. Por ejemplo:

printf("%.1f\n", 3.1415926); printf("%.2f\n", 3.1415926); printf("%.3f\n", 3.1415926); printf("%.4f\n", 3.1415926); printf("%.5f\n", 3.1415926); printf("%.6f\n", 3.1415926);

Las lneas de cdigo anteriores presentarn la siguiente salida:3.1 3.143.1413.14153.141593.141592

CONSTANTESTambin llamadas variables de solo lectura, las constantes no pueden perder su valor inicial durante la ejecucin de un programa. Son usadas cuando necesitamos reusar un valor de una variable sin que cambie. Los valores constantes pueden ser de cualquier tipo de datos y deben ser asignados en el momento de su definicin, como muestra este ejemplo:

const int j = 10;const float PI = 3.1415926;

Observemos que la palabra clave const precede al tipo de datos, lo que indica que esta variable ser una constante. Puede imprimir valores de variables constantes al igual que otra variable, como ya hemos visto:

#include main()


{ const int j = 10; const float PI = 3.1415926; printf("\nValores constantes: j=%d y PI=%.4f\n", j, PI); }

ESTILOS DE CONVENCIN DE PROGRAMASAntes de seguir debemos aclarar que la programacin es tanto un arte como una ciencia! Nuestros programas son el reflejo de nosotros mismos y deben revelar un estilo suave y consistente que gue al lector a travs de los algoritmos y el flujo del programa. Al igual que un puente que realiza su funcin, puede proporcionar belleza a la vista del viajero como del ingeniero estructural.Debemos seguir un estilo y una convencin que nos permita a nosotros o a alguien ms leer con facilidad nuestro cdigo. Una vez que adoptemos un estilo de escritura, usemos siempre el mismo, no mezclemos dentro del mismo programa diferentes formas de nombrar variables o de usar el sangrado de las sentencias.Al aprender como programar deberemos considerar al menos dos reas importantes en el desarrollo de una convencin coherente y con estilo:

El sangrado y los espacios en blanco. La convencin de nombres de las variables.

El sangrado y los espacios en blancoEste tema no es frecuentemente discutido porque no provee ningn beneficio computacional. De hecho el compilador ignora los espacios en blanco, as que podemos escribir el programa como quisiramos.Por ejemplo, el programa anterior podramos escribirlo de la siguiente manera:

#include main(){const int j = 10; const float PI = 3.1415926; printf("\nValores constantes: j=%d y PI=%.4f\n", j, PI);}

Y compilara sin errores, y el resultados ser el mismo. Pero imaginemos un programa con miles de lneas de cdigo escrito de esta forma, sera imposible de entender....Como regla prctica para comenzar a programar en C, usemos siempre una sentencia por lnea; indentemos las lneas con 2 a 4 espacios luego de cada llave o estructura de programa; usemos siempre llaves para cada bloque de estructura por ms que no sea necesario. (Algunos de estos detalles lo veremos mas adelante).

Convencin de nombres de las variablesAntes debemos conocer que una variable debe tener ciertas reglas para que el compilador la reconozca vlida y no nos de error de sintaxis:

La longitud de un nombre puede ser de mas de 255 caracteres (pero se torna muy inmanejable)

Deben comenzar por una letra Pueden contener letras, nmeros o caracteres de subrayado (_) No pueden contener espacios ni signos de puntuacin. No pueden coincidir con una palabra clave de lenguaje C

No existe una nica forma de dar nombre a las variables aunque algunas son mejores que otras. La


siguiente lista es una mnima gua a seguir cuando declaremos y demos nombre a las variables:

Identificar los tipos de datos con prefijos. Usar maysculas y minsculas apropiadamente. Dar a las variables nombres significativos.

Los nombres deben ser descriptivos, indicando qu es lo que estn alojando dentro. No tengamos miedo en usar nombres largos ni que contengan mas de una palabra. Si el nombre es una palabra compuesta usar la convencin llamada CamelCase, donde separaremos las palabras con maysculas (EjemploDeVariableCamelCase).

Identificar los tipos de datos con prefijosCuando trabajemos con variables, intentemos elegir un tipo de prefijo como se muestra aqu:

int iOperando1;float fResultado;char cLetraInicial;

Para cada tipo de variable diferente, usaremos una letra como prefijo del nombre elegido. Es decir, i para int, f para float y c para char. Esto nos permitir conocer el tipo de dato almacenado en una variable sin tener que ir a ver la declaracin de dicha variable.

Supongamos el siguiente cdigo:

/* declaracion de variables */float operando = 3.1415926; int resultado;/* . . . */resultado = operando * 2.0;

Aqu vemos que es fcil equivocar un clculo si no tenemos presente los tipos de variables utilizados. Estamos asignando a una variable entera el resultado de una operacin en punto flotante. Esto no generar error al compilar pero el resultado esperado no es el que se quiere, y al imprimir la variable resultado veremos solo la parte entera.

Veamos como debera escribirse para que no exista este error potencial:

/* declaracion de variables */float fOperando = 3.1415926; int iResultado;/* . . . */iResultado = fOperando * 2.0;

Aqu vemos claramente que al entero iResultado le estamos asignando el valor float fOperando.

Usar maysculas y minsculas apropiadamenteLa forma preferida para escribir variables en lenguaje C es usar el formato llamado CamelCase, que consiste en que todas las palabras usadas en el nombre de la variable estn capitalizadas, o sea que por cada palabra, la primera letra estar en mayscula y el resto en minscula. A esta convencin le podemos agregar el prefijo para distinguir el tipo de variable. En el caso de constantes, muchas veces se adopta usar toda la palabra en maysculas, separando laspalabras con guin bajo (_).Algunos adoptan convenciones ms restrictivas, como por ejemplo utilizar solo palabras en ingls o no usar artculos, como en CantidadDeRepeticiones.


Ejemplos:

float fVelocidadInicial;int iCantBits;char cMenuSelection;const float CONST_GRAVITY 9.8const int MAX_BITS 16

Dar a las variables nombres significativosDar a las variables un nombre significativo es, tal vez, lo mas importante en programacin. Haciendo esto creamos un cdigo auto-documentado. Consideremos el siguiente segmento de cdigo, que utiliza comentarios para describir las variables usadas.

int a; /* a es la edad */int b; /* b es la distancia */int c; /* c es el resultado */

La siguiente declaracin de variables no usa comentarios como la anterior, pero si utiliza convencin de variables y nombres significativos:

int iEdad;int iDistancia;int iResultado;

La siguiente tabla muestra ejemplo de variables incorrectamente nombradas segn las convenciones aqu nombradas, y algunas variables mal nombradas que dan error de compilacin.

Declaracin Comentarios

int mesactual; No se est usando CamelCase y no tiene prefijo que indique el tipo de variable.Forma sugerida: int iMesActual;

const int cant_de_semanas=52; Es constante, por lo tanto debera estar en maysculas. El nombre podra ser ms corto e identificar solo el contenido.Forma ms correcta: const int SEMANAS = 52;

int temp; Muchas variables en un programa son en cierta forma temporales. Usar un nombre mas significativo.

int cont; Al igual que temp, existen muchos lazos contadores en un programa. Podramos usar contFila, contColumna, contBytes, etc.

int iCantidadDeFilasDelMargenDeArriba; Tratar de acortar los nombres muy largos. Muchas veces un nombre en ingles nos ayuda.Ejemplo: int iCantFilasMargenSup;o int iSupMarginRowCount;

char cNoApagado; Ms evidente sera llamarla char cEncendido;float 2pi; Error de compilacin! No puede comenzar con

nmeros. Lo correcto sera float PI2;float gananciaEn$; Error de compilacin! Debe comenzar con una


Declaracin Comentarios

letra o un subrayado (_). Lo correcto podra ser float fGananciaEnPesos;

scanf()Ya vimos como enviar un texto a la pantalla de la computadora usando la funcin printf(). Ahora veremos como leer un dato ingresado por el teclado usando la funcin scanf().Esta funcin es otra funcin que provee la librera ; sta lee la entrada estndar desde el teclado y almacena el valor en una variable. Necesita dos argumentos como vemos aqu:

scanf("especificador de conversin", variable); El especificador de conversin le dice al scanf() como convertir el dato ingresado, y es el mismo especificador de conversin que utiliza el printf().El siguiente cdigo representa un ejemplo completo en C que utiliza la funcin scanf() para leer dos enteros y mostrar la suma de los mismos.

#include main() {

int iOperand1 = 0; int iOperand2 = 0; printf("\nIngrese el primer operando: "); scanf("%d", &iOperand1); printf("\nIngrese el segundo operando: "); scanf("%d", &iOperand2); printf("\nEl resultado es %d\n", iOperand1 + iOperand2);

}

Para utilizar la funcin scanf() se deber primero declarar la variable a usar. En este ejemplo declaramos iOperand1 e iOperand2. Luego, observemos la forma de usar estas variables en la funcin scanf():

scanf("%d", &iOperand1);

Observemos que iOperand1 est precedido por un smbolo &. Esto debe ser as, y se debe a que la funcin scanf() necesita un puntero a la variable. Por ahora no vamos a profundizar sobre punteros yaque lo veremos en un curso ms avanzado. Por ahora nos vasta saber que no debemos olvidarnos nunca del smbolo & antes de la variable.

ARITMTICA EN CComo vimos en el ejemplo anterior al sumar las variables, C habilita a los programadores a usar todo tipo de aritmtica. La siguiente tabla muestra todos los tipos de operaciones usadas en la programacin inicial en C:

Operador Descripcin Ejemplo

* Multiplicacin fResult = fOperando1 * fOperando2;/ Divisin fResult = fOperando1 / fOperando2;% Mdulo o Resto fResto = fOperando1 % fOperando2;


Operador Descripcin Ejemplo

+ Suma o Adicin fResult = fOperando1 + fOperando2;- Resta o Substraccin fResult = fOperando1 - fOperando2;

En el ejemplo anterior vimos que la suma estaba hecha directamente en el argumento de la funcin printf(). En el siguiente ejemplo vemos como asignar el resultado a una variable:

#include main() {

int iOperand1 = 0; int iOperand2 = 0; int iResultado = 0;

printf("\nIngrese el primer operando: "); scanf("%d", &iOperand1); printf("\nIngrese el segundo operando: "); scanf("%d", &iOperand2);

iResultado = iOperand1 + iOperand2;

printf("\nEl resultado es %d\n", iResultado); }

Recordemos que el signo = se utiliza para asignar un valor a una variable. En este caso el resultado dela suma se la asigna a la variable del resultado.

Precedencia de operadoresLa precedencia de operadores es muy importante cuando tratamos con operaciones aritmticas en cualquier lenguaje de programacin. Observemos estos ejemplos:

int f = (5 1) * (20 - 5);int f = 5 1 * 20 - 5;

El resultado ser el mismo?

Cuando no existen parntesis el compilador usa la precedencia para realizar las operaciones. En el ejemplo sin parntesis se har primero la multiplicacin y luego las sumas, muy distinto a utilizar los parntesis.

Orden de precedencia Descripcin

() Los parntesis son evaluados primero, de adentro hacia afuera.

*, /, % Se evalan segundo, de izquierda a derecha.+, - Se evalan tercero, de izquierda a derecha.


CONDICIONESLas condiciones, tambin llamadas decisiones, expresiones o control de programa, nos permiten tomardecisiones acerca del flujo del programa. Estas decisiones harn que se ejecute una u otra accin o algoritmo del programa. La estructura que nos permite el uso de condiciones es el if...else. Veamos un ejemplo en pseudo-cdigo.

Encender el aire acondicionado cuando la temperatura sea mayor o igual a 25 grados, sino apagarlo.

if temperatura >= 25Encender el AC

elseApagar el AC

end if

El ejemplo anterior usa pseuso-cdigo para representar el programa. El cdigo es una mezcla de lenguaje y sintaxis de programacin usado para representar el flujo del algoritmo, y no necesariamenterepresenta el cdigo definitivo en lenguaje C.

Aqu tenemos otro problema que requiere el uso de decisiones:

Permitir depositar o retirar dinero de una cuenta bancaria, y si el cliente decide retirar fondos,asegurarse que exista suficiente dinero.

El pseudo-cdigo podra ser como el siguiente:

if accion == depositarDepositar fondos en la cuenta

elseif balance < dinero a retirar

Fondos insuficientes para realizar la extraccinelse

Retire el dineroend if

end if

El primer punto interesante del cdigo anterior es que existe una condicin dentro de otra condicin. Si no se cumple la condicin padre no se evaluar la condicin anidada. En este caso, si la accin no es igual a depositar entonces se evaluar la condicin anidada.

Obsrvese que el indentado usado en el pseudo-cdigo es similar al usado en la sintaxis del lenguaje C. Esto es para mejorar la legibilidad.Distinto sera haber utilizado el siguiente pseudo-cdigo:

if accion == depositarDepositar fondos en la cuentaelseif balance < dinero a retirarFondos insuficientes para realizar la extraccinelseRetire el dinero


end ifend if

EXPRESIONES Y OPERADORES CONDICIONALESLos operadores condicionales se utilizan para armar las expresiones usadas para evaluar las condiciones.Cuando se usan estos operadores en una expresin, el resultado ser verdadero o falso.

Operador Descripcin

== Igual!= No igual> Mayor < Menor

>= Mayor o igual 5 FALSO5 < 5 FALSO5 >= 5 VERDADERO5 = 25Encender el AC

elseApagar el AC

end if

En lenguaje C el cdigo quedara as:

if(temperatura >= 25)// Encender el AC

else// Apagar el AC

La primera sentencia es la condicin, la cual chequea la expresin (temperatura >=25) por un resultado


verdadero o falso.Si fuera necesario ejecutar ms de una sentencia bajo una misma condicin, ser necesario colocar dichas sentencias entre llaves, como se muestra aqu:

if(temperatura >= 25) {// Encender el ACprintf(\nEl AC est encendido\n);

}else {

// Apagar el ACprintf(\nEl AC est apagado\n);

}

Las llaves pueden colocarse donde ms le guste a uno. Es una decisin que tomar el programador, pero tratemos de usar siempre la mismo estilo.Otro ejemplo:

if(temperatura >= 25) {

// Encender el ACprintf(\nEl AC est encendido\n);

}else {

// Apagar el ACprintf(\nEl AC est apagado\n);

}

ESTRUCTURA IF ANIDADAEl el ejemplo de la cuenta bancaria tenemos una estructura anidada. El mismo en lenguaje C quedara de la siguiente manera:

if(accion == depositar) {// Depositar fondos en la cuentaprintf(Fondos depositados);

}else {

if(balance < dinero) {// Fondos insuficientes para realizar la extraccinprintf(Fondos insuficientes);

}else {

//Retire el dineroprintf(Dinero retirado);

}}

Para terminar se muestra un ejemplo completo de manejo de cuenta bancaria, el cual permite ingresar el dinero a extraer.

#include main() {


int iSeleccion = 0; float fDinero = 0.0; float fBalance = 100.25;

printf("\n\tBANCO\n"); printf("Su saldo es %.2f\n",fBalance); printf("\n1\tDepositar"); printf("\n2\tExtraer\n"); printf("\nIngrese su eleccin: ");

scanf("%d", &iSeleccion);

if(iSeleccion == 1) { printf("\nIngrese el monto a depositar: "); scanf("%f", &fDinero); printf("\nSu nuevo balance es: $%.2f\n", fBalance + fDinero);

}//end if else if(iSeleccion == 2) {

printf("\nIngrese el monto a extraer: "); scanf("%f", &fDinero); if (fDinero > fBalance)

printf("\nFondos insuficientes\n"); else

printf("\nSu nuevo balance es: $%.2f\n",fBalance - fDinero); } //end if

} //end main function

INTRODUCCIN AL ALGEBRA BOOLEANAPara realizar expresiones ms complejas es necesario conocer de lgebra booleana. sta utiliza comnmente tres operadores: AND, OR y NOT para manipular dos valores: TRUE y FALSE.

Operador ANDEl operador and se usa para armar expresiones compuestas. Cada lado de la condicin debe ser verdadera (TRUE) para que la condicin completa sea verdadera. Por ejemplo:3==3 and 4==4Esta condicin evaluar dos expresiones que en este caso son verdaderas, por lo tanto toda la expresin ser verdadera.No ocurrir lo mismo aqu, que la expresin completa ser falsa, porque la primera condicin es falsa:3==4 and 4==4

Operador OREl operador or es similar al and porque se necesitan dos condiciones para armar una expresin compuesta. En este caso, solo se requiere una condicin verdadera para que toda la expresin sea verdadera. Por ejemplo:3==4 or 4==4Resultar que la segunda condicin es verdadera, suficiente para considerar toda la expresin verdadera.


Operador NOTEl operador booleano not es fcil de entender primeramente, pero luego al usarlo en lenguaje C puede llegar a confundir un poco.Esencialmente el operador not invierte el valor del resultado. Por ejemplo la expresin not(4==4) ser evaluada como falsa, ya que 4==4 es verdadera y luego el not invierte el valor del resultado.

Importante: cuando en lenguaje C se evala un valor numrico como booleano se usar la siguiente condicin: valores iguales a 0 son falsos y valores distintos de cero son verdaderos.

Orden de OperacionesEl orden en que se evalan los operadores booleanos en muy importante cuando se usan expresiones complejas como por ejemplo:z < y or z

int x=1;int y=2;int z=3;if(z < y || (z b) es verdadero, !(A>b) ser falso. Ejemplo:

if(!(3 10 )

printf("\nNmero fuera de rango\n"); else

printf("\nGracias\n"); }


OPERADOR TERNARIO ?:Se trata de un operador condicional, y asignar un valor luego de aplicar una condicin.Por ejemplo, si tenemos el siguiente cdigo:

if (a >= 0)result = 1;

elseresult = -1;

La variable result obtendr un valor (1 o -1) dependiendo del valor de la variable a.Esto se puede simplificar son el operador ternario de la siguiente forma:

result = (a >= 0) ? 1 : -1;

donde luego de la expresin a evaluar le sigue el carcter ?.Luego el valor resultante de la condicin verdares seguido del carcter :.Finalmente el valor resultante de la condicin falsa.

ESTRUCTURA SWITCH...CASELa estructura switch/case es otra estructura condicional usada para evaluar condiciones. A diferencia del if que nos puede entregar solo dos resultados, el switch/case nos permite elegir entremuchas opciones. Es ms comnmente usada cuando los programadores tienen un conjunto especfico de valores, comopor ejemplo en una entrada de seleccin. El siguiente ejemplo muestra su estructura:

switch(x) {case 1:

//x es 1break;

case 2://x es 2break;

case 3://x es 3break;

default://x no es ninguno de los valores anterioresbreak;

}

Esta misma estructura puede realizarse con expresiones if, pero llevara un total de cuatro if, resultando un bloque muy difcil de leer. En muchos compiladores el switch/case implica tambin ms velocidad y rendimiento que varios bloques if.

Como vemos, para cada valor de la variable x se ejecuta un bloque de sentencias distinto, en el que nonecesitamos llaves.Cuando C encuentra la sentencia break dentro de un bloque case, deja de evaluar cualquier otra expresin case. Si ningn bloque case es verdadero, se ejecutar el bloque de sentencias que sigueal default. ste no es obligatorio colocarlo.


Pueden colocarse varias expresiones case seguidas sin colocar un break. Esto es para evaluar varias condiciones mediante la expresin OR booleana. Por ejemplo:

switch(c) {case 'A':case 'a':

//c es 'a' o 'A'break;

case 'b':case 'B':

//c es 'b' o 'B'break;

}

ESTRUCTURAS DE LAZOLas estructuras de lazo permiten realizar operaciones de bucles o repeticiones de sentencias.

ESTRUCTURA WHILEMientras la condicin sea verdadera se ejecutarn las sentencias del bloque.

while(condicin) {sentencias...

}

Por ejemplo:

int contador=0;while(contador

Por ejemplo:

int contador;for(contador = 0 ; contador

Bucle infinito con whilewhile(1) {

// la condicin del while es siepre verdadera, // por lo tanto nunca saldr del lazo,// salvo que se ejecute una sentencia break.

}

otra forma de bucle con while:

do {// la condicin del while es siepre verdadera, // por lo tanto nunca saldr del lazo,// salvo que se ejecute una sentencia break.

} while(1);

En todos los casos se puede abortar la ejecucin dentro del bucle ejecutando la centencia break. Esto se ver en el tema siguiente.

Ejemplo: Realizar un programa que encienda y apague un LED en forma intermitente, con una cadencia de medio segundo.

main() {While(1) {

encender_led();delay_ms(500);apagar_led();delay_ms(500);

}}

Aqu vemos que el programa nunca sale del bucle principal, ya que su tarea es repetir las centencias indefinidamente. No vamos a entrar en detalle de como son los mtodos encender_led, apagar_led y delay_ms, ya que en este caso no es necesario.

SENTENCIAS BREAK Y CONTINUELas sentencias break y continue se usan para manipular el flujo del programa en estructuras de lazo. (Ya vimos que la estructura Switch/Case tambin usa la sentencia break).Cuando una sentencia break aparece dentro de una estructura de lazo, el lazo termina y el control del programa retorna a la siguiente sentencia luego del fin del lazo. El siguiente programa muestra como trabaja la sentencia break:

#include main() {

int x; for ( x = 10; x > 5; x-- ) {

if ( x == 7 ) break;

} //fin del bucle forprintf(\n%d\n, x);

}


En este programa, la condicin (x==7) se vuelve verdadera luego de la tercera iteracin. Luego, se ejecuta la sentencia break y sta enva el control del programa fuera del for, ejecutando el printf.La sentencia continue tambin se utiliza para estructuras de lazo. Cuando se ejecuta, todas las sentencias que le siguen hasta el final del lazo se saltean, continuando con la siguiente iteracin.

El siguiente bloque de programa muestra la sentencia continue:

#include main() {

int x; for ( x = 10; x > 5; x-- ) {

if ( x == 7 ) continue; printf("\n%d\n", x);

} //fin del bucle for}

En este caso, el nmero 7 no se mostrar en la salida, ya que cuando la condicin (x==7) sea verdadera se seguir con la siguiente iteracin, salteando as el printf.

OPERADORES (CONTINUACIN)Ya vimos los operadores aritmticos (+ - * /) y el de asignacin (=). Ahora veremos otros operadores usados en lenguaje C que nos permiten controlar variables para bucles y contadores.

Operadores de auto-incremento / decrementoPara incrementar o decrementar el valor de una variable usamos sentencias como las que siguen:

contador = contador + 1; // incrementa en 1contador = contador - 1; // decrementa en 1

Con los operadores de autoincremento y autodecremento podemos realizar estas operaciones de una forma ms sencilla y ms entendible. Veamos como quedan los ejemplos anteriores con los nuevos operadores:

contador++; // incrementa en 1++contador; // incrementa en 1contador--; // decrementa en 1--contador; // decrementa en 1

Los operadores ++ o -- se pueden utilizar a la izquierda o a la derecha de la variable a incrementar o decrementar. En los ejemplos anteriores no hay diferencia: siempre modifica el valor de la variable en uno.Pero estas expresiones pueden utilizarse a la vez dentro de una condicin. En estos casos la evaluacin de la variable se har antes o despus del incremento.

int contador = 0;if(contador++ == 1)

// no se ejecuta la sentencia

int contador = 0;


if(++contador == 1)// se ejecuta la sentencia

En este otro ejemplo se muestracomo vara la variable i en un post o pre incremento:

int x=0, y=0; printf("El valor de x es %d\n", x++); printf("El valor de y es %d\n", ++y);

Operadores +=, -=, *=, /=Para incrementar el valor de una variable en ms de 1 podemos usar una sentencia como la que sigue:

contador = contador + 2; // incrementa en 2

La forma corta de esta sentencia es:

contador += 2; // incrementa en 2

Usando los operadores -=, *=, /= podemos acortar la sentencia de la misma forma. Ejemplos:

contador -= 2; // decrementa en 2valor *= 10; // valor = valor * 10valor /= 10; // valor = valor / 10

OPERADORES DE BITSEstos operadores solo se pueden aplicar a expresiones enteras (a tipos de datos int) y se aplican a nivel de bit.Con esta manipulacin es posible cambiar solo un bit de un nmero entero de, por ejemplo 16 bits.

Character set Operador de bit

& AND (Y)| OR (O)^ XOR (O exclusiva)~ NOT (complemento a uno)

> Shift Right (Desplazamiento a la derecha)

Importante: No se deben confundir los operadores & con && ni | con ||. Los operadores | y & se aplican sobre bits, mientras que los operadores || y && son operadores lgicos.

El operador AND (&)El operador AND compara dos bits; si los dos son 1 el resultado es 1, en otro caso el resultado ser 0. Ejemplo:

c1 = 0x45 --> 01000101


c2 = 0x71 --> 01110001 --------------------------- c1 & c2 = 0x41 --> 01000001

char c1 = 0x45;char c2 = 0x71;printf(%X\n, c1 & c2 );

El operador OR (|)El operador OR compara dos bits; si cualquiera de los dos bits es 1, entonces el resultado es 1; en otrocaso ser 0. Ejemplo:

c1 = 0x47 --> 01000111 c2 = 0x53 --> 01010011 --------------------------- c1 | c2 = 0x57 --> 01010111

char c1 = 0x47;char c2 = 0x53;printf(%X\n, c1 | c2 );

El operador XOR (^)El operador OR exclusivo o XOR, dar como resultado un 1 si cualquiera de los dos operandos es 1, pero no los dos a la vez. Ejemplo:

c1 = 0x47 --> 01000111 c2 = 0x53 --> 01010011 --------------------------- c1 ^ c2 = 0x14 --> 00010100

char c1 = 0x47;char c2 = 0x53;printf(%X\n, c1 ^ c2 );

El operador de complemento (~)Este operador devuelve como resultado el complemento a uno del operando. Ejemplo:

c = 0x45 --> 01000101 ---------------------- ~c = 0xBA --> 10111010

char c = 0x45;char b = ~c;printf(%X\n, b );

Los operadores de desplazamiento (>)Los operadores de desplazamiento, >, mueven todos los bits en una posicin hacia la derecha o la izquierda un determinado nmero de posiciones. El formato general de la sentencia de desplazamiento a la derecha es:

resultado = variable >> num_pos_de_bit ;


y el formato general de desplazamiento a la izquierda es :

resultado = variable 2; '0 0 0 1 1 0 0 0' 24

char x = 7;x = x > 2;printf(%d\n, x );

Tambin pueden utilizarse como formas abreviadas >>= y = 1; // x = x >> 1;x

m = m & 0xF0; // Limpia nibble bajo de la variable mm = m ^ 0b00110000; // Invierte los bits 4 y 5 de la variable mm = 0b00011000; // Carga m con 0b00011000m = m >> 2; // Desplaza m 2 posiciones a la derecha // Ahora m ser 0b00000110n = 0xFF1F; // n ser 0xFF1Fn = n

Programacin estructurada y modular

Es un concepto cargado de historia en la programacin de computadoras. No es una tcnica nueva, todo lo contrario, pero resulta imprescindible a la hora de ser claros y generar cdigo fuente comprensible para quien quiera leerlo.Esta tcnica ya no se utiliza para aplicaciones de gran tamao, para eso se utiliza la programacin orientada a objetos, pero esto ya escapa a nuestro objetivo.

La programacin estructurada utiliza estructuras de control de secuencia, seleccin e iteracin, como las vistas anteriormente: for, while, switch, etc. No es el caso de, por ejemplo, la programacin en assembler, que utiliza muchos saltos incondicionales llevando a perder al programador en una maraa de saltos.

La programacin modular permite romper en pequeos problemas y fcilmente comprensibles los componentes que eventualmente forman un sistema completo, con el fin de hacerlo ms comprensible y manejable. En este captulo veremos como utilizar los conceptos de programacin estructurada, como tcnicas de diseo top-down y la creacin de sus propias funciones, para construir un cdigo eficiente y reutilizableen sus programas.

INTRODUCCINLa programacin estructurada y modular permite al programador llevar sistemas complejos a componentes manejables. En C estos componentes son conocidos como funciones, que son el corazn de este captulo. En esta seccin veremos tcnicas y conceptos de programacin estructuraday modular. Al terminar este captulo, usted estar capacitado a construir sus propias funciones en C.Los conceptos mas relevantes de la programacin estructurada y modular para este caso son los siguientes:

Diseo top-down (anlisis descendente o refinamiento sucesivo) Reusabilidad de cdigo Ocultamiento de informacin

Diseo top-down y botton-upTop-down es una estrategia de programacin que se basa en realizar mdulos en gran escala sin especificar demasiado, y a medida que se avanza en la programacin se van definiendo ms detalles de cada mdulo, mediante la construccin de nuevos mdulos ms pequeos. Fue desarrollado en los aos 70 por IBM y todava se sigue utilizando por laingeniera del software. Para llevar a cabo esta estrategia se debe tener un enfoque y conocimiento total del sistema a desarrollar. La codificacin no puede comenzar hasta queno se halla alcanzado un nivel de detalle suficiente.En el botton-up las partes individuales se disean con detalle y luego se enlazan unas con otras para formar componentes ms grandes.Actualmente se utilizan ambas en forma conjunta, debiendo siempre tener un conocimiento completo del sistema para un buen diseo.


Reusabilidad de cdigoAl reutilizar cdigo nos referimos a utilizar un componente realizado con estrategia bottom-up. Un cdigo especfico y con mucho nivel de detalle, pensado para que alguien ms lo utilice en otro proyecto, como una pieza de una maquinaria.La reusabilidad de cdigo se implementa como funciones en C. En concreto, los programadores crean funciones definidas para los problemas que generalmente necesitan resolver.

Ocultamiento de informacinEs un proceso conceptual mediante el cual los programadores ocultan el detalle de algunas funciones. Las funciones pueden ser vistas como cajas negras, las cuales realizan una tarea especfica. Estas tareas pueden tener una entrada de informacin y una salida de informacin. Cmo realiza el proceso interno no importa en el momento de utilizar esta caja negra. Solo la utilizamos.Por ejemplo la funcin printf() podemos verla como una caja negra que le llegan parmetros de que imprimir y la salida de informacin es la pantalla:

PROTOTIPOS DE FUNCIONESLos prototipos de funciones le dicen al C como sern las funciones y como usarlas. Es muy comn construir aplicaciones comenzando por los prototipos de funciones, indicando como se comportarn lasfunciones y como sern sus parmetros, antes de codificar dicha funcin. Esto le da ventajas a otros programadores para poder utilizar estos componentes sin todava estar terminados o probados completamente.Los programadores deben pensar en el propsito de la funcin, como obtendr los datos de entrada y cmo y qu retornar. Para demostrarlo, observemos este prototipo de funcion:

float sumarDosNumeros(int,int);

Este prototipo de funcin le dice a C las siguientes cosas respecto a la funcin: El tipo de dato que va a retornar, en este caso un tipo float. La cantidad de parmetros de entrada, en este caso son 2. El tipo de datos de los parmetros, en este caso ambos son enteros. El orden de los parmetros.

Los prototipos de funciones y sus implementaciones pueden variar. No es necesario que la funcin tenga parmetros de entrada ni tampoco que retorne algn valor. En estos casos el tipo de dato que seusar es el tipo void que significa nulo o sin tipo de dato.Veamos estos dos ejemplos:

int obtenerNumeroAleatorio(void);En este caso la palabra void significa que no se aceptan datos de entrada en la funcin, pero si retornaun tipo de datos entero.

void imprimirSuma(int,int);En este caso void est indicando que la funcin no retornar ningn valor.

Los prototipos de funcin deben colocarse fuera de la funcin main y antes que la funcin main


comience. Adems, pueden existir muchos prototipos de funcin ya que no hay lmite.

#include

void imprimirSuma(int,int);int obtenerNumeroAleatorio(void);

//function prototype main() { }

DEFINICIN DE FUNCIONESLa definicin de la funcin implementa el prototipo de la funcin. De hecho, la primera lnea de la definicin es similar al prototipo de la funcin.

#include

void imprimirSuma(int,int);int obtenerNumeroAleatorio(void);

//function prototype main() {

int rnd;

rnd = obtenerNumeroAleatorio();imprimirSuma(10, rnd);

}

void imprimirSuma(int n1, int n2){

printf(Suma: %d + %d = %d, n1, n2, n1+n2);}

int obtenerNumeroAleatorio(void){

//(implementar una funcin // que genere nmeros aleatorios)return 1234;

}

ALCANCE DE LAS VARIABLESEl alcance de una variable determina la vida de dicha variable en un lenguaje de programacin. Cuando la variable est fuera de su alcance significa que su valor se perdi. Existen dos tipos de alcance de variables en C, local y global. El alcance local ya lo vimos al comienzo de este texto, solo nos queda definir alcance global.


Alcance localLas variables locales se definen dentro de las funciones, como ya vimos su uso dentro de main(), o tambin podran definirse dentro de cualquier otra funcin.

main() {

int num1;num1 = 2;printf("%d", num1 + 10);

}

Cada vez que el programa anterior de ejecuta, C crea espacio en memoria para la variable entera num1. El valor de la variable se pierde cuando termina la funcin main().Como el alcance de la variable es local a la funcin donde se define, puede usarse el mismo nombre de variable en otras funciones. Veamos un ejemplo:

#include

int obtenerNumero();

main() {

int num1;num1 = 2;printf("%d y %d", num1 , obtenerNumero());

}

int obtenerNumero(){

int num1;num1 = 3;return num1;

}

Como cada variable se declara en su propio espacio local, o sea, en funciones diferentes, los valores no se sobreescriben, ya que C implementa posiciones de memoria diferentes para cada variable.

Alcance globalA veces es necesario el uso de una variable en muchas funciones, compartiendo el valor de la variableentre funciones. Para poder compartir datos, tendremos que crear y usar variables globales.Las variables globales deben crearse fuera de la toda funcin, inclusive la funcin main().Para ver como funcionan las variables globales, examinemos el siguiente ejemplo:

#include

int numero;int imprimirNumeroGlobal();

main() {

numero = 2;imprimirNumeroGlobal();

}


void imprimirNumeroGlobal(){

printf(%d, numero);}

La variable numero es global porque est definida fuera de las funciones. Se puede asignar un valor encualquiera de las funciones, y desde otra funcin ver ese valor. Esto es posible porque la posicin de memoria que C asign al ejecutar el programa es la misma mientras dure la ejecucin del programa.


Enteros (int)Nmeros en Punto Flotante (float)Caracteres (char)Literales enterosLiterales en punto flotanteLiterales de caracterCadena de LiteralesDesambiguacinEspecificadores de conversinEl sangrado y los espacios en blancoConvencin de nombres de las variablesIdentificar los tipos de datos con prefijosUsar maysculas y minsculas apropiadamenteDar a las variables nombres significativos

Precedencia de operadoresOperador ANDOperador OROperador NOTOrden de OperacionesOperador &&Operador ||Operador !Chequeando maysculas y minsculasChequeando un rango de valoresBucle infinito con forBucle infinito con whileOperadores de auto-incremento / decrementoOperadores +=, -=, *=, /=El operador AND (&)El operador OR (|)El operador XOR (^)El operador de complemento (~)Los operadores de desplazamiento (>)Ejemplos:Diseo top-down y botton-upReusabilidad de cdigoOcultamiento de informacinAlcance localAlcance global

Documents

Libro LenguajeC Javier Inicial Version 201504