LENGUAJE C

Los comentarios
Los comentarios tienen el mismo propsito que en ensamblador: documentar y adornar el cdigo.
Es todo es texto que sigue a las barritas // y todo lo que est entre los signos /* y */. Se identifican
fcilmente porque suelen aparecer en color verde.
Ejemplos.
// ste es un comentario simple
/*
sta es una forma de comentar varias lneas a la vez.
Sirve mucho para enmascarar bloques de cdigo.
*/

Las sentencias
Un programa en C, en lugar de instrucciones, se ejecuta por sentencias. Una sentencia es algo as
como una mega instruccin, que hace lo que varias instrucciones del ensamblador.
Salvo casos particulares, donde su uso es opcional, una sentencia debe finalizar con un punto y
coma (;). As que tambin podemos entender que los ; sirven para separar las sentencias. Alguna
vez le que el compilador C lee el cdigo como si lo absorbiera con una caita, lnea por lnea, una a
continuacin de otra (evadiendo los comentarios por supuesto). Por ejemplo, la funcin main del
programa de arriba bien pudo escribirse del siguiente modo.
void main(void) { TRISB0=0; while(1) { RB0=1; pausa(); RB0=0; pausa(); } }

Sorprendido? Podrs deducir que los espacios y las tabulaciones solo sirven para darle un aspecto
ordenado al cdigo. Es una buena prctica de programacin aprender a acomodarlas.
Las sentencias se pueden clasificar en sentencias de asignacin, sentencias selectivas, sentencias
iterativas, de llamadas de funcin, etc. Las describiremos ms adelante.

Los bloques
Un bloque establece y delimita el cuerpo de las funciones y algunas sentencias mediante llaves ({}).
Como ves en el ejemplo de arriba, las funciones main y pausa tienen sus bloques, as como los
bucles while y for. Creo que exager con los comentarios, pero sirven para mostrarnos dnde
empieza y termina cada bloque. Podrs ver cmo las tabulaciones ayudan a distinguir unos bloques
de otros. Afortunadamente, los editores de los buenos compiladores C pueden resaltar cules son las
llaves de inicio y de cierre de cada bloque. Te ser fcil acostumbrarte a usarlas.

Ing. Flavio Condor De La Cruz

Las directivas
Son conocidas en el lenguaje C como directivas de preprocesador, de preprocesador porque son
evaluadas antes de compilar el programa. Como pasaba en el ensamblador, las directivas por s
mismas no son cdigo ejecutable. Suelen ser indicaciones sobre cmo se compilar el cdigo.
Entre las pocas directivas del C estndar que tambin son soportadas por los compiladores C para
Microcontroladores estn #include (para incluir archivos, parecido al assembler), #define (mejor
que el #define del ensamblador) y las #if, #elif, #endif y similares. Fuera de ellas, cada compilador
maneja sus propias directivas y sern tratadas por separado.

Las funciones
Si un programa en ensamblador se puede dividir en varias subrutinas para su mejor estructuracion,
un programa en C se puede componer de funciones. Por supuesto que las fuciones son muchsimo
ms potentes y, por cierto, algo ms complejas de aprender. Por eso ni siquiera el gran espacio que
se les dedica ms adelante es suficiente para abarcarlas. Pero, no te preocupes, aprenderemos de a
poco.
En un programa en C puede haber las funciones que sean posibles, pero la nunca debe faltar la
funcin principal, llamada main. Donde quiera que se encuentre, la funcin main siempre ser la
primera en ser ejecutada. De hecho, all empieza y no debera salir de ella.

Variables y Tipos de Datos

En ensamblador todas nuestras variables de programa eran registros de la RAM crudos, es decir,
datos de 8 bits sin formato. En los lenguajes de alto nivel estos registros son tratados de acuerdo con
formatos que les permiten representar nmeros de 8, 16 32 bits (a veces ms grandes), con signo o
sin l, nmeros enteros o decimales. Esos son los tipos de datos bsicos.
Las variables de los compiladores pueden incluso almacenar matrices de datos del mismo tipo
(llamadas arrays) o de tipos diferentes (llamadas estructuras). Estos son los tipos de datos
complejos.
Los siguientes son los principales tipos de datos bsicos del lenguaje C:

Tipo de dato
char
signed char

Tamao
8
8

Rango
0 a 255 -128 a 127
-128 a 127

unsigned char

0 a 255

(signed) int
unsigned int

16
16

-32,768 a 32,767
0 a 65,536

(signed) long

32

-2,147,483,648 a 2,147,483,647

unsigned long

32

0 a 4,294,967,295

float

32

+/- 1.18E38 a +/- 3.40E+38

Ing. Flavio Condor De La Cruz

Por desgracia, excepto signed char y unsigned char, los otros tipos establecen variables de tamaos
y/o rangos que suelen varar de un compilador C a otro. Otros compiladores tambin manejan los
tipos short, double, bool (o boolean), bit, etc. Esas divergencias pueden afectar la portabilidad de los
cdigos, adems de confundir a los programadores. Los valores de esta tabla son los utilizados por
la mayora de los compiladores C.
Los especificadores signed (con signo) mostrados entre parntesis son opcionales. Es decir, da lo
mismo poner int que signed int, por ejemplo. Es una redundancia que se suele usar para reforzar
su condicin o para que se vea ms ilustrativo.

Declaracin de variables
Esta parte es comparable, aunque lejanamente a cuando identificbamos nuestras variables del
ensamblador con las directivas equ o cblock endc. No se puede usar una variable si antes no se ha
declarado. La forma general ms simple de hacerlo es la siguiente:
data_type myvar;

donde data_type es un tipo de dato bsico o complejo, del compilador o definido por el usuario y
myvar es un identificador cualquiera, siempre que no sea palabra reservada.
Ejemplos.
unsigned char d;
char b;
signed char c;
int i;
signed int j;
unsigned int k;

//
//
//
//
//
//
//

Variable para enteros de 8 bits sin signo

Variable de 8 bits (para almacenar
caracteres ascii)
Variable para enteros de 8 bits con signo
i es una variable int, con signo
j tambin es una variable int con signo
k es una variable int sin signo

Tambin es posible declarar varias variables del mismo tipo, separndolas con comas. As nos
ahorramos algo de tipeo. Por ejemplo:
float area, side;
unsigned char a, b, c;

// Declarar variables area y side de tipo float

// Declarar variables a, b y c como unsigned char

Especificadores de tipo de datos

A la declaracin de una variable se le puede aadir un especificador de tipo como const, static,
volatile, extern, register, etc. Dichos especificadores tienen diversas funciones y, salvo const, se
suelen usar en programas ms elaborados. Como no queremos enredarnos tan pronto, lo dejaremos
para otro momento.
Una variable const debe ser inicializada en su declaracin. Despus de eso el compilador solo
permitir su lectura mas no su escritura. Ejemplos:
const int a = 100;
int b;

// Declarar constante a
// Declarar variable b

//...
b = a;
b = 150;

// Vlido
// Vlido

a = 60;

// Error! a es constante

Ing. Flavio Condor De La Cruz

a = b;

// Error! a es constante

Por ms que las variables constantes sean de solo lectura, ocuparn posiciones en la RAM del C.
Por eso muchas veces es preferible definir las constantes del programa con las clsicas directivas
#define (como lo hacamos en el ensamblador).
#define a 100

// Definir constante a

Los operadores
Sirven para realizar operaciones aritmticas, lgicas, comparativas, etc. Segn esa funcin se
clasifican en los siguientes grupos.

Operadores aritmticos
Adems de los tpicos operadores de suma, resta, multiplicacion y divisin, estn los operadores de
mdulo, incremento y decremento.

Operador
Accin
Suma
+
Resta
Multiplicacin
*
Divisin
/
Mdulo. Retorna el residuo de una divisin entera. Solo se debe usar con
%
++
--

nmeros enteros.
Incrementar en uno
Decrementar en uno

Ejemplos:
int a, b, c;

// Declarar variables a, b y c

a = b + c;
// Sumar a y b. Almacenar resultado en c
b = b * c;
// Multiplicar b por c. Resultado en b
b = a / c;
// Dividir a entre c. Colocar resultado en b
a = a + c b;
// Sumar a y c y restarle b. Resultado en a
c = (a + b) / c;
// Dividir a+b entre c. Resultado en c
b = a + b / c + b * b; // Sumar a ms b/c ms bb. Resultado en b
c = a % b;
// Residuo de dividir ab a c
a++;
// Incrementar a en 1
b--;
// Decrementar b en 1
++c;
// Incrementar c en 1
--b;
// Decrementar b en 1

Te recordaron a tus clases de lgebra del colegio? A diferencia de esas matemticas, estas
expresiones no son ecuaciones; significan las operaciones que indican sus comentarios.

Ing. Flavio Condor De La Cruz

Por lo visto, los operadores ++ y -- funcionan igual si estn antes o despus de una variable en una
expresin simple. Sin embargo, hay una forma (tal vez innecesaria y confusa para un novato, pero
muy atractiva para los que ya estamos acostumbrados a su uso) que permite escribir cdigo ms
compacto, es decir, escribir dos sentencias en una.

Si ++ o -- estn antes del operando, primero se suma o resta 1 al operando y luego se evala
la expresin.
Si ++ o -- estn despus del operando, primero se evala la expresin y luego se suma o
resta 1 al operando.

int a, b;

// Declarar variables enteras a y b

a = b++;
a = ++b;

// Lo mismo que a = b; y luego b = b + 1;

// Lo mismo que b = b + 1; y luego a = b;

if (a++ < 10)

{
// algn cdigo
}

// Primero comprueba si a < 10 y luego

// incrementa a en 1

if (++a < 10)

{
// algn cdigo
}

// Primero incrementa a en 1 y luego

// comprueba si a < 10

Operadores de bits
Se aplican a operaciones lgicas con variables a nivel binario. Aqu tenemos las clsicas
operaciones AND, OR inclusiva, OR exclusiva y la NEGACIN. Adicionalmente, he incluido en
esta categora los operaciones de desplazamiento a la derecha y la izquierda.
Si bien son operaciones que producen resultados anlogos a los de las instrucciones de ensamblador
iorlw y iorwf para la OR inclusiva, xorlw y xorwf para la OR exclusiva, andlw y andwf para la
AND y comf para la negacin; los operadores lgicos del C pueden operar sobre variables de
distintos tamaos, ya sean de 1, 8, 16 32 bits.

Operador
Accin
&
AND a nivel de bits
|
OR inclusiva a nivel de bits
^
OR exclusiva a nivel de bits
~
Complemento a uno a nivel de bits
<<
Desplazamiento a la izquierda
>>
Desplazamiento a la derecha
Ejemplos:
char m;
int n;
m
m
m
m

=
=
=
=

// variable de 8 bits
// variable de 16 bits

0x48;
m & 0x0F;
m | 0x24;
m & 0b11110000;

Ing. Flavio Condor De La Cruz

//
//
//
//

m ser 0x48
Despus de esto m ser 0x08
Despus de esto m ser 0x2F
Despus de esto m ser 0x20
5

n
n
m
m
m

=
=
=
=
=

0xFF00;
~n;
m | 0b10000001;
m & 0xF0;
m ^ 0b00110000;

//
//
//
//
//

m = 0b00011000;
m = m >> 2;

n ser 0xFF00
n ser 0x00FF
Setear bits 0 y 7 de variable m
Limpiar nibble bajo de variable m
Invertir bits 4 y 5 de variable m

// Cargar m con 0b00011000

// Desplazar m 2 posiciones a la derecha
// Ahora m ser 0b00000110

n = 0xFF1F;
n = n << 12;

// Desplazar n 12 posiciones a la izquierda

// Ahora n ser 0xF000;
// Despus de esto m ser 0x00

m = m << 8;

Fjate en la semejanza entre las operaciones de desplazamiento con >> y << y las operaciones del
rotacin del ensamblador. La diferencia es que cuando una variable se desplaza hacia un lado, los
bits que salen por all se pierden y los bits que entran por el otro lado son siempre ceros. Es por esto
que en la ltima sentencia, m = m << 8, el resultado es 0x00. Por cierto, en el lenguaje C no existen
operadores de rotacin. Hay formas alternativas de realizarlas.

Desplazamientos producidos por los operadores << y >>.

Operadores relacionales
Se emplean para construir las condiciones lgicas de las sentencias de control selectivas e iterativas,
como ya hemos podido apreciar en las secciones anteriores. La siguiente tabla muestra los
operadores relacionales disponibles.

Operador
Accin
==
Igual

Ing. Flavio Condor De La Cruz

!=

No igual

>

Mayor que

<

Menor que

>=

Mayor o igual que

<=

Menor o igual que

Operadores lgicos
Generalmente se utilizan para enlazar dos o ms condiciones lgicas simples. Por suerte, estos
operadores solo son tres y sern explicados en las prcticas del curso.

Operador
Accin
&&
AND lgica
||

OR lgica

Negacin lgica

Ejemplos:
if( !(a==0) )
{
// sentencias
}

// Si a igual 0 sea falso

if( (a<b) && (a>c) )

{
// sentencias
}

// Si a<b y a>c son verdaderas

while( (a==0) || (b==0) )

{
// sentencias
}

// Mientras a sea 0 b sea 0

Composicin de operadores
Se utiliza en las operaciones de asignacin y nos permite escribir cdigo ms abreviado. La forma
general de escribir una sentencia de asignacin mediante los operadores compuestos es:
obtect op= expression;

que es equivalente a la sentencia

object = object op expression;

op puede ser cualquiera de los operadores aritmticos o de bit estudiados arriba. O sea, op puede ser
+, - , *, /, %, &, | , ^, ~,<< >>. Nota: no debe haber ningn espacio entre el operador y el signo
igual.
Ejemplos:
int a;
a += 50;
a += 20;
a *= 2;
a &= 0xF0;
Ing. Flavio Condor De La Cruz

//
//
//
//
//

Declarar a
Es lo mismo que a
Tambin significa
Es lo mismo que a
Es lo mismo que a

= a + 50;
sumarle 20 a a
= a * 2;
= a & 0xF0;
7

a <<= 1;

// Es lo mismo que a = a << 1;

Precedencia de operadores
Una expresin puede contener varios operadores, de esta forma:
b = a * b + c / b;

// a, b y c son variables

A diferencia del lenguaje Basic, donde la expresin se evala de izquierda a derecha, en esta
sentencia no queda claro en qu orden se ejecutarn las operaciones indicadas. Hay ciertas reglas
que establecen dichas prioridades; por ejemplo, las multiplicaciones y divisiones siempre se
ejecutan antes que las sumas y restas. Pero es ms prctico emplear los parntesis, los cuales
ordenan que primero se ejecuten las operaciones de los parntesis ms internos. Eso es como en el
lgebra elemental de la escuela, as que no profundizar.
Por ejemplo, las tres siguientes sentencias son diferentes.
b = (a * b) + (c / b);
b = a * (b + (c / b));
b = ((a * b) + c)/ b);
Tambin se pueden construir expresiones condicionales, as:
if ( (a > b) && ( b < c) )
{
// ...
}

// Si a>b

b<c, ...

Sentencias selectivas
Llamadas tambin sentencias de bifurcacin, sirven para redirigir el flujo de un programa segn la
evaluacin de alguna condicin lgica.
Las sentencias if e ifelse son casi estndar en todos los lenguajes de programacin. Adems de
ellas estn las sentencias ifelse escalonadas y switchcase.

La sentencia if
La sentencia if (si condicional, en ingls) hace que un programa ejecute una sentencia o un grupo de
ellas si una expresin es cierta. Esta lgica se describe en el siguiente esquema.

Diagrama de flujo de la sentencia if.

Ing. Flavio Condor De La Cruz

La forma codificada sera as:

sentenciaA;
if ( expression )
{

// Si expression es verdadera,
//
ejecutar el siguiente bloque
// apertura de bloque

sentenciaB;
sentenciaC;
// algunas otras sentencias
}
// cierre de bloque
sentenciaX;

Despus de ejecutar sentenciaA el programa evala expression. Si resulta ser verdadera, se ejecutan
todas las sentencias de su bloque y luego se ejecutar la sentenciaX.
En cambio, si expression es falsa, el programa se saltear el bloque de if y ejecutar sentenciaX.

La sentencia if else
La sentencia if brinda una rama que se ejecuta cuando una condicin lgica es verdadera. Cuando el
programa requiera dos ramas, una que se ejecute si cierta expression es cierta y otra si es falsa,
entonces se debe utilizar la sentecia if else. Tiene el siguiente esquema.

Diagrama de flujo de la sentencia if else.

Expresando lo descrito en cdigo C, tenemos: (Se lee como indican los comentarios.)
SentenciaA;
if ( expression )
{
sentenciaB;
sentenciaC;
// ...
}
else
{
sentenciaM;
sentenciaN;
// ...
}
sentenciaX;
// ...

// Si expression es verdadera, ejecutar

// este bloque

// En caso contrario, ejecutar este bloque

Ing. Flavio Condor De La Cruz

Como ves, es bastante fcil, dependiendo del resultado se ejecutar uno de los dos bloques de la
sentencia if else, pero nunca los dos a la vez.

La sentencia if else if escalonada

Es la versin ampliada de la sentencia if else.
En el siguiente boceto se comprueban tres condiciones lgicas, aunque podra haber ms. Del
mismo modo, se han puesto dos sentencias por bloque solo para simplificar el esquema.
if ( expression_1 )
// Si expression_1 es verdadera ejecutar
{
// este bloque
sentencia1;
sentencia2;
}
else if ( expression_2 )
// En caso contrario y si expression_2 es
{
// verdadera, ejecutar este bloque
sentencia3;
sentencia4;
}
else if ( expression_3 )
// En caso contrario y si expression_3 es
{
// verdadera, ejecutar este bloque
sentencia5;
sentencia6;
}
else
// En caso contrario, ejecutar este bloque
{
sentencia7;
sentencia8;
};
// ; opcional
// todo...

Las expresiones se evualan de arriba abajo. Cuando alguna de ellas sea verdadera, se ejecutar
su bloque correspondiente y los dems bloques sern salteados. El bloque final (de else) se ejecuta
si ninguna de las expresiones es verdadera. Adems, si dicho bloque est vaco, puede ser omitido
junto con su else.

La sentencia switch
La sentencia switch brinda una forma ms elegante de bifurcacin mltiple. Podemos considerarla
como una forma ms estructurada de la sentencia if else if escalonada, aunque tiene algunas
restricciones en las condiciones lgicas a evaluar, las cuales son comparaciones de valores enteros.
Para elaborar el codigo en C se usan las palabras reservadas switch, case, break y default.
El siguiente esquema presenta tres cases pero podra haber ms, as como cada bloque tambin
podra tener ms sentencias.
switch ( expression )
{
case constante1: // Si expression = constante1, ejecutar este bloque
sentencia1;
sentencia2;
break;
case constante2: // Si expression = constante2, ejecutar este bloque
sentencia3;
sentencia4;

Ing. Flavio Condor De La Cruz

10

break;
case constante3: // Si expression = constante3, ejecutar este bloque
sentencia5;
sentencia6;
break;
default:
// Si expression no fue igual a ninguna de las
// constantes anteriores, ejecutar este bloque
sentencia7;
sentencia8;
break;
}
sentenciaX;
// todo...

donde constante1, constante2 y constante3 deben ser constantes enteras, por ejemplo, 2, 0x45, a,
etc. (a tiene cdigo ascii 165, que es, a fin de cuentas, un entero.)
expresion puede ser una variable compatible con entero. No es una expresin que conduce a una
condicin lgica como en los casos anteriores.
El programa solo ejecutar uno de los bloques dependiendo de qu constante coincida con
expression. Usualmente los bloques van limitados por llaves, pero en este caso son opcionales, dado
que se pueden distinguir fcilmente. Los bloques incluyen la sentencia break. Qu es eso?
La sentencia break hace que el programa salga del bloque de switch y ejecute la sentencia que sigue
(en el boceto, sentenciaX). Atento!: de no poner break, tambin se ejecutar el bloque del siguiente
case, sin importar si su constante coincida con expression o no.
No sera necesario poner el default si su bloque estuviera vaco.

Sentencias iterativas
Las sentencias de control iterativas sirven para que el programa ejecute una sentencia o un grupo de
ellas un nmero determinado o indeterminado de veces. As es, esta seccin no habla de otra cosa
que de los bucles en C.
El lenguaje C soporta tres tipos de bucles, las cuales se construyen con las sentencias while, do
while y for. El segundo es una variante del primero y el tercero es una versin mas compacta e
intuitiva del bucle while.

La sentencia while
El cuerpo o bloque de este bucle se ejecutar una y otra vez mientras (while, en ingls) una
expresin sea verdadera.

Ing. Flavio Condor De La Cruz

11

Diagrama de flujo de las sentencia while.

El bucle while en C tiene la siguiente sixtaxis y se lee as: mientras (while) expression sea
verdadera, ejecutar el siguiente bloque.
sentenciaA;
while ( expression )

// Mientras expression sea verdadera, ejecutar el

// siguiente bloque

{
sentenciaB;
sentenciaC;
// ...
};
sentenciaX;
// ...

// Este ; es opcional

Nota que en este caso primero se evala expression. Por lo tanto, si desde el principio expression es
falsa, el bloque de while no se ejecutar nunca. Por otro lado, si expression no deja de ser
verdadera, el programa se quedar dando vueltas para siempre.

La sentencia do - while
Como dije antes, es una variacin de la sentencia while simple. La principal diferencia es que la
condicin lgica (expression) de este bucle se presenta al final. Como se ve en la siguiente figura,
esto implica que el cuerpo o bloque de este bucle se ejecutar al menos una vez.

Diagrama de flujo de las sentencia do while.

Ing. Flavio Condor De La Cruz

12

La sintaxis para la sentencia do while es la siguiente y se lee: Ejecutar (do) el siguiente bloque,
mientras (while) expression sea verdadera.
sentenciaA;
do
{
sentenciaB;
sentenciaC;
// ...
} while ( expression ); // Este ; es mandatorio
sentenciaX;
// ...

La sentencia for
Las dos sentencias anteriores, while y do while, se suelen emplear cuando no se sabe de antemano
la cantidad de veces que se va a ejecutar el bucle. En los casos donde el bucle involucra alguna
forma de conteo finito es preferible emplear la sentencia for. (Inversamente, al ver un for en un
programa, debemos suponer que estamos frente a algn bucle de ese tipo.)
sta es la sintaxis general de la sentencia for en C:
for ( expression_1 ; expression_2 ; expression_3 )
{
sentencia1;
sentencia2;
// ...
};
// Este ; es opcional

Ahora veamos por partes cmo funciona:

expression_1 suele ser una sentencia de inicializacin.

expression_2 se evuala como condicin lgica para que se ejecute el bloque.
expression_3 es una sentencia que debera poner coto a expression_2.

Por la forma y orden en que se ejecutan estas expresiones, el bucle for es equivalente a la siguiente
construccin, utilizando la sentencia while. Primero se ejecuta expression_1 y luego se ejecuta el
bloque indicado tantas veces mientras expression_2 sea verdadera.
expression_1;
while ( expression_2 )
{
sentencia1;
sentencia2;
// ...
expression_3;
}

No obstante, de esa forma se ve ms rara an; as que, mejor, veamos estos ejemplos, que son sus
presentaciones ms clsicas. (i es una variable y a y b son constantes o variables):
for ( i = 0 ; i < 10 ; i++ )
{
sentencias;
}

Ing. Flavio Condor De La Cruz

13

Se lee: para (for) i igual a 0 hasta que sea menor que 10 ejecutar sentencias. La sentencia i++ indica
que i se incrementa tras cada ciclo. As, el bloque de for se ejecutar 10 veces, desde que i valga 0
hasta que valga 9.
En este otro ejemplo las sentencias se ejecutan desde que i valga 10 hasta que valga 20. Es decir, el
bucle dar 11 vueltas en total.
for ( i = 10 ; i <= 20 ; i++ )
{
sentencias;
}

El siguiente bucle for empieza con i inicializado a 100 y su bloque se ejecutar mientras i sea mayor
o igual a 0. Por supuesto, en este caso i se decrementa tras cada ciclo.
for ( i = 100 ; i >= 0 ; i-- )
{
sentencias;
}

Se pueden hacer muchas ms construcciones, todas coincindentes con la primera plantilla, pero
tambin son menos frecuentes.

Sentencias con bloques simples

Cuando las sentencias selectivas (como if) o de bucles (como while o for) tienen cuerpos o bloques
que constan de solo una sentencia, se pueden omitir las llaves. Aun as, es aconsejable seguir
manteniendo las tabulaciones para evitarnos confusiones.
Por ejemplo, las siguientes sentencias:
if(a > b)
{
a = 0;
}
if(a == b)
{
a++;
}
else
{
b--;
}
while( a >= b)
{
a = a + b;
}
for(i=0; i<=10; i++)
{
a = a*2;
}

bien se pueden escribir de la siguiente forma:

Ing. Flavio Condor De La Cruz

14

if(a > b)
a = 0;
if(a == b)
a++;
else
b--;
while( a >= b)
a = a + b;
for(i=0; i<=10; i++)
a = a*2;

Ing. Flavio Condor De La Cruz

15