Tablas de multiplicar

#include <iostream>
using namespace std;
int imprime_tabla(int opcion);
int main()
{
int opcion=0;
cout << "Tablas de multiplicar\n";
cout<< "Ingresa que tabla deseas";
cin >> opcion;
imprime_tabla(opcion);
}
 int imprime_tabla(int opcion)
  {
        for (int b=1;b < 11;b++){
        cout << opcion;
        cout << " x ";
        cout << b;
        cout << "=";
        cout << opcion * b ;
        cout << "\n";
        }
  }

Calculadora

#include <iostream>
using namespace std;
float funcion_suma(float valor1,float valor2);
float funcion_resta(float valor1,float valor2);
float funcion_multiplica(float valor1,float valor2);
float funcion_divide(float valor1,float valor2);
int main()
{
    int opcion=0;
    float valor1=0;
    float valor2=0;
    cout <<"Calculadora\n" << "1-.Suma\n" <<"2-.Resta\n" <<"3-.Multiplicacion\n" << "4-.Division\n";
    cout << "Seleccionar una opcion\n";
    cin >> opcion;
    cout << "\n Ingresa valor1 ";
    cin >> valor1;
    cout << "\n Ingresa valor2 ";
    cin >> valor2;
    switch(opcion)

    {
        case 1: cout << "El resultado es: ";
        cout << funcion_suma(valor1, valor2);
        break;
        case 2: cout << "El resultado es: ";
        cout << funcion_resta(valor1, valor2);
        break;
        case 3: cout << "El resultado es: ";
        cout << funcion_multiplica(valor1, valor2);
        break;
        case 4: cout << "El resultado es: ";
        cout << funcion_divide(valor1, valor2);
        break;
    }
}
 float funcion_suma(float valor1, float valor2)
{
    return valor1+valor2;
}
float funcion_resta(float valor1, float valor2)
{
    return valor1-valor2;
}
float funcion_multiplica(float valor1, float valor2)
{
    return valor1*valor2;
}
float funcion_divide(float valor1, float valor2)
{
    return valor1/valor2;
}

Conceptos

¿Qué es una clase?

Es una construcción que permite crear tipos personalizados propios mediante la agrupación de variables de otros tipos, métodos y eventos. Una clase es como un plano. Define los datos y el comportamiento de un tipo. Si la clase no se declara como estática, el código de cliente puede utilizarla mediante la creación de objetos o instancias que se asignan a una variable. La variable permanece en memoria hasta todas las referencias a ella están fuera del ámbito. Si la clase se declara como estática, solo existe una copia en memoria y el código de cliente solo puede tener acceso a ella a través de la propia clase y no de una variable de instancia.

Cada una tiene sus propias características y ventajas. Un programador que conoce estas características sabe cuando debe usar una y no otra, de manera que su desarrolla un buen software. Los tipos de clases son:

Class. Public: Son muy comunes, accesibles desde cualquier otra clase en la misma librería (de otro modo hay que importarlas).

Class. Abstract: Aquellas que tienen por lo menos un método abstracto. No implementan sus métodos, sino que dan las bases para que sean implementados en la herencia.

Class. Final: Son las que terminan la cadena de herencia. Útiles por motivos de seguridad y eficiencia de un programa, ya que no permiten crear más sub-divisiones por debajo de esta clase.

Class. Synchronizable: Especifica que sus métodos son sincronizados, evitando problemas con los thread (hilo de ejecución), de forma que estos no pueden empezar a correr un método si no ha acabado el otro.

¿Qué es una herencia?

La herencia es específica de la programación orientada a objetos, donde una clase nueva se crea a partir de una clase existente. La herencia (a la que habitualmente se denomina subclase) proviene del hecho de que la subclase (la nueva clase creada) contiene las atributos y métodos de la clase primaria. La principal ventaja de la herencia es la capacidad para definir atributos y métodos nuevos para la subclase, que luego se aplican a los atributos y métodos heredados.

Esta particularidad permite crear una estructura jerárquica de clases cada vez más especializada. La gran ventaja es que uno ya no debe comenzar desde cero cuando desea especializar una clase existente. Como resultado, se pueden adquirir bibliotecas de clases que ofrecen una base que puede especializarse a voluntad (la compañía que vende estas clases tiende a proteger las datos miembro usando la encapsulación).

¿Qué es un polimorfismo?

La palabra polimorfismo proviene del griego y significa que posee varias formas diferentes. Es uno de los conceptos esenciales de la programación orientada a objetos. Así como la herencia está relacionada con las clases y su jerarquía, el polimorfismo lo está con los métodos.

En general, hay tres tipos de polimorfismo: el polimorfismo de sobrecarga, el polimorfismo paramétrico (también llamado polimorfismo de plantillas) y el polimorfismo de inclusión (también llamado redefinición o subtipado).

Polimorfismo de sobrecarga

El polimorfismo de sobrecarga ocurre cuando las funciones del mismo nombre existen, con función similar, en clases que son completamente independientes unas de otras (estas no tienen que ser clases secundarias de la clase objeto). Por ejemplo, la clase complex, la clase image y la clase linkpueden todas tener la función display. Esto significa que no necesitamos preocuparnos sobre el tipo de objeto con el que estamos trabajando si todo lo que deseamos es verlo en la pantalla. 

Por lo tanto, el polimorfismo de sobrecarga nos permite definir operadores cuyos comportamientos varían de acuerdo a los parámetros que se les aplican. Así es posible, por ejemplo, agregar el operador + y hacer que se comporte de manera distinta cuando está haciendo referencia a una operación entre dos números enteros (suma) o bien cuando se encuentra entre dos cadenas de caracteres (concatenación). 

Polimorfismo paramétrico

El polimorfismo paramétrico es la capacidad para definir varias funciones utilizando el mismo nombre, pero usando parámetros diferentes (nombre y/o tipo). El polimorfismo paramétrico selecciona automáticamente el método correcto a aplicar en función del tipo de datos pasados en el parámetro. 

Por lo tanto, podemos por ejemplo, definir varios métodos homónimos de addition() efectuando una suma de valores. El método int addition(int,int) devolvería la suma de dos números enteros. Por su parte, float addition(float, float) devolvería la suma de dos flotantes. En cuanto a char addition(char, char) daría por resultado la suma de dos caracteres definidos por el autor. 

Una signature es el nombre y tipo (estático) que se da a los argumentos de una función. Por esto, una firma de método determina qué elemento se va a llamar. 

Polimorfismo de subtipado

La habilidad para redefinir un método en clases que se hereda de una clase base se llama especialización. Por lo tanto, se puede llamar un método de objeto sin tener que conocer su tipo intrínseco: esto es polimorfismo de subtipado. Permite no tomar en cuenta detalles de las clases especializadas de una familia de objetos, enmascarándolos con una interfaz común (siendo esta la clase básica). 

Imagina un juego de ajedrez con los objetos rey, reina, alfil, caballo, torre y peón, cada uno heredando el objeto pieza. El método movimiento podría, usando polimorfismo de subtipado, hacer el movimiento correspondiente de acuerdo a la clase objeto que se llama. Esto permite al programa realizar el movimiento.de_pieza sin tener que verse conectado con cada tipo de pieza en particular.

¿Cómo hacer métodos (funciones) en una clase?

 En el método main se incluye como parámetro para su invocación un array de Strings. Este array permitiría iniciar el programa con argumentos adicionales: por ejemplo podríamos indicarle una gama de colores de presentación entre varias posibles, o si se trata de un juego, si se ejecuta en modo 1 ó 2 jugadores, etc. En este caso suponiendo que la clase que contiene el main se llama juego, para la ejecución por consola escribiríamos > java juego TwoPlayers Red, donde TwoPlayers y Red son parámetros que condicionan la ejecución del programa. Cada palabra después del nombre de la clase se introduce en un array que se pasa al array Args[ ] que va como parámetro de la clase main. No obstante, es muy frecuente que los programas se inicien sin parámetros, para lo cual simplemente en consola habríamos de escribir java y el nombre de la clase.

Un método de instancia es el que se invoca siempre sobre una instancia (objeto) de una clase. Por ejemplo p1.getNombre(); siendo p1 un objeto de tipo Persona es un método de instancia: para invocarlo necesitamos una instancia de persona. Un método de clase es aquel que puede ser invocado sin existir una instancia.

Ejemplo:

// Programa OPP01.CPP
#include <iostream>
#include <cstring>

using std::cout;
using std::endl;


// Esto define la clase CRender
class CRender {
public:
    char buffer[255];
    void m_Renderizar(const char *cadena);
};


/* implementar m_Renderizar() para la c;*/
void CRender::m_Renderizar(const char *cadena){
    strcpy(buffer, cadena);//copia la cadena
    return;
}


int main (int argc, char **argv){
    // crear 2 objetos CRender
    CRender render1, render2;

    render1.m_Renderizar("Inicializando el objeto render1");
    render2.m_Renderizar("Inicializando el objeto render2"); 
   
    cout << "buffer en render1: ";
    cout << render1.buffer << endl;   // tenemos acceso a buffer ya que es publico.

    cout << "buffer en render2: ";
    cout << render2.buffer << endl;

return (0);
}

Este programa imprime:

buffer en render1: Inicializando el objeto render1

buffer en render2: Inicializando el objeto render2

Ejemplo de Funciones

Ejemplo de paso de parámetros por valor:
Por valor:

#include <iostream>

using namespace std;

iut << "Introduce un numero entero: ";

    cin >> num;

    rent invertir (int);

int main()

{   int num;

    int resultado;

    cosultado = invertir(num);

    cout << "Numero introducido: " << num << endl;

    cout << "Numero con las cifras invertidas: " << resultado << endl;

}

int invertir(int num)

{

    int inverso = 0, cifra;

    while (num != 0)

    {

        cifra = num % 10;

        inverso = inverso * 10 + cifra;

        num = num / 10;

    }

    return inverso;

}

Por referencia:

#include <iostream>
using namespace std;
 
int funcion(int &n, int &m);
 
int main() { 
   int a, b;
 
   a = 10; b = 20; 
   cout << "a,b ->" << a << ", " << b << endl;
   cout << "funcion(a,b) ->" << funcion(a, b) << endl; 
   cout << "a,b ->" << a << ", " << b << endl; 
   /* cout << "funcion(10,20) ->" 
           << funcion(10, 20) << endl; // (1)
   es ilegal pasar constantes como parámetros cuando 
   estos son referencias */ 
   
   return 0; 

}
 
int funcion(int &n, int &m) {
   n = n + 2; 
   m = m - 5; 
   return n+m; 
}

Calculadora Básica

La calculadora básica realiza en CodeBlocks tiene 4 funciones: sumar, restar,y potencia dividir y multiplicar. Este código fue realizado con la "Instrucción Switch".
Si queremos realizar alguna operación se debe de poner los siguientes signos:
+ = Suma
- = Resta
/ = División 
x = Multiplicación
^ = Potencia


#include <stdio.h>

float potencia(float base, int exponente) {
    float resultado = 1;
    int i;
    for (i = 0; i < exponente; ++i) {
        resultado *= base;
    }
    return resultado;
}


int main() {
    float x, y, resultado;
    char op;
    int valido = 1;

    printf("Ingrese operacion: ");
    scanf("%c", &op);
    printf("Ingrese x: ");
    scanf("%f", &x);
    printf("Ingrese y: ");
    scanf("%f", &y);

    switch (op) {
        case '+':
            resultado = x + y;
            break;
        case '-':
            resultado = x - y;
            break;
        case '*':
        case 'x':
            resultado = x * y;
            break;
        case '/':
            resultado = x / y;
            break;
        case '^':
            resultado = potencia(x, (int) y);
            break;
        default:
            valido = 0;
    }

    if (valido)
        printf("El resultado es %f\n", resultado);
    else
        printf("Operacion invalida\n");

    return 0;
}

   

Instrucción Switch

La sentencia switch da una alternativa mucho más refinada a la necesidad de utilizar o implementar múltiples sentencias condicionales if cuando deseamos que una determinada variable tome diferentes valores para cada condición.

Generalmente, la sentencia switch se implementa cuando es necesarario la utilización de un menú de opciones ya que el usuario deberá escoger una de las opciones, a esto me refiero cuando comento que la variable puede tomar diferentes valores.

En primer lugar, decir que en inglés switch significa algo así como conmutar, cambiar. Esta instrucción tiene la estructura que se muestra a continuación:

1. switch(/* Variable a comprobar */) {
3. }

La variable a comprobar será la variable que queramos testear si contiene un resultado. Dichos testeos los haremos usando dentro de los corchetes la palabra reservada case, junto a unos paréntesis y dos puntos. Para indicar que hemos acabado el bloque de instrucciones usaremos la palabra reservada break; seguida de un punto y coma. Entendamos mejor esto con el siguiente ejemplo:

1. Console.WriteLine("Seleccione una opción:");
2. Console.WriteLine("1. Sumar");
3. Console.WriteLine("2. Restar");
5. int opcionSeleccionada = Convert.ToInt32(Console.ReadLine());
7. switch(opcionSeleccionada) {
8. case (1):
9. Console.WriteLine("Seleccionada opción 1");
10. break;
11. case (2):
12. Console.WriteLine("Seleccionada opción 2");
13. break;
14. case (0):
15. Console.WriteLine("Opción incorrecta");
16. break;
17. }

En este caso, vemos como la variable que testeamos es la variable opcionSeleccionada (Línea 8), que justamente acaba de introducir el usuario para seleccionar una opción de un menú. Si la variable contiene el valor 1 (Línea 9), entonces se mostrará el mensaje “Seleccionada la opción 1” para luego salirse del switch con la instrucción break;

Si seleccionamos la opción 2, veremos “Seleccionada la opción 2“, saliendose del switch después, y lo mismo ocurre con la opción 0, que muestra “Opción incorrecta” y luego abandona el swich.

Break, saliendo del switch

Para salir del switch, como ya hemos visto, usamos la palabra break, cuya función es dar por terminada la función switch y continuar inmediatamente después de esta. Una de las cosas que podemos hacer es apliar varias instrucciones antes de una instrucción break para que ambas ejecuten las mismas líneas:

1. Console.WriteLine("Seleccione una opción:");
2. Console.WriteLine("1. Sumar");
3. Console.WriteLine("2. Restar");
4. Console.WriteLine("0. Salir");
6. int opcionSeleccionada = Convert.ToInt32(Console.ReadLine());
8. switch(opcionSeleccionada) {
9. case (1):
10. case (2):
11. Console.WriteLine("Seleccionadas opción 1 o 2");
12. break;
13. case (3):
14. Console.WriteLine("Seleccionada opción 3");
15. break;
16. case (0):
17. Console.WriteLine("Opción incorrecta");
18. break;
19. }

Así, al haber apliado case (1): y case (2): uno encima del otro, y al no haber un break entre ellos, tanto si tecleamos 1 como si 2 se ejecutará la línea que escribe “Seleccionadas opción 1 o 2”, saliendo del swich después de hacerlo por el break;. Podemos apliar tantos case() como queramos.

Advertencia de programación

Toda instrucción case debe terminar en una instrucción break, esté apilada o no. No hacerlo es un error de compilación.

Default, qué hacer en cualquier otro caso

Cuándo necesitemos hacer algo en cualquier otro caso a los diferentes cases, usaremos la instrucción default: seguida de dos puntos. Las líneas dentro de esta etiqueta se ejecutarán si el valor no coincide con el valor de las otras etiquetas case, hasta, nuevamente, salir de la instrucción switch con un break.

Advertencia de programación

La instrucción default también debe terminar en una instrucción break. No hacerlo es un error de compilación.

1. Console.WriteLine("Seleccione una opción:");
2. Console.WriteLine("1. Sumar");
3. Console.WriteLine("2. Restar");
5. int opcionSeleccionada = Convert.ToInt32(Console.ReadLine());
7. Console.WriteLine("introduzca el primer número:");
8. int num1 = Convert.ToInt32(Console.ReadLine());
10. Console.WriteLine("introduzca el segundo número:");
11. int num2 = Convert.ToInt32(Console.ReadLine());
13. switch(opcionSeleccionada) {
14. case (1):
15. int suma = num1 + num2;
16. Console.WriteLine("Resultado de la suma: " + suma);
17. break;
18. case (2):
19. int resta = num1 - num2;
20. Console.WriteLine("Resultado de la resta: " + resta);
21. break;
22. default:
23. Console.WriteLine("Opción incorrecta");
24. Console.ReadKey();
25. return; // Return sale del método main y por lo tanto cierra el programa en aplicaciones de consola
26. break;
27. }

En este caso, hemos creado una aplicación práctica, una pequeña calculadora, que nos permite sumar o restar según el número que introduzcamos. Si introducimos el número 1, que quedará guardado en la variable opcionSeleccionada, al llegar al switch/case, se sumarán los valores y se imprimirá el resultado de la suma. Si introducimos el número 2, entonces se restarán, y si introducimos cualquier otra cosa entonces aparecerá el mensaje “Opción incorrecta” y la aplicación esperará a que presionemos una tecla y luego se cerrará.

Uso con tipos de datos

Sin ningún problema, podemos usar switch/case con diferentes tipos de datos, como por ejemplo float, double o string. Cada uno de estos tipos de datos debe ir con sus correspondientes valores explícitos, como por ejemplo, “a” para un string o 4.0 para un double,  Así, por ejemplo, podemos hacer el ejemplo anterior de la siguiente manera:

1. Console.WriteLine("Seleccione una opción:");
2. Console.WriteLine("S: Sumar");
3. Console.WriteLine("R: Restar");
5. string opcionSeleccionada = Console.ReadLine();
7. Console.WriteLine("introduzca el primer número:");
8. int num1 = Convert.ToInt32(Console.ReadLine());
10. Console.WriteLine("introduzca el segundo número:");
11. int num2 = Convert.ToInt32(Console.ReadLine());
13. switch(opcionSeleccionada) {
14. case ("S"):
15. case ("s"):
16. int suma = num1 + num2;
17. Console.WriteLine("Resultado de la suma: " + suma);
18. break;
19. case ("R"):
20. case ("r"):
21. int resta = num1 - num2;
22. Console.WriteLine("Resultado de la resta: " + resta);
23. break;
24. default:
25. Console.WriteLine("Opción incorrecta");
26. Console.ReadKey();
27. return; // Return sale del método main y por lo tanto cierra el programa en aplicaciones de consola
28. break;
29. }

Nótese cómo en este caso, el string se testea la letra S para sumar y la letra R para restar. También hay que destacar que se ejecuta el mismo código si la letra es mayúscula o minúscula, porque hemos apilado diferentes cases.

Igual que las instrucciones if

Si nos damos cuenta, una instrucción switch/case es equivalente a varias instrucciones if con comparaciones respecto a los mismos valores. Por ejemplo, el siguiente código con switch/case:

1. int numero = 3;
3. switch(numero) {
4. case(1):
5. Console.WriteLine("Numero es 1");
6. break;
7. case(2):
8. Console.WriteLine("Numero es 2");
9. break;
10. case(3):
11. Console.WriteLine("Numero es 3");
12. break;
13. default:
14. Console.WriteLine("Numero no es ni 1 ni 2 ni 3");
15. break;
16. }

tiene exactamente el mismo comportamiento que lo siguiente, escrito con ifs:

1. int numero = 3;
3. if(numero == 1)
4. {
5. Console.WriteLine("Numero es 1");
6. }
7. else if(numero == 2)
8. {
9. Console.WriteLine("Numero es 2");
10. }
11. else if(numero == 3)
12. {
13. Console.WriteLine("Numero es 3");
14. }
15. else
16. {
17. Console.WriteLine("Numero no es ni 1 ni 2 ni 3");
18. }

y ambos producirán la misma salida. Es elección del programador elegir cuándo usar uno u otro, en función de cual haga más cómoda la lectura o cual resulte más sencillo de escribir, ya que son análogos. 

Un ejemplo es:

#include<stdio.h>
main() {
char ch;
printf("Introduzca una vocal: ");
ch=getchar();
switch(ch) {
case 'a': puts("Se ha pulsado una a.");
break;
case 'e': puts("Se ha pulsado una a.");
break;
case 'i': puts("Se ha pulsado una a.");
break;
case 'o': puts("Se ha pulsado una a.");
break;
case 'u': puts("Se ha pulsado una a.");
break;
default: puts("Error");
}
}