Desarrollo APP

1. CURSO : TÉCNICAS DE PROGRAMACIÓN I
ALUMNO : SAFORAS CONTRERAS, Da
nny Henderson
SEMESTRE : IV
TURNO : MAÑANAS
HUANCAYO
2007
TERMINOS DEL LENGUAJE DE PROGRAMACIÓN C++
E.A.P INGENIERÍA INFORMÁTICA

2. 1. TIPOS DE DATOS CON SU RESPECTIVO TAMAÑO Y SU RANGO DE VALORES.
DECLARACIÓN EN UN PROGRAMA EN C
char (caracter)
El char es de tipo alfanumérico y puede almacenar un caracter, un signo de puntuación, o un
dígito numérico. En C un caracter es tomado como un número, y por ello, puede ser declarado
con o sin signo, y si no specificamos C asume que es con signo.
• Este tipo de variable es apto para almacenar numeros muy pequeños, asì como: cuantos
dedos tienes o cuantas letras tiene tu nombre.
[signed | unsigned] char <identificador>
int (entero)
Ésta variable almacena numeros enteros dentro del rango de su tamaño, y se utiliza para
almacenar números medianamente grandes, pero sin decimales.
• Aquí podemos almacenar numeros enteros como: el número de granos de arroz que hay en
3 kilos de arroz, cuantos habitantes hay en huancayo, etc.
[signed | unsigned] [short | long | long long] int <identificador>
[signed | unsigned] long long [int] <identificador>
[signed | unsigned] short [int] <identificador>
[signed | unsigned] short [int] <identificador>
float (coma flotante)
Aquí podemos almacenar numeros en formato de coma flotante, mantisa y exponente, en
palabras simple y comunes quiero decir que son números con decimales. Son adecuados para
variables de tipo real, como por ejemplo el tipo de cambio entre soles y dolares, o también
para numeros muy grandes como la cantidad se segundos que transcurren por año ó la
cantidad de dinero que tiene Bill Gates en su cuenta bancaria.
float <identificador>
Pero, lo curioso de float no es lo que grande puede ser el número que deseamos almacenar, si
no, la presición al calcular una operación. Por ejemplo:
float i = 123456789;
i=i+1;
i=i­123456789;
cout<<i;
Al parecer el valor que nos daría al calcular esta operación sería '1', ya que ;
123456789 + 1 = 1234567890 y 1234567890 ­ 123456789 = 1, sorpresivamente la
computadora nos muetra '0 'como resultado final. el resultado si seria el correcto en
operaciones con numeros mas pequeños. Por lo tanto, el float romperia los esquemas a la hora

3. de querer hacer un bucle o cálculos con mucha precisión y nos causaría algunos incovenientes.
¿Entonces para que usar el float, si es impresiso?, eso me pregunte la primera vez que estudie
sobre el uso de esta variable, y me fui dando cuenta que hay ciertas veces que son necesarias,
y creo que en la vida real se usa constantemente. Por ejemplo a la hora de programar con
temperaturas, estadísticas,etc.
double (coma flotante de precisión doble)
Esta variable almacena números con las mismas caractrísticas que el float, pero usa una mayor
precisión a la hora de hacer cálculos. Se pueden usar para variables de tipo real. Entonces
porqué no usar double o long double para ya no usar mas el float, la respuesta seria
simplemente para ahorrar recursos, un ejemplo seria en el compilador de Dev­C++ el cual usa
4 bytes al usar un float, 8 bytes en un double y 12 bytes en un long double. Como vemos la
proporcionalidad entre un double y un float es de 4 bytes a 12 bytes.
RANGOS DE LAS CONSTANTES ENTERAS Y REALES
• El valor que una variable puede almacenar tiene un límite.
• Este esta definido en los rangos de las constantes.
• Dichos rangos dependen de la máquina en que se trabaje.
Tipo Longitud Rango
unsigned char 8 bits 0 a 255
char 8 bits ­128 a 127
unsigned short 16 bits 0 a 65, 535
short 16 bits ­32,768 a 32,767
unsignted int 32 bits 0 a 4,294,967,295
int 32 bits ­2,147,483,648 a 2,147,483,647
unsigned long 32 bits 0 a 4,294,967,295
long 32 bits 2,147,483,648 a 2,147,483,647
float 32 bits 3.4E­38 a 3.4E+38
double 64 bits 1.7E­308 a 1.7E+308
long double 80 bits 3.4 E­4932 a 1.1E+4932
2. VARIABLES Y SU DECLARACIÓN EN UN PROGRAMA EN C
Una variable biene a ser un espacio que se reserva en el ordenador para poder almacenar
valores que podrían cambiar durante la ejecución de un programa, La variables principales
conocidas son: void, char, int, float y double.
las variables mencionadas anteriormente son utilizadas en C, pero en C++ también se incluye
el tipo bool.
Los modificadores pueden ser: shor, long, signed y unsigned, o las combinaciones entre ellos.
También se podría conciderar a los de tipo enumerados: enum.

4. Como iba mencionando, en C solo existen cinco tipos fundamentales y los tipos enumerados,
y en C++ se añade un tipo más, el bool, y el resto de los tipos que conocemos son derivados
de ellos.
Para la declaración de variables el esquema es siempre igual, primero especificamos el tipo y a
continuación una lista de variables.
En C++ podemos hacer uso de:
● Letras mayusculas y minusculas: C y C++ diferencian correctamente las mayusculas y
minúsculas, por ello será diferente escribir Conti. conti, cOnti, CoNtI, y todas sus
combinaciones entre mayusculas y minúsculas.
● Números y caracteres como el '_', jamas se nos permitirá utilizar un punto, coma, guión,
comillas, símbolos matemáticos. lógicos o simbolos de expresión (interrogantes,
exclamaciones: '?¿' '!¡').
● El primer carácter no puede ser un número.
Una declaración solo es una presentación, mientras que una definición posee a las
instrucciones con las cuales la función realizará su objetivo.
<tipo> <lista de variables>;
Otro tema muy importante es que Dependiendo de dónde se declaren las variables, podrán o
no ser accesibles desde distintas partes del programa. Podemos identificar 2 tipos de variables:
Las Variables Globales, que son aquellas que se declaran fuera de una función y las Variables
Locales se declaran dentro de una determinada función.
Ejemplo:
float s,i;
int main()
{
int x;
x=10;
for(int i=0; i<x; i++)
Mostrar(i);
i = 0.0;
while(x>0) {
i *= 10.3;
x--;
}
a) La variable de tipo float s tiene ámbito: GLOBAL
b) La variable de tipo int i tiene ámbito: LOCAL EN BUCLE
c) La variable de tipo float i tiene ámbito: GLOBAL
d) La variable de tipo int x tiene ámbito: LOCAL EN MAIN
REGLA GENERAL DE DECLARACIÓN DE VARIABLES
1. No se pueden declarar dos variables globales del mismo nombre.
2. No podemos declarar dos variables automaticas del mismo nombre.

5. 3. Si una variable global y una automatica tienen el mismo nombre la global sera destruida por
la automatica .
4. Si dos variables automaticas tienen el mismo nombre la del bloque superior elimina a la del
inferior
Caso 1: Caso 2: Caso 3: Caso 4:
tipo var; { tipo1 var1; func(i)
tipo var; tipo var; tipo2 var2; tipo1 i;
tipo var; {
} func(var1) tipo1 j;
tipo2 var1; ...
{ {tipo2 i;
tipo2 var2; tipo2 j;
... ...
} }
}
3. CONSTANTES Y SU DECLARACIÓN EN UN PROGRAMA EN C
Las constantes son datos cuyos valores permanecen constantes durante la ejecución de un
programa.
• Son los posibles valores que una variable puede tomar.
• Encontramos constantes numéricas y de caracteres.
• Las constantes numéricas pueden expresarse en base ocho, diez y 16.
• Ejemplos de constantes son:
­ caracteres : 'c','d','e','n','0'
­ decimal : 123, 345, ­1943, +4567
­ octal : 0123, 0456, 01234, 04567
­ hexadecimal : 0x12, 0xf5ad12, 0x12f103
Constantes "int"
Debemos tener mucho cuidado con las constantes numéricas, en C y C++ no es el mismo
número el 0123 que el 123. El primero es un número octal y el segundo decimal. Aquí es
necesario saber los fundamentos de los numeros hexadecimales, octales, como también de los
binarios, ya que nos facilitará la comprensión para no desperdiciar absurdamente los recursos
del ordenador. Por ejemplo: cada dígito en hexadecimal se puede sustituir por cuatro bits, el
0x0 por 0000, el 0x1 por 0001 ..... 0xf por 1111 así un byte pude tomar los valor
hexadecimales desde el 0x0 hasta 0xf, dos bytes desde 0x0000 hasta 0xffff. Así con la
notación octal es análogo.

6. Constantes "long"
Cuando utilizamos este tipo de constante debemos recordar que es necesario usar siempre el
sufijo L, principalmente no debemos olvidarlo cuando usamos expresiones condicionales ni en
las asignaciones.
long i = 101L; (asignación).
if(i == 0L) cout <<“muestrame el valor”; (expresión condicional).
Si no usamos el sufijo L es posible que nos salga un error en la compilación del programa,
como los conocidos mensajes de desbordamiento que recibia cuando compilaba con gcc o g++
. Lo mismo ocurre cuando usamos constantes long long.
Constantes "long long"
Parecido a la constante long que explique anteriormente, solo que con numeros mucho mas
grandes. A menudo es fácil saber ubicar el problema cuando hay errores de compilación al
usar long long: Cuando no ponemos LL como sufijo .
long long i = 16575476522787LL; (asignación)
if(i == 1LL) cout << "muestrame el valor " << endl; (expresión condicional).
Constantes "unsigned"
Cuando usamos esta constante también es necesario establecer un sufijo, y este es 'U'
unsigned int i = 123U;
if(i == 3124232U) cout << "muestrame el valor" << endl;
Constantes "unsigned long"
Este es resultado de una combinación entre dos constantes unsigned y long, y
lógicamente tenemos que combinar sus sufijos 'UL'
unsigned long i = 123456UL;
if(i == 3124232UL) cout << "muestrame el valor" << endl;
Constantes "unsigned long long"
Este también es una combinación entre 2 constantes, 'unsigned' y 'long long', y también
hay que combinar sus sufijos. 'ULL'.
unsigned long long I = 123456534543ULL;
if(I == 3124232ULL) cout << "muestrame el valor" << endl;
Constantes "float"
Las constantes float o coma flotante usan una sintaxis parecida a los anteriores, aquí lo que

7. hacemos es añadir un '.0' a las constantes de tipo enteros, es posible también usar 'f', y nos
mostrarà el resultado en un formato de precisión sencilla (float).
float i = 0.0;
if(i <= 1.0f) i+=0.01f;
Constantes "double"
Al no usar el sufijo en float, se tomará como una constante double.
double i = 0.0;
if(i <= 1.0) i += 0.01;
Constantes "long double"
Si usamos la 'L' se tomará como una constante de presición máxima.
long double i = 0.0L;
if(i <= 1.0L) i += 0.01L;
Constantes enteras
Aquí podemos hacer uso de combinaciones de lo prefijos "0" y "0x" con los sufijos "L", "U", y
"UL". Los sufijos pueden usarse en mayusculas y minusculas, pero es preferible ponerlas
mayúsculas para no confundir l (ele) con 1 (uno).
Constantes en punto flotante
Cuando la constante se pueda confundir con un entero, debemos añadir el '.0'.
Un ejemplo de su uso es el siguiente.
double i = 5e5; i=5*(10^5)
double j = 3.15e2; j=3,15*(10^2)
double pi = 3.141592e0; pi=3,141592*(10^0)
Constantes "char"
Para representar las constantes char es necesario hacerlo entre comillas simples, por ejemplo
'i', '9', 'K'.
A la hora de mandar a imprimir un caracter por pantalla, comunmente se usa la siguiente
sintaxis:
cout<<char(64); Esta sintaxis nos mostraría el caracter '@'
También podemos usar la forma hexadecimal:
cout<<char(0x3f); Esta linea de expresión nos muestra en pantalla el caracter '?'
Otra manera de usar los caracteres en hexadecimales es:
cout<<'x7c'; El cual nos mostrará ' | '
Si se pude representar en hexadecimal, facil que tambiénse puede en octal, y como sabemos
aqui solo son válidos los simbolos del 0 al 7.
cout<<'107'; Nos muestra la letra 'G'

8. Para la representación de caracteres especiales existe un mecanismo llamado secuencias de
escape. En este caso la comilla sencilla se define como ' '', Si queremos definir la barra
descendente pondremos '', ya que si escribimos '', habria error en la compilación.
Anteriormente se usaba el código ASCII de 7 bits (128 caracteres), pero quedó practicamente
en desuso por la sencilla razón que no aguanta caracteres como la 'ñ' o 'á'. Hoy en día se suele
usar ya el código ASCII de 8 bits (256 caracteres), por lo tanto al ser de 8 bits diremos que con
el tipo char utilizaríamos 1 byte.
Aparte de todo lo mencionado , podemos decir que también existen caracteres no imprimibles,
es decir que solo muetran algún tipo de evento como tabulacion, salto de linea, etc. Estos son:
0x00 NULL Carácter nulo
a 0x07 BELL Sonido de campanilla
b 0x08 BS Retroceso
f 0x0C FF Avance de página
n 0x0A LF Avance de línea
r 0x0D CR Retorno de línea
t 0x09 HT Tabulador horizontal
v 0x0B VT Tabulador vertical
0x5c Barra descendente
' 0x27 ' Comilla sencilla
" 0x22 " Comillas
? 0x3F ? Interrogación
4. OPERADORES ARITMÉTICOS Y ASIGNACIÓN. JERARQUIA DE OPERADORES
OPERADORES ARITMÉTICOS
Los operadores aritméticos llaman a una fución matemática, específicamente existen 2 tipos
de operadores aritméticos: unitarios y binarios.
Los operadores unitarios: Le corresponden POSITIVO(+) y NEGATIVO(­), y su función es de
asignar positivos o negativos a las expresiones. Son usados de la siguiente manera:
+ <expresión>
­ <expresión>
Los operadores binarios: Aquí encontramos las tradicinales operaciones aritméticas suma (+),
resta(­), multiplicación (*), división(/). Estos operadores son capaces de aceptar enteros o de
coma flotante.

9. <expresión> + <expresión>
<expresión> ­ <expresión>
<expresión> * <expresión>
<expresión> / <expresión>
Existe un quinto tipo, conocido como módulo; este operador nos devuelve el residuo de una
división entre numeros enteros, por lo tanto no es posible utilizarlo en coma flotante.
<expresión> % <expresión>
Por último, tenemos a dos operadores unitarios que implica escencialmente a la asignación de
variables, estos operadores son conocidos como incremento(++), el cual incrementa el valor
de la variable en una unudad y decremento(­­), que disminuye el valor de la variable en una
unidad.
Estos operadores puden ser usado de dos formas: Prefijo y Sufijo.
<variable> ++ post incremento
++ <variable> pre incremento
<variable>­­ post decremento
­­ <variable> pre decremento
Voy a explicar un poco de como se utiliza este operador.
Supongamos que i = 10 y j = 0
i = i + ++j; En este primer caso, el orden en que se evalua la expresión es:
++j = 1 j incrementa en una unidad (pre incremento).
i + 1 = 11 se resuelve la expresión i + (++j)
i = 11 finalmente i vale 11
i = i + j++; En este caso el orden de asignación sería:
i + j = 10 se evalua la expresión i + j
i = 10 i tomará el valor de 10
j = 1 finalmente j incrementa en una unidad (post incremento).
NOTA: La igualdad no es una operación matemática, es un operando de asignación de valores.
OPERADORES DE ASIGNACIÓN
Existen varias operaciones de asignación, talves el mas conocido es ==, pero eso no quiere
decir que es el único, los siguientes son también operadores de asignación: "=", "*=", "/=",
"%=", "+=", "­=", "<<=", ">>=", "&=", " ^=" y "|=". La sintaxis de uso es la siguiente:
<variable> <operador de asignación> <expresión>
En cualquier operador de los mostrados anteriormente la asignaión es de derecha a izquierda,
y además es igual utilizar: i op = j que i = i op j

10. 5. OPERADORES LÓGICOS Y RELACIONALES
OPERADORES LÓGICOS
Son operadores que relacionan expresiones lógicas como: '&&', '||' y '!'.
<expresión1> && <expresión2>
<expresión1> || <expresión2>
!<expresión>
OPERADORES RELACIONALES
Los operadores relacionales son "<", ">", "<=" y ">=", estos lo utilizamos cuando queremos
comprobar relaciones de igualdad o desigualdad.
<expresión1> > <expresión2>
<expresión1> < <expresión2>
<expresión1> <= <expresión2>
<expresión1> >= <expresión2>
6. SENTENCIAS EN C:
OPERACIONES DE ENTRADA Y SALIDA
Una operación de entrada tiene por objeto el obtener datos de los diferentes dispositivos de
entrada; generalmente del teclado, y de almacenarlos en memoria principal.
Una operación de salida tiene por objeto el obtener datos de memoria principal y sacarlos a los
dispositivos de salida, gneralmente la pantalla.
En C++
Objeto cout: cout: salida estándar: pantalla.
Se trata de un objeto global definido en "iostream.h"
Operador<<; para mostrar cadenas de caracteres y variables
Si queremos que lo que escribimos se muestre en pantalla tenemos que ponerlo entre
comillas.
cout<< “UCCI”<<endl; en este caso se muestra en pantalla UCCI.
También pude mostrarnos variables que hayan sufrido algún proceso de modificación.
int i=10;
cout<< i <<endl; en este otro caso se muestra en pantalla 10.
En C
Objeto printf: Prácticamente printf() y cout<< tienen la misma finalidad, el de imprimir en
pantalla una cadena de caracteres o variables, pero con una sintaxis diferente:
printf ("formato", var1, var2, ..., varN)
"formato": serie de caracteres.

11. Secuencias especiales:
• %d}: escribir un entero;
• %o}: escribir en octal;
• %x}: escribir en hexadecimal;
• %u}: escribir en entero sin signo;
• %f}: escribir un flotante o doble;
• %%}: escribir caracter '%';
Despliega en pantalla lo especificado por formato, sustituye var1 por la primera secuencia %,
var2 por la segundo % y así sucesivamente.
En C++
Objeto cin: cin: entrada estándar: teclado.
Se trata de un objeto global definido en "iostream.h"
Operador>>; para capturar variables que se ingresan desde el teclado.
{
int num;
cout<< “Ingrese un numero: ” <<endl;
cin>>num;
num=num*2;
cout<< “El doble es: ”<<num<<endl;
cin.ignore(): return 0:
}
En pantalla se mostraría en el orden siguiente: (El numero que ingreso es 100)
Ingrese un numero: 100
El doble es: 200
*En conclusión diriamos que cin me recibe las los datos que ingrese o que se me pidan.
En C
Objeto scanf:
scanf("formato", &var1, &var2, ..., &varN)
valores del formato:
• %d, %o, %x: se refiere a un decimal, octal o hexadecimal;
• %ld, %lo, %lx: lo mismo solo que para un long;
• %hd, %ho, %hx: lo mismo solo que para un short;
• %c: hace referencia a un caracter;
• %f, %lf: referencia a un float o double
Tiene el mismo comportamiento que cin, pero con una sintaxis diferente, ejempo:

12. #include<iostream>
using namespace std;
int main()
{
int i,j;
i=3;
j=4;
printf ("Universidad Continental n");
printf("Valor i:%d nValor j:%d",i,j);
}
7. ESTRUCTURA DE UN PROGRAMA EN C
[Directivas del pre­procesador: #includes y #defines]
[Declaración de variables Gloables]
[Prototipos de Funciones]
[Declaración de clases]
función main
[Definiciones de Funciones]
[Definiciones de Clases]
Ejemplo de una estructura general de un programa codificado en C.
tipo var1;
tipo var2;
tipo f1(par1)
tipo par1;
{ tipo var3;
{ tipo var4;
Bloque 1
Bloque2
}
}
tipo var5;
int main()
{
tipo var6;
}