Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
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
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)
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:
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:
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
break
case
char
const
Valor constante
continue
default
do
double
else
enum
extern
float
for
Estructura de control
goto
if
Sentencia condicional
int
long
register
return
short
signed
sizeof
static
struct
switch
Control de bifurcacin
typedef
union
unsigned
void
volatile
while
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
\t
\r
\\
Inserta un carcter \
\'
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:
Aqu tenemos una lista de los compiladores mas conocidos, que se generan ejecutables para PC bajo
Windows o en Linux:
Compilador
Descripcin
Editor y compilador para aplicaciones Windows y de consola,
Javier Rambaldo
Compilador
Descripcin
basado en GCC (Mingw).
http://www.bloodshed.net/
http://www.cygwin.com/
Digital Mars
http://www.digitalmars.com/
http://www.mingw.org/
DJ Delorie's C++
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
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
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
Tipo
Valor
Direccin
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
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 (;).
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
0b02011011
0187
0x85H1
+123.1
Javier Rambaldo
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:
/* 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:
#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
Descripcin
%d
%f
%.2f
%c
Muestra un caracter
%X
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:
#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);
}
#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).
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:
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).
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.
Javier Rambaldo
Ejemplos:
float fVelocidadInicial;
int iCantBits;
char cMenuSelection;
const float CONST_GRAVITY 9.8
const int MAX_BITS 16
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;
int temp;
int cont;
int iCantidadDeFilasDelMargenDeArriba;
char cNoApagado;
float 2pi;
float gananciaEn$;
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("%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
Divisin
Mdulo o Resto
Versin 201504
Javier Rambaldo
Operador
Descripcin
Ejemplo
Suma o Adicin
Resta o Substraccin
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:
Descripcin
()
*, /, %
+, -
Versin 201504
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
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:
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:
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
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.
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:
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:
#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");
}
#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:
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:
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.
Versin 201504
Javier Rambaldo
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.
#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.
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
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:
contador = contador + 2;
// incrementa en 2
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)
<<
>>
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.
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 );
c1 = 0x47
--> 01000111
c2 = 0x53
--> 01010011
--------------------------c1 ^ c2 = 0x14 --> 00010100
char c1 = 0x47;
char c2 = 0x53;
printf(%X\n, c1 ^ c2 );
Javier Rambaldo
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
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:
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;
}
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