Versin 201504

Javier Rambaldo

Indice

Introduccin............................................................................................................................4
Prerequisitos......................................................................................................................4
A quin est dirigido este libro..........................................................................................4
Lenguaje C..............................................................................................................................5
La funcin main()...............................................................................................................5
Comentarios.......................................................................................................................6
Palabras Clave....................................................................................................................6
Sentencias de Programa....................................................................................................7
Directivas...........................................................................................................................8
Compilador.........................................................................................................................9
Tipos de Datos Primarios..................................................................................................10
Identificadores..................................................................................................................11
Tipos de Datos.................................................................................................................12
Enteros (int).................................................................................................................12
Nmeros en Punto Flotante (float)...............................................................................12
Caracteres (char).........................................................................................................12
Literales............................................................................................................................13
Literales enteros......................................................................................................13
Inicializando Variables y el Operador de Asignacin........................................................13
Imprimiendo Contenidos de Variables.............................................................................14
Especificadores de conversin.....................................................................................14
Constantes.......................................................................................................................15
Estilos de Convencin de Programas...............................................................................16
El sangrado y los espacios en blanco..........................................................................16
Convencin de nombres de las variables....................................................................16
Identificar los tipos de datos con prefijos................................................................17
Usar maysculas y minsculas apropiadamente....................................................17
Dar a las variables nombres significativos..............................................................18
Aritmtica en C................................................................................................................19
Precedencia de operadores.........................................................................................20
Condiciones......................................................................................................................20
Expresiones y Operadores Condicionales........................................................................21
Estructura IF Simple.........................................................................................................22
Estructura IF Anidada.......................................................................................................23
Introduccin al Algebra Booleana....................................................................................24
Operador AND..............................................................................................................24
Operador OR................................................................................................................24
Operador NOT..............................................................................................................24
Orden de Operaciones.................................................................................................24
Estrucuras IF Compuestas................................................................................................24
Operador &&................................................................................................................25
Operador ||...................................................................................................................25
Operador !....................................................................................................................25
Chequeando maysculas y minsculas.......................................................................25
Chequeando un rango de valores................................................................................26
Operador Ternario ?:........................................................................................................26
Estructura Switch...Case..................................................................................................26
Estructuras de Lazo..........................................................................................................27
Estructura While...............................................................................................................27
Estructura For...................................................................................................................28
Estructura Do...While.......................................................................................................28
Bucles infinitos.................................................................................................................29
Bucle infinito con for....................................................................................................29
Bucle infinito con while................................................................................................29
Sentencias Break y Continue...........................................................................................29
Operadores (Continuacin)..............................................................................................30
Versin 201504

Javier Rambaldo

Operadores de auto-incremento / decremento...........................................................30

Operadores +=, -=, *=, /=..........................................................................................31
Operadores de Bits...........................................................................................................31
El operador AND (&).....................................................................................................32
El operador OR (|)........................................................................................................32
El operador XOR (^)....................................................................................................32
El operador de complemento (~)................................................................................32
Los operadores de desplazamiento (<< y >>)...........................................................33
Ejemplos:.....................................................................................................................33
Programacin estructurada y modular.................................................................................35
Introduccin.....................................................................................................................35
Diseo top-down y botton-up.......................................................................................35
Reusabilidad de cdigo................................................................................................35
Ocultamiento de informacin......................................................................................36
Prototipos de funciones....................................................................................................36
Definicin de funciones....................................................................................................37
Alcance de las variables...................................................................................................37
Alcance local................................................................................................................37
Alcance global..............................................................................................................38

Versin 201504

Javier Rambaldo

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.

PREREQUISITOS
Para 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 defecto
en cualquier sistema operativo, pero para windows te recomiendo el Notepad++ (http://notepad-plusplus.org/).
b- Como entorno de desarrollo o IDE te recomiendo el DevC++
(http://www.bloodshed.net/dev/devcpp.html)

A QUIN EST DIRIGIDO ESTE LIBRO

Este 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.

Versin 201504

Javier Rambaldo

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 bol

Combine los ingredientes secos
Prepare el molde
hornee 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, pero
sta 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.

Versin 201504

Javier Rambaldo

/* Mi primer programa en C */
#include <stdio.h>
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:

/* Mi primer
programa
en C */
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 C
main() // funcion principal

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

PALABRAS CLAVE
Existen 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.

Versin 201504

Javier Rambaldo

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 de

aplicacin 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.

Versin 201504

Javier Rambaldo

SENTENCIAS DE PROGRAMA
Muchas 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 funcin
printf() 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 nueva
lnea 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 <stdio.h>
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");
}
Versin 201504

Javier Rambaldo

DIRECTIVAS
Aqu tenemos nuevamente nuestro primer programa:

/* Mi primer programa en C */
#include <stdio.h>
main()
{
printf("Hola Mundo\n");
}
Observemos la sentencia que comienza con el numeral (#):

#include <stdio.h>
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.

COMPILADOR
Existen 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

Dev-C++ de Bloodshed Software

Versin 201504

Descripcin
Editor y compilador para aplicaciones Windows y de consola,
Javier Rambaldo

Compilador

Descripcin
basado 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 DOS
http://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-softwaredevelopment/

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 Microsoft

http://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
1
8
15
22
29

mar mie jue vie sb dom

2 3 4 5 6 7
9 10 11 12 13 14
16 17 18 19 20 21
23 24 25 26 27 28
30 31

TIPOS DE DATOS PRIMARIOS

Ahora veremos los conceptos esenciales de la memoria de la computadora y cmo obtener
Versin 201504

Javier Rambaldo

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

IDENTIFICADORES
Los 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_V1
contador
no_pulsado
SUM3
_vtext
Aqu hay identificadores NO vlidos:
36temperatura
%mayor
if
f23.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 referencia
a 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
Versin 201504

Javier Rambaldo

numrico hexadecimal en muy comn usarlo en programacin avanzada en lenguaje C para

referenciar una direccin de memoria especfica.
Nombre de la
variable

Valor

Tipo

Direccin de
memoria

Operando1

29

entero

FFF4

Resultado

756,21

flotante (decimal)

FDD6

Inicial

caracter

F03A

TIPOS DE DATOS
En 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.742134
1234.02
112.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
Versin 201504

Javier Rambaldo

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.

LITERALES
Los 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
11
011
0b11

//
//
//
//

literal
literal
literal
literal

hexadecimal equivalente al decimal 17

decimal
otal equivalente al decimal 9
binario equivalente al decimal 3

Estos son ejemplos de literales no reconocidos por el compilador.

Puedes descubrir porqu?

0b02011011
0187
0x85H1
+123.1

Literales en punto flotante

Los literales en punto flotante consisten en:
enteros decimales
punto decimal
fraccin decimal, y
Versin 201504

Javier Rambaldo

 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^6
2e-5
// = 2.0 * 10^-5
3E+10
// = 3.0 * 10^10
.09E34
// = 0.09 * 10^34

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

Cadena de Literales
Una 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!

C

//
//
//
//

cadena de 13 caracteres
dos espacios, largo 2 caracteres
letra, largo 1 caracter
cadena nula o vaca, largo = 0

Desambiguacin
Podra 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 Intro
Para anular este efecto, se debe colocar de la siguiente forma la cadena:

printf(\x09 1.0 Intro);

INICIALIZANDO VARIABLES Y EL OPERADOR DE ASIGNACIN

Cuando 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
Versin 201504

Javier Rambaldo

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 VARIABLES

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

#include <stdio.h>
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 conversin
La 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 <stdio.h>
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);
Versin 201504

Javier Rambaldo

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 especificar

cuantos 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.14
3.141
3.1415
3.14159
3.141592

CONSTANTES
Tambin 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 <stdio.h>
main()
Versin 201504

Javier Rambaldo

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

ESTILOS DE CONVENCIN DE PROGRAMAS

Antes 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 blanco

Este 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 <stdio.h>
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 variables

Antes 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
Versin 201504

Javier Rambaldo

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 prefijos

Cuando 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 apropiadamente

La 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 las
palabras con guin bajo (_).
Algunos adoptan convenciones ms restrictivas, como por ejemplo utilizar solo palabras en ingls o no
usar artculos, como en CantidadDeRepeticiones.
Versin 201504

Javier Rambaldo

Ejemplos:

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

Dar a las variables nombres significativos

Dar 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

Versin 201504

Javier Rambaldo

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 <stdio.h>; 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 <stdio.h>
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 ya
que 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 C
Como 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;

Versin 201504

Javier Rambaldo

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 <stdio.h>
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 de
la suma se la asigna a la variable del resultado.

Precedencia de operadores
La 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.

*, /, %
+, -

Versin 201504

Se evalan segundo, de izquierda a derecha.

Se evalan tercero, de izquierda a derecha.

Javier Rambaldo

CONDICIONES
Las condiciones, tambin llamadas decisiones, expresiones o control de programa, nos permiten tomar
decisiones 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 pseudocdigo.

Encender el aire acondicionado cuando la temperatura sea mayor o igual a 25 grados, sino
apagarlo.
if temperatura >= 25
Encender el AC
else
Apagar 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 necesariamente
representa 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 == depositar
Depositar fondos en la cuenta
else
if balance < dinero a retirar
Fondos insuficientes para realizar la extraccin
else
Retire el dinero
end 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 == depositar
Depositar fondos en la cuenta
else
if balance < dinero a retirar
Fondos insuficientes para realizar la extraccin
else
Retire el dinero
Versin 201504

Javier Rambaldo

end if
end if

EXPRESIONES Y OPERADORES CONDICIONALES

Los 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

<=

Menor o igual

Ejemplos de expresiones:
Expresin

Resultado

5 == 5

VERDADERO

5 != 5

FALSO

5>5

FALSO

5<5

FALSO

5 >= 5

VERDADERO

5 <= 5

VERDADERO

ESTRUCTURA IF SIMPLE
La estructura if en C es similar a la del pseudo-cdigo visto anteriormente. Para demostrarlo veamos
uno de los ejemplos anteriores.

if temperatura >= 25
Encender el AC
else
Apagar 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
Versin 201504

Javier Rambaldo

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 AC
printf(\nEl AC est encendido\n);
}
else {
// Apagar el AC
printf(\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 AC
printf(\nEl AC est encendido\n);
}
else
{
// Apagar el AC
printf(\nEl AC est apagado\n);
}

ESTRUCTURA IF ANIDADA
El 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 cuenta
printf(Fondos depositados);
}
else {
if(balance < dinero) {
// Fondos insuficientes para realizar la extraccin
printf(Fondos insuficientes);
}
else {
//Retire el dinero
printf(Dinero retirado);
}
}
Para terminar se muestra un ejemplo completo de manejo de cuenta bancaria, el cual permite ingresar
el dinero a extraer.

#include <stdio.h>
main()
{
Versin 201504

Javier Rambaldo

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 BOOLEANA

Para 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 AND
El 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==4
Esta 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 OR
El 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==4
Resultar que la segunda condicin es verdadera, suficiente para considerar toda la expresin
verdadera.

Versin 201504

Javier Rambaldo

Operador NOT
El 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 Operaciones
El orden en que se evalan los operadores booleanos en muy importante cuando se usan expresiones
complejas como por ejemplo:
z < y or z <= z and x < z
Debemos colocar parntesis para indicar el orden de la evaluacin booleana.
Por ejemplo, dando los valores x=1, y=2, z=3.
Si evaluamos la expresin de izquierda a derecha el resultado ser VERDADERO.
En cambio con los parntesis:
z < y or (z <= z and x < z)
el resultado de la evaluacin ser FALSO.

ESTRUCURAS IF COMPUESTAS
Para usar las condiciones booleanas en estructuras if en lenguaje C, y poder enlazar dos o ms
condiciones lgicas simples, se usan los siguientes operadores:
Character set
&&

Operador booleano
AND

||

OR

NOT

Operador &&
El operador && implementa el operador booleano and, y evala la expresin de izquierda a derecha.
Por ejemplo:

if(3>1 && 5<10)

printf(La expresin es verdadera\n);

Operador ||
El operador || implementa el operador booleano or, y evala la expresin de izquierda a derecha. Por
ejemplo:

if(3>5 || 5<=5)
printf(La expresin es verdadera\n);
Ejemplo usando ambos operadores:

Versin 201504

Javier Rambaldo

int x=1;
int y=2;
int z=3;
if(z < y || (z <= z && x < z)) {
printf(La expresin es verdadera\n);
}

Operador !
El operador ! Invierte el valor del resultado a evaluar. Por ejemplo si a es verdadero, !a ser falso. En
una expresin, si (a>b) es verdadero, !(A>b) ser falso.
Ejemplo:

if(!(3<=5) && !(5=5))

printf(La expresin es falsa\n);

Chequeando maysculas y minsculas

Ejemplo para determinar si una letra ingresada es correcta, sin importar si est en maysculas o
minsculas:

#include <stdio.h>
main()
{
char cResponse = '\0';
printf("Enter the letter A: ");
scanf("%c", &cResponse);
if( cResponse == 'A' || cResponse == 'a')
printf("\nCorrect response\n");
else
printf("\nIncorrect response\n");
}

Chequeando un rango de valores

Ejemplo para determinar si un valor ingresado est entre un rango de valores especfico:

#include <stdio.h>
main()
{
int iResponse = 0;
printf("Ingrese un nmero entre 1 y 10: ");
scanf("%d", &iResponse);
if( iResponse < 1 || iResponse > 10 )
printf("\nNmero fuera de rango\n");
else
printf("\nGracias\n");
}

Versin 201504

Javier Rambaldo

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;
else
result = -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...CASE
La 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 entre
muchas opciones.
Es ms comnmente usada cuando los programadores tienen un conjunto especfico de valores, como
por ejemplo en una entrada de seleccin. El siguiente ejemplo muestra su estructura:

switch(x) {
case 1:
//x es 1
break;
case 2:
//x es 2
break;
case 3:
//x es 3
break;
default:
//x no es ninguno de los valores anteriores
break;
}
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 no
necesitamos 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 sigue
al default. ste no es obligatorio colocarlo.

Versin 201504

Javier Rambaldo

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 LAZO
Las estructuras de lazo permiten realizar operaciones de bucles o repeticiones de sentencias.

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

while(condicin) {
sentencias...
}
Por ejemplo:

int contador=0;
while(contador <= 10) {
contador = contador +1;
printf(contador=%d,contador);
}

ESTRUCTURA FOR
La estructura for es la ms comnmente usada para realizar bucles de contadores. Tiene tres partes
separadas con ; (punto y coma) las cuales son:

for(inicializacin ; condicin ; incremento o decremento) {

sentencias...
}
'inicializacin': esta sentencia se ejecutar una sola vez y al comienzo del bucle, y se usa
generalmente para inicializar la variable del contador.
'condicin': esta sentencia se ejecuta en segundo lugar y tambin luego de terminar todo el bloque for.
Si la condicin es verdadera se ejecuta el bloque de sentencias.
'incremento o decremento': luego de ejecutar todo el bloque de sentencias se ejecuta esta parte del
for. Generalmente se utiliza para modificar la variable que inici el ciclo. Luego de sta se
evala nuevamente la condicin, iniciando un nuevo ciclo.
Versin 201504

Javier Rambaldo

Por ejemplo:

int contador;
for(contador = 0 ; contador <= 10 ; contador = contador + 1) {
printf(contador=%d,contador);
}
Cabe aclarar que pueden omitirse cualquiera de los tres parmetros de la estructura for. Pero no
deben omitirse los punto y comas.
El siguiente ejemplo permite hacer un bucle infinito, esto es, una repeticin de sentencias infinita. En
este caso la condicin no existe como expresin, pero sin embargo se evala como verdadera:

for(;;){
// sentencias que se repiten indefinidamente...
}

ESTRUCTURA DO...WHILE
Esta estructura es similar al while visto anteriormente, con la salvedad que se ejecuta al menos una
vez el bloque de sentencias. Luego, y mientras la condicin sea verdadera, se seguir repitiendo la
ejecucin de dicho bloque de sentencias.

do {
//sentencias
} while(condicin);
En este ejemplo vemos que se ejecuta una nica vez el bloque de sentencias, ya que la condicin
nunca es verdadera.

int contador=10;
do {
contador = contador +1;
printf(contador=%d,contador);
} while(contador < 10);

BUCLES INFINITOS
Muchas veces vamos a necesitar que un programa no salga nunca de un ciclo, de hecho, todo
programa en algn momento vuelve a iniciar su ciclo principal. Por ejemplo, en un sistema de alarma,
el programa estar en un bucle infinito esperando que se active. Mientras no ocurra el estado de
activacin permanecer en dicho bucle.
Para hacer bucles infinitos se pueden utilizar estructuras for o while.

Bucle infinito con for

for(;;) {
// no existe condicin de salida para este bucle,
// salvo que se ejecute una sentencia break.
}

Versin 201504

Javier Rambaldo

Bucle infinito con while

while(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 CONTINUE

Las 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 <stdio.h>
main()
{
int x;
for ( x = 10; x > 5; x-- ) {
if ( x == 7 )
break;
} //fin del bucle for
printf(\n%d\n, x);
}

Versin 201504

Javier Rambaldo

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 <stdio.h>
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 / decremento

Para incrementar o decrementar el valor de una variable usamos sentencias como las que siguen:

contador = contador + 1;
contador = contador - 1;

// incrementa en 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++;
++contador;
contador--;
--contador;

// incrementa en 1
// incrementa en 1
// decrementa en 1
// 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;
Versin 201504

Javier Rambaldo

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;
valor *= 10;
valor /= 10;

// decrementa en 2
// valor = valor * 10
// valor = valor / 10

OPERADORES DE BITS
Estos 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 Left (Desplazamiento a la izquierda)

>>

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
Versin 201504

--> 01000101
Javier Rambaldo

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 otro
caso 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 (<< y >>)

Los operadores de desplazamiento, << y >>, 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 ;

Versin 201504

Javier Rambaldo

y el formato general de desplazamiento a la izquierda es :

resultado = variable << num_pos_de_bit ;

Como los operadores desplazan bits en un sentido, en el otro extremo se llenar de ceros.
Se debe recordar que un desplazamiento no es una rotacin: los bits desplazados en un extremo no
vuelven al otro. Se pierden y los ceros trados los reemplazan.
Una aplicacin que tienen los operadores de desplazamiento de bits es para realizar multiplicaciones y
divisiones rpidas con enteros. Como se ve en la siguiente tabla, donde un desplazamiento a la
izquierda es multiplicar por 2 y uno a la derecha dividir por 2.

Char x

Ejecucin

Valor de x

X = 7;

'0 0 0 0 0 1 1 1'

X << 1;

'0 0 0 0 1 1 1 0'

14

X << 3;

'0 1 1 1 0 0 0 0'

112

X << 2;

'1 1 0 0 0 0 0 0'

192

X >> 1;

'0 1 1 0 0 0 0 0'

96

X >> 2;

'0 0 0 1 1 0 0 0'

24

char x = 7;
x = x << 1;
printf(%d\n,
x = x << 3;
printf(%d\n,
x = x << 2;
printf(%d\n,
x = x >> 1;
printf(%d\n,
x = x >> 2;
printf(%d\n,

x );
x );
x );
x );
x );

Tambin pueden utilizarse como formas abreviadas >>= y <<=, por ejemplo:

x >>= 1;
x <<= 2;

// x = x >> 1;
// x = x << 2;

Ejemplos:
char m;
// variable de 8 bits
int n;
// variable de 16 bits
m = 0x48;
// m ser 0x48
m = m & 0x0F;
// Despus de esto m ser 0x08
m = m | 0x24;
// Despus de esto m ser 0x2F
m = m & 0b11110000;
// Despus de esto m ser 0x20
n = 0xFF00;
// n ser 0xFF00
n = ~n;
// n ser 0x00FF
m = m | 0b10000001;
// Setea los bits 0 y 7 de la variable m
Versin 201504

Javier Rambaldo

m
m
m
m

=
=
=
=

m & 0xF0;
// Limpia nibble bajo de la variable m
m ^ 0b00110000;
// Invierte los bits 4 y 5 de la variable m
0b00011000;
// Carga m con 0b00011000
m >> 2;
// Desplaza m 2 posiciones a la derecha
// Ahora m ser 0b00000110
n = 0xFF1F;
// n ser 0xFF1F
n = n << 12;
// Desplazar n 12 posiciones a la izquierda
// Ahora n ser 0xF000
m = m << 8;
// Despus de esto m ser 0x00

Versin 201504

Javier Rambaldo

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 reutilizable
en sus programas.

INTRODUCCIN
La 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 estructurada
y 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-up

Top-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 la
ingeniera 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 que
no 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.

Versin 201504

Javier Rambaldo

Reusabilidad de cdigo
Al 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 informacin
Es 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 FUNCIONES
Los 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 las
funciones 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 se
usar 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 retorna
un 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
Versin 201504

Javier Rambaldo

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

#include <stdio.h>
void imprimirSuma(int,int);
int obtenerNumeroAleatorio(void);
//function prototype
main()
{
}

DEFINICIN DE FUNCIONES
La 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 <stdio.h>
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 VARIABLES

El 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.

Versin 201504

Javier Rambaldo

Alcance local
Las 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 <stdio.h>
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 global
A veces es necesario el uso de una variable en muchas funciones, compartiendo el valor de la variable
entre 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 <stdio.h>
int numero;
int imprimirNumeroGlobal();
main()
{
numero = 2;
imprimirNumeroGlobal();
}

Versin 201504

Javier Rambaldo

void imprimirNumeroGlobal()
{
printf(%d, numero);
}
La variable numero es global porque est definida fuera de las funciones. Se puede asignar un valor en
cualquiera 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.

Versin 201504

Javier Rambaldo