sábado, 11 de marzo de 2017

¿Que es el codigo ASCCI?

SCII es el acrónimo inglés para American Standard Code for Information Interchange, o lo que es lo mismo, Código Estándar Estadounidense para el Intercambio de Información. Es un código de caracteres creado en 1963 por el ANSI (American National Standards Institute o Instituto Nacional Estadounidense de Estándares) ideado para evolucionar los códigos usados en telegrafía y cuya funcionalidad es representar numéricamente caracteres y símbolos, de tal forma que cualquier computador pueda entender esa información.

Una computadora solamente entiende de números, por lo que la inclusión de un estándar numérico para representar caracteres es algo fundamental.

El código ASCII es un código de 7 bits, es decir, siete 0 o 1, los cuales son la unidad mínima de información para un computador. El ASCII entró en vigor en un momento en que los computadores utilizaban grupos de 8 bits, es decir, un byte, el octavo bit es conocido como bit de paridad, el cual indica si ha habido un error o no en la transmisión de información.

El código ASCII comprende 128 caracteres, que van del 0 al 127.

El código ASCII no es necesario aprendérselo de memoria puesto que está en constante evolución y además cada vez van surgiendo nuevos estándares evolucionados de ésta forma de representación de caracteres para el envío de información. El código ASCII está basado en el alfabeto latino, por lo que la representación de caracteres de otras lenguas no están recogidas aquí.

Una de las más típicas funciones del código ASCII es la de poder escribir específicamente un carácter sin necesidad de teclearlo. Ejemplos claros son los caracteres que simbolizan el retorno de carro, el suprimir, el nulo o la tabulación, aunque también se pueden escribir letras del alfabeto, números y símbolos tales como los de puntuación o interrogación.

Prácticamente todos los lenguajes de programación vienen provistos de sentencias concretas para usar o representar en pantalla un caracter especificando su código ASCII.

Tipos de caracteres del código ASCII.

Los caracteres del código ASCII pueden ser divididos en dos clases:

Imprimibles – En éste conjunto entrarían todas las letras del alfabeto latino, números y símbolos de cualquier tipo, el “espacio” también está incluido. Es información que se puede mostrar, es decir, imprimir.

No imprimibles – Se corresponden con los primeros 32 caracteres del código ASCII y representan códigos de control del hardware o de un programa, algunos de ellos son el escape, el retorno de carro, cancelar, finalización, etc.

Variantes de ASCII

ASCII no es necesariamente el estándar usado universalmente, en la actualidad se han tenido que tener en cuenta multitud de caracteres más, por lo que tener un estándar basado solamente en 128 caracteres se ha ido quedando un poco obsoleto, no obstante han servido de punto de partida para el resto de estándares, respetándose siempre estos 128 primeros.

Así por ejemplo encontramos el ASCII Extendido, el cual continúa en el carácter 128 codificando caracteres especiales y adicionales a la tabla original llegando así a los 255 caracteres.

Tabla ASCII

Os dejo el recurso de varias formas, primero y principal la siguiente imagen que plasma perfectamente todo el código ASCII y ASCII Extendido. Muy recomendable para imprimir y tenerlo siempre a mano.



A continuación dejo la relación de los caracteres ASCII separada en sus dos grupos.

No imprimibles

00 = NULL ( Carácter nulo )
01 = SOH ( Inicio de encabezado )
02 = STX ( Inicio de texto )
03 = ETX ( Fin de texto, palo corazon barajas inglesas de poker )
04 = EOT ( Fin de transmisión, palo diamantes barajas de poker )
05 = ENQ ( Consulta, palo treboles barajas inglesas de poker )
06 = ACK ( Reconocimiento, palo picas cartas de poker )
07 = BEL ( Timbre )
08 = BS ( Retroceso )
09 = HT ( Tabulador horizontal )
10 = LF ( Nueva línea - salto de línea )
11 = VT ( Tabulador vertical )
12 = FF ( Nueva página - salto de página )
13 = CR ( ENTER - retorno de carro )
14 = SO ( Desplazamiento hacia afuera )
15 = SI ( Desplazamiento hacia adentro )
16 = DLE ( Escape de vínculo de datos )
17 = DC1 ( Control dispositivo 1 )
18 = DC2 ( Control dispositivo 2 )
19 = DC3 ( Control dispositivo 3 )
20 = DC4 ( Control dispositivo 4 )
21 = NAK ( Confirmación negativa )
22 = SYN ( Inactividad síncronica )
23 = ETB ( Fin del bloque de transmisión )
24 = CAN ( Cancelar )
25 = EM ( Fin del medio )
26 = SUB ( Sustitución )
27 = ESC ( Esc - escape )
28 = FS ( Separador de archivos )
29 = GS ( Separador de grupos )
30 = RS ( Separador de registros )
31 = US ( Separador de unidades )
127 = DEL ( DEL - Suprimir, borrar, eliminar )

Imprimibles

32 = espacio ( Espacio en blanco )
33 = ! ( Signos de exclamacion, signo de admiracion )
34 = " ( Comillas dobles , comillas altas o inglesas )
35 = # ( Signo numeral o almohadilla )
36 = $ ( Signo pesos )
37 = % ( Signo de porcentaje - por ciento )
38 = & ( Y - ampersand - et latina )
39 = ' ( Comillas simples, apóstrofe )
40 = ( ( Abre paréntesis )
41 = ) ( Cierra paréntesis )
42 = * ( Asterisco )
43 = + ( Signo mas, suma, positivo )
44 = , ( Coma )
45 = - ( Signo menos , resta , negativo , guión medio )
46 = . ( Punto )
47 = / ( Barra inclinada, división, operador cociente )
48 = 0 ( Número cero )
49 = 1 ( Número uno )
50 = 2 ( Número dos )
51 = 3 ( Número tres )
52 = 4 ( Número cuatro )
53 = 5 ( Número cinco )
54 = 6 ( Número seis )
55 = 7 ( Número siete )
56 = 8 ( Número ocho )
57 = 9 ( Número nueve )
58 = : ( Dos puntos )
59 = ; ( Punto y coma )
60 = < ( Menor que )
61 = = ( Signo igual, igualdad, igual que )
62 = > ( Mayor que )
63 = ? ( Cierra signo interrogación )
64 = @ ( Arroba )
65 = A ( Letra A mayúscula )
66 = B ( Letra B mayúscula )
67 = C ( Letra C mayúscula )
68 = D ( Letra D mayúscula )
69 = E ( Letra E mayúscula )
70 = F ( Letra F mayúscula )
71 = G ( Letra G mayúscula )
72 = H ( Letra H mayúscula )
73 = I ( Letra I mayúscula )
74 = J ( Letra J mayúscula )
75 = K ( Letra K mayúscula )
76 = L ( Letra L mayúscula )
77 = M ( Letra M mayúscula )
78 = N ( Letra N mayúscula )
79 = O ( Letra O mayúscula )
80 = P ( Letra P mayúscula )
81 = Q ( Letra Q mayúscula )
82 = R ( Letra R mayúscula )
83 = S ( Letra S mayúscula )
84 = T ( Letra T mayúscula )
85 = U ( Letra U mayúscula )
86 = V ( Letra V mayúscula )
87 = W ( Letra W mayúscula )
88 = X ( Letra X mayúscula )
89 = Y ( Letra Y mayúscula )
90 = Z ( Letra Z mayúscula )
91 = [ ( Abre corchetes )
92 = \ ( Barra invertida , contrabarra , barra inversa )
93 = ] ( Cierra corchetes )
94 = ^ ( Intercalación - acento circunflejo )
95 = _ ( Guión bajo , subrayado , subguión )
96 = ` ( Acento grave )
97 = a ( Letra a minúscula )
98 = b ( Letra b minúscula )
99 = c ( Letra c minúscula )
100 = d ( Letra d minúscula )
101 = e ( Letra e minúscula )
102 = f ( Letra f minúscula )
103 = g ( Letra g minúscula )
104 = h ( Letra h minúscula )
105 = i ( Letra i minúscula )
106 = j ( Letra j minúscula )
107 = k ( Letra k minúscula )
108 = l ( Letra l minúscula )
109 = m ( Letra m minúscula )
110 = n ( Letra n minúscula )
111 = o ( Letra o minúscula )
112 = p ( Letra p minúscula )
113 = q ( Letra q minúscula )
114 = r ( Letra r minúscula )
115 = s ( Letra s minúscula )
116 = t ( Letra t minúscula )
117 = u ( Letra u minúscula )
118 = v ( Letra v minúscula )
119 = w ( Letra w minúscula )
120 = x ( Letra x minúscula )
121 = y ( Letra y minúscula )
122 = z ( Letra z minúscula )
123 = { ( Abre llave curva - llaves curvas )
124 = | ( Barra vertical, pleca , linea vertical )
125 = } ( Cierra llave - llaves curvas )
126 = ~ ( Signo de equivalencia , tilde o virgulilla de la ñ )

ASCII Extendido Imprimible

128 = Ç ( Letra C cedilla mayúscula )
129 = ü ( Letra u minúscula con diéresis )
130 = é ( Letra e minúscula con acento agudo )
131 = â ( Letra a minúscula con acento circunflejo )
132 = ä ( Letra a minúscula con diéresis )
133 = à ( Letra a minúscula con acento grave )
134 = å ( Letra a minúscula con anillo )
135 = ç ( Letra c cedilla minúscula )
136 = ê ( Letra e minúscula con acento circunflejo )
137 = ë ( Letra e minúscula con diéresis )
138 = è ( Letra e minúscula con acento grave )
139 = ï ( Letra i minúscula con diéresis )
140 = î ( Letra i minúscula con acento circunflejo )
141 = ì ( Letra i minúscula con acento grave )
142 = Ä ( Letra A mayúscula con diéresis )
143 = Å ( Letra A mayúscula con anillo )
144 = É ( Letra E mayúscula con acento agudo )
145 = æ ( Diptongo latino ae minúscula )
146 = Æ ( Diptongo latino AE mayúscula )
147 = ô ( Letra o minúscula con acento circunflejo )
148 = ö ( Letra o minúscula con diéresis )
149 = ò ( Letra o minúscula con acento grave )
150 = û ( Letra u minúscula con acento circunflejo )
151 = ù ( Letra u minúscula con acento grave )
152 = ÿ ( Letra y minúscula con diéresis )
153 = Ö ( Letra O mayúscula con diéresis )
154 = Ü ( Letra U mayúscula con diéresis )
155 = ø ( Letra o minúscula con barra inclinada )
156 = £ ( Signo Libra Esterlina )
157 = Ø ( Letra O mayúscula con barra inclinada )
158 = × ( Signo de multiplicación )
159 = ƒ ( Símbolo de función, florín neerlandés )
160 = á ( Letra a minúscula con acento agudo )
161 = í ( Letra i minúscula con acento agudo )
162 = ó ( Letra o minúscula con acento agudo )
163 = ú ( Letra u minúscula con acento agudo )
164 = ñ ( Letra eñe minúscula - letra n con tilde - enie )
165 = Ñ ( Letra EÑE mayúscula - letra N con tilde - ENIE )
166 = ª ( Ordinal femenino, indicador de genero femenino )
167 = º ( Ordinal masculino, indicador de genero masculino )
168 = ¿ ( Abre signo interrogacion )
169 = ® ( Símbolo de Marca Registrada )
170 = ¬ ( Signo de negacion )
171 = ½ ( Un medio, mitad, fracción )
172 = ¼ ( Un cuarto, cuarta parte, fracción )
173 = ¡ ( Abre signos de exclamacion, signo de admiracion )
174 = « ( Abre comillas bajas, angulares, latinas o españolas )
175 = » ( Cierra comillas bajas, angulares, latinas o españolas )
176 = ░ ( Bloque color tramado densidad baja, carácter gráfico )
177 = ▒ ( Bloque color tramado densidad media, gráfico )
178 = ▓ ( Bloque color tramado densidad alta, carácter gráfico )
179 = │ ( Línea simple vertical de recuadro gráfico )
180 = ┤ ( Línea vertical con empalme de recuadro gráfico )
181 = Á ( Letra a mayúscula con acento agudo )
182 = Â ( Letra A mayúscula con acento circunflejo )
183 = À ( Letra A mayúscula con acento grave )
184 = © ( Símbolo Copyright, bajo derecho de autor )
185 = ╣ ( Doble línea vertical empalme izquierdo, gráfico )
186 = ║ ( Líneas doble vertical de recuadro gráfico, verticales )
187 = ╗ ( Línea doble esquina de recuadro gráfico )
188 = ╝ ( Línea doble esquina de recuadro gráfico )
189 = ¢ ( Signo centavo, céntimo o centésimo )
190 = ¥ ( Signo monetario YEN japonés, YUAN chino )
191 = ┐ ( Línea simple esquina de recuadro gráfico )
192 = └ ( Línea simple esquina de recuadro gráfico )
193 = ┴ ( Línea horizontal con empalme de recuadro gráfico )
194 = ┬ ( Línea horizontal con empalme de recuadro gráfico )
195 = ├ ( Línea vertical con empalme de recuadro gráfico )
196 = ─ ( Línea simple horizontal de recuadro gráfico )
197 = ┼ ( Líneas simples empalmes de recuadro gráfico )
198 = ã ( Letra a minúscula con tilde )
199 = Ã ( Letra A mayúscula con tilde )
200 = ╚ ( Línea doble esquina de recuadro gráfico )
201 = ╔ ( Línea doble esquina de recuadro gráfico )
202 = ╩ ( Doble línea horizontal empalme arriba, recuadro )
203 = ╦ ( Doble línea horizontal empalme abajo, recuadro )
204 = ╠ ( Doble línea vertical empalme derecho, recuadro )
205 = ═ ( Líneas doble horizontales de recuadro gráfico )
206 = ╬ ( Líneas dobles cruce de líneas de recuadro gráfico )
207 = ¤ ( Signo monetario - divisa general )
208 = ð ( Letra eth latina minúscula )
209 = Ð ( Letra eth latina mayúscula )
210 = Ê ( Letra E mayúscula con acento circunflejo )
211 = Ë ( Letra E mayúscula con diéresis )
212 = È ( Letra E mayúscula con acento grave )
213 = ı ( Letra minuscula i sin punto )
214 = Í ( Letra i mayúscula con acento agudo )
215 = Î ( Letra I mayúscula con acento circunflejo )
216 = Ï ( Letra i mayúscula con diéresis )
217 = ┘ ( Línea simple esquina de recuadro gráfico )
218 = ┌ ( Línea simple esquina de recuadro gráfico )
219 = █ ( Bloque color pleno solido, carácter gráfico )
220 = ▄ ( Medio bloque color pleno, mitad inferior, carácter gráfico )
221 = ¦ ( Barra vertical partida )
222 = Ì ( Letra I mayúscula con acento grave )
223 = ▀ ( Medio bloque color pleno, mitad superior, carácter gráfico )
224 = Ó ( Letra o mayúscula con acento agudo )
225 = ß ( Letra alemana eszett o ese-zeta )
226 = Ô ( Letra O mayúscula con acento circunflejo )
227 = Ò ( Letra O mayúscula con acento grave )
228 = õ ( Letra o minúscula con tilde )
229 = Õ ( Letra O mayúscula con tilde )
230 = µ ( Signo micro )
231 = þ ( Letra latina thorn minúscula )
232 = Þ ( Letra latina thorn mayúscula )
233 = Ú ( Letra U mayúscula con acento agudo )
234 = Û ( Letra U mayúscula con acento circunflejo )
235 = Ù ( Letra U mayúscula con acento grave )
236 = ý ( Letra y minúscula con acento agudo )
237 = Ý ( Letra Y mayúscula con acento agudo )
238 = ¯ ( Macron (marca larga), superguión, guión alto )
239 = ´ ( Acento agudo )
240 = ≡ ( Símbolo matemático de congruencia )
241 = ± ( Signo mas menos )
242 = ‗ ( ASCII 242 )
243 = ¾ ( Tres cuartos, fracción )
244 = ¶ ( Fin de párrafo - signo de calderón )
245 = § ( Signo de sección )
246 = ÷ ( Signo de división )
247 = ¸ ( Cedilla , virgulilla baja )
248 = ° ( Signo de grado, anillo )
249 = ¨ ( Diéresis )
250 = · ( Punto centrado, punto medio, coma georgiana )
251 = ¹ ( Superíndice uno )
252 = ³ ( Superíndice tres , potencia tres , al cubo )
253 = ² ( Superíndice dos , al cuadrado )
254 = ■ ( ASCII 254 )
255 = nbsp ( Espacio sin separación - non breaking space )

Codigo en C del juego del ahorcado

#include<stdio.h>
#include<string.h>
int main() {
    char frase[60],rep[100],temporal[100];
    char pal;
    int longitud,i,j,inicial,acertado=0,temp=0,oportunidades=5;
    int repetido=0,gano=0;
   
    printf("\tJuego del Ahorcado\n");
    printf("Introduzca la palabra a adivinar: ");
    gets(frase);
   
    system("cls");
   
    longitud = 0;
    inicial = 0;
    j = 0;
   
    rep[0] = ' ';
    rep[1] = '\0';
   
   
    do {
                system("cls");
        temp=0;
   
        if(inicial == 0) {
         for(i=0;i<strlen(frase);i++) {
          if(frase[i] == ' ') {
            temporal[i] = ' ';
             longitud++;
          }
          else {
             temporal[i] = '_';       
             longitud++;
          }
         }
        }
   
        inicial = 1;
       
        temporal[longitud] = '\0';
       
        for(i=0;i<strlen(rep);i++) {
           if(rep[i] == pal) {
            repetido = 1;
            break;
          }
          else {
           repetido = 0;
         }
        }
       
        if(repetido == 0) {
         for(i=0;i<strlen(frase);i++) {
                    if(frase[i] == pal) {
             temporal[i] = pal;
              acertado++;
              temp=1;
            }
          }
        }
       
        if(repetido == 0) {
         if(temp == 0) {
           oportunidades = oportunidades - 1;
         }
        }
        else {
         printf("Ya se ha introducido este caracter");
         printf("\n\n");
        }
       
        printf("\n");
       
        for(i=0;i<strlen(temporal);i++) {
         printf(" %c ",temporal[i]);
        }
       
        printf("\n");
       
        if(strcmp(frase,temporal) == 0) {
            gano = 1;
            break;
        }
       
        printf("\n");
        printf("Letras Acertadas: %d",acertado);
        printf("\n");
        printf("Oportunidades Restantes: %d",oportunidades);
        printf("\n");
   
        rep[j] = pal;
        j++;
       
        if (oportunidades==0)
        {
           break;
        }
     
        printf("Introduzca una letra:");
        scanf("\n%c",&pal);
      
    }while(oportunidades != 0);
   
   
    if(gano) {
                printf("\n\n");
        printf("Enhorabuena, has ganado.");
    }
    else {
                printf("\n\n");
        printf("Has perdido.");
    }
   
    printf("\n\n");
    system("PAUSE");
    return 0;
} 

Secuencias de escape en C

Las secuencias de escape se utilizan en los lenguajes de programación C y C ++ , y también en muchos más idiomas (con algunas variaciones) como Java y C # . Una secuencia de escape es una secuencia de caracteres que no se representa a sí misma cuando se utiliza dentro de un carácter o cadena literal , sino que se traduce en otro carácter o una secuencia de caracteres que pueden ser difíciles o imposibles de representar directamente. En C, todas las secuencias de escape constan de dos o más caracteres, el primero de los cuales es la barra invertida, \ ; Los caracteres restantes determinan la interpretación de la secuencia de escape. Por ejemplo, \ n es una secuencia de escape que denota un carácter de nueva línea . El resto de este artículo se centra en C; Es probable que otros lenguajes de programación tengan diferentes sintaxis y semántica.
Secuencia

Valor
\n
Nueva línea (new line). El cursor pasa a la primera posición de la línea siguiente
\r
Retorno de carro (carriage return). El cursor pasa a la primera posición de la línea donde nos encontremos.
\t
Tabulador. El cursor pasa a la siguiente posición de tabulación.
\a
Alerta. Crea un aviso bien de forma visible o bien mediante sonido.
\b
Espacio atrás (backspace). Hace retroceder el cursor una posición a la izquierda.
\f
Alimentación de página (form feed). Crea una nueva página.
\\
Muestra la barra invertida.
\”
Muestra la comilla doble.
\?
Muestra un interrogante.
\número_octal
Muestra el carácter ASCII correspondiente según el número octal que se haya especificado.
\xnúmero_hexadecimal
Muestra el carácter ASCII correspondiente según el número hexadecimal que se haya especificado.
\v
Tabulación vertical.
\'
Apóstrofo o comilla simple.

viernes, 10 de marzo de 2017

Codigo Cajero Automatico en Java

import javax.swing.JOptionPane;
public class Cajero {

public static void main(String[] args) {
int saldo;
String fin;
fin="";
saldo= 5000;
do{
String opcion = JOptionPane.showInputDialog(null," ¿Que deseas realizar:" + " \n " + " 1= Incrementar saldo " + " \n " + " 2= Decrementar saldo" + " \n " + "3= Revisar tu Saldo");
int no;
no = Integer.parseInt(opcion);
switch(no) {
case 1:
String abonar = JOptionPane.showInputDialog(null,"¿Cua… quieres abonar?");
double mas;
mas = Integer.parseInt(abonar);
JOptionPane.showMessageDialog(null,"Tu saldo es= $"+(saldo+mas));
break;
case 2:
String restar = JOptionPane.showInputDialog(null,"¿Cua… quieres retirar?");
double res;
res = Integer.parseInt(restar);
JOptionPane.showMessageDialog(null,"Tu saldo es= $"+(saldo-res));
break;
case 3:
JOptionPane.showMessageDialog(null,"Tu saldo actual es= $"+ saldo);
break;
}
JOptionPane.showInputDialog("¿Deseas hacer otra operación?" + " \n " + " 1= si" + " \n " + " 2= no");
//fin = Integer.parseInt(decision);
}while (fin=="");
JOptionPane.showMessageDialog(null,"Gr... por hacer uso del cajero");
System.exit(0);
}
}

Programación en C y C++: Simulación de un Cajero Automatico Sencillo

int main();
 
#include<iostream>
using namespace std;
 
double saldo(double retiro,double deposito,double saldot)
{
 
    system("clear");
    saldot=saldot+deposito-retiro;
    return saldot;
     
     
}
 
double deposit(double saldot)
{
     
    double dep=0;
    char sn;
    do
    {
LDeposito:
    system("clear");
    cout<<"Ingrese cantidad a Depositar: ";
    cin>>dep;
     
    while(dep<=0)
    {
        cout<<"Desea ingresar un valor valido s/S n/N: ";
        cin>>sn;
        if(sn=='S'||sn=='s')
            goto LDeposito;
        else
            exit(0);
    }
    saldot=saldo(0,dep,saldot);
    cout<<"Desea realizar otro deposito s/S n/N: ";cin>>sn;
    }while(sn=='s'||sn=='S');
     
return saldot;
}
 
double retiro(double saldot)
{
    double retir=0;
        char sn;
        system("clear");
        if (saldot==0)
        {cout<<"Ud. no cuenta con saldo \n";
            cout<<"Desea realizar otra operacion s/S n/N: ";cin>>sn;
            if(sn=='S'||sn=='s')
            {
            system("clear");
            main();
            }
            else
            exit(0);
         
        }
        do
        {
            LRetir:
            system("clear");
            cout<<"Ingrese cantidad a Retirar: ";
            cin>>retir;
 
            while(saldot<retir)
            {  
                cout<<"Ud. no cuenta con saldo suficiente para hacer ese retiro\n";
                goto reintentar;
            }
             
            while(retir<=0)
            {
            reintentar:
                cout<<"Desea ingresar un valor valido s/S n/N: ";
                cin>>sn;
                if(sn=='S'||sn=='s')
                    goto LRetir;
                else
                    exit(0);   
            }
            saldot=saldo(retir,0,saldot);
            cout<<"Desea realizar otro retiro s/S n/N: ";cin>>sn;
        }while(sn=='s'||sn=='S');
     
return saldot;
}
 
 
 
double Option(int option1,double saldot)
{
    switch(option1)
    {
    case 1:saldot=deposit(saldot);break;
    case 2:saldot=retiro(saldot);break;
    case 3: {
            saldot=saldo(0,0,saldot);
            cout<<"Usted cuenta con :"<<saldot<<" dolares\n";
            }break;
    case 4:{system("clear");cout<<"Cerrando Sistema...";exit(0);}break;
     
    }
 
         
return saldot;
}
 
 
int main()
{
    int opt;
    char sn;
    double saldot=0;
     
    do
    {
    system("clear");
    cout<<"\t\t\tOperaciones Bancarias\n";
    cout<<"1. Deposito\n";
    cout<<"2. Retiro\n";
    cout<<"3. Saldo\n";
    cout<<"4. Salir\n\n";
    cout<<"Elija el numero de la opcion: ";cin>>opt;
    saldot=Option(opt,saldot);
    cout<<"Desea continuar con otra operacion s/S n/N: ";cin>>sn;
    }while(sn=='s'||sn=='S');
    system("clear");
    cout<<"Cerrando Sistema...\n";exit(0);
    return 0;
}

Características de la Programacion Orientada a Objetos

Esta se divide en :
Abstracción
Denota las características esenciales de un objeto, donde se capturan sus comportamientos. Cada objeto en el sistema sirve como modelo de un "agente" abstracto que puede realizar trabajo, informar y cambiar su estado, y "comunicarse" con otros objetos en el sistema sin revelar "cómo" se implementan estas características. Los procesos, las funciones o los métodos pueden también ser abstraídos, y, cuando lo están, una variedad de técnicas son requeridas para ampliar una abstracción. El proceso de abstracción permite seleccionar las características relevantes dentro de un conjunto e identificar comportamientos comunes para definir nuevos tipos de entidades en el mundo real. La abstracción es clave en el proceso de análisis y diseño orientado a objetos, ya que mediante ella podemos llegar a armar un conjunto de clases que permitan modelar la realidad o el problema que se quiere atacar.
Encapsulamiento
Significa reunir todos los elementos que pueden considerarse pertenecientes a una misma entidad, al mismo nivel de abstracción. Esto permite aumentar la cohesión (diseño estructurado) de los componentes del sistema. Algunos autores confunden este concepto con el principio de ocultación, principalmente porque se suelen emplear conjuntamente.
Polimorfismo
Comportamientos diferentes, asociados a objetos distintos, pueden compartir el mismo nombre; al llamarlos por ese nombre se utilizará el comportamiento correspondiente al objeto que se esté usando. O, dicho de otro modo, las referencias y las colecciones de objetos pueden contener objetos de diferentes tipos, y la invocación de un comportamiento en una referencia producirá el comportamiento correcto para el tipo real del objeto referenciado. Cuando esto ocurre en "tiempo de ejecución", esta última característica se llama asignación tardía o asignación dinámica. Algunos lenguajes proporcionan medios más estáticos (en "tiempo de compilación") de polimorfismo, tales como las plantillas y la sobrecarga de operadores de C++.
Herencia
Las clases no se encuentran aisladas, sino que se relacionan entre sí, formando una jerarquía de clasificación. Los objetos heredan las propiedades y el comportamiento de todas las clases a las que pertenecen. La herencia organiza y facilita el polimorfismo y el encapsulamiento, permitiendo a los objetos ser definidos y creados como tipos especializados de objetos preexistentes. Estos pueden compartir (y extender) su comportamiento sin tener que volver a implementarlo. Esto suele hacerse habitualmente agrupando los objetos en clases y estas en árboles o enrejados que reflejan un comportamiento común. Cuando un objeto hereda de más de una clase se dice que hay herencia múltiple; siendo de alta complejidad técnica por lo cual suele recurrirse a la herencia virtual para evitar la duplicación de datos.
Modularidad
Se denomina "modularidad" a la propiedad que permite subdividir una aplicación en partes más pequeñas (llamadas módulos), cada una de las cuales debe ser tan independiente como sea posible de la aplicación en sí y de las restantes partes. Estos módulos se pueden compilar por separado, pero tienen conexiones con otros módulos. Al igual que la encapsulación, los lenguajes soportan la modularidad de diversas formas.
Principio de ocultación
Cada objeto está aislado del exterior, es un módulo natural, y cada tipo de objeto expone una "interfaz" a otros objetos que especifica cómo pueden interactuar con los objetos de la clase. El aislamiento protege a las propiedades de un objeto contra su modificación por quien no tenga derecho a acceder a ellas; solamente los propios métodos internos del objeto pueden acceder a su estado. Esto asegura que otros objetos no puedan cambiar el estado interno de un objeto de manera inesperada, eliminando efectos secundarios e interacciones inesperadas. Algunos lenguajes relajan esto, permitiendo un acceso directo a los datos internos del objeto de una manera controlada y limitando el grado de abstracción. La aplicación entera se reduce a un agregado o rompecabezas de objetos.
Recolección de basura
La recolección de basura (garbage collection) es la técnica por la cual el entorno de objetos se encarga de destruir automáticamente, y por tanto desvincular la memoria asociada, los objetos que hayan quedado sin ninguna referencia a ellos. Esto significa que el programador no debe preocuparse por la asignación o liberación de memoria, ya que el entorno la asignará al crear un nuevo objeto y la liberará cuando nadie lo esté usando. En la mayoría de los lenguajes híbridos que se extendieron para soportar el Paradigma de Programación Orientada a Objetos como C++ u Object Pascal, esta característica no existe y la memoria debe desasignarse expresamente.