E.A.

P  INGENIERÍA INFORMÁTICA

TERMINOS DEL LENGUAJE DE PROGRAMACIÓN C++

CURSO : TÉCNICAS DE PROGRAMACIÓN I

ALUMNO : SAFORAS CONTRERAS, Danny Henderson

SEMESTRE : IV

TURNO : MAÑANAS

HUANCAYO
2007
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 
 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.
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. 
 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.
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 
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'
 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.
<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
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. 
 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:
 #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; 
}