Mensajes

Repites muchas veces el mismo código lo cual no es para nada eficiente. Tienes que pensar bien lo que quieres hacer antes de programar. Haz un esquema en un papel o algo por el estilo que te ayude a organizar la información.
Te dejo un ejemplo para que veas que se puede organizar mejor el código basándome en el primer código que publicaste. No está completo ya que lo que tienes bien te he puesto un comentario para que lo incluyas tú. Tampoco era plan de hacerlo todo. Espero que te sirva de ayuda porque no es algo que haga a menudo así que aprovéchalo.

Debes ver qué cosas quieres guardar y cuales no hace falta; por ejemplo no es necesario guardar el precio antes del descuento y después (si fuera necesario pues entonces sí, creas una variable <precio_inicial> y otra <precio_final>). Si quieres mostrar cuántos clientes han elegido la opción 2 no tiene mucho sentido mostrarlo al terminar cada iteración porque en este caso si la opción es 2, los clientes que habrán elegido la opción 2 son todos <numero_clientes> y si la opción no es 2, entonces ninguno. Lo lógico desde mi punto de vista sería mostrar eso al terminar el programa (entonces en cada vuelta si la opción es 2, acumulamos los clientes que han elegido esa opción).

Código (c) [Seleccionar] Expandir


// creamos constantes globales para los precios ya que usar numeros sueltos que no se sabe lo que significa no es una buena practica
const int PRECIO_1 = 250;
const int PRECIO_2 = 255;
const int PRECIO_3 = 350; // supongo esto ya que en el ultimo mensaje es 250 igual que precio1

// constantes para los descuentos
const float DESCUENTO_1 = 0.15;
const float DESCUENTO_3 = 0.25;

// constante para determinar el valor que se usa para finalizar el programa
const int CLIENTES_EXIT = 9999;

int main(){
    // creamos las variables que vamos a usar pensando bien en lo que necesitamos
    int numero_clientes; // numero de clientes que van a "comprar" una de las opciones
    int clientes_opcion2 = 0; // numero de clientes que eligen la opcion 2
    int opcion_precio, opcion_pago; // opciones tanto de precio como de forma de pago
    float precio, descuento; // precio de la compra (con decimales) y descuento aplicado

    // pides el numero de clientes
    while(numero_clientes != CLIENTES_EXIT){
        // pides las opciones

       // calculamos los precios segun el precio por cliente
        if(opcion_precio == 1)
            precio = numero_clientes * PRECIO_1;
        else if(opcion_precio == 2)
            precio = numero_clientes * PRECIO_2;
        else
            precio = numero_clientes * PRECIO_3;

        // calculamos lo necesario segun el metodo de pago
        if(opcion_pago == 1)
            descuento = precio * DESCUENTO_1;
        else if(opcion_pago == 3)
            descuento = precio * DESCUENTO_3;
        else // si no es la opcion 1 ni 3, entonces es la 2 (suponiendo que solo se admiten esos 3 valores)
            clientes_opcion2 += numero_clientes; // equivalente a clientes_opcion2 = clientes_opcion2 + numero_clientes

        // aplicamos el descuento
        precio -= descuento; // equivalente a decir precio = precio - descuento

        // mostramos los resultados
        printf("El importe final es: %.2f\n", precio); // mostramos el precio con 2 decimales
        // muestras el descuento de la misma manera (CUIDADO: si la opcion de pago es 2 se mostrara el descuento de la repeticion anterior ya que no se actualiza)

        // pides numero de clientes nuevamente para repetir el programa
    }
    // llegamos aqui una vez que introducimos <numero_clientes = 9999>
    printf("El numero de clientes que han elegido la opcion de pago 2 son: %d\n", clientes_opcion2);
}

A la hora de pedir las opciones hay un problema. Que pasa si el usuario introduce opciones no válidas?? O qué pasa si el usuario introduce <numero_clientes = 10000>??
Bueno lo segundo es fácil. Cambiamos la condición del <while> por un (numero_clientes < CLIENTES_EXIT) y listo.
Lo primero se suele solucionar con lo que se conoce como filtro. Un filtro es un bucle que pide un valor al usuario y se repite mientras el valor no sea válido, o sea básicamente un filtro que solo deja pasar valores válidos. Esto se implementa con un <do while>. Te dejo un ejemplo de un filtro para que solo deje pasar números positivos y pares. Como tarea te queda adaptarlo a ti a tu problema...

Código (c) [Seleccionar] Expandir


int numero;
do{ // hacer lo que hay dentro del bucle (pedir un valor)...
    printf("Introduce un numero par y positivo: ");
    scanf("%d", &numero);
}   while(numero < 0 || numero % 2 != 0); // ... mientras el numero sea menor que 0 o sea impar
// cuando un valor pase el filtro llegamos aqui y podemos asegurar que ese valor es positivo y par
printf("El numero introducido es: %d\n", numero);

Lo primero, cuidado con esas suposiciones...

una potencia de 2 elevada a un número primo, menos uno, da como resultado otro número primo

Código [Seleccionar] Expandir


potencia de 2 := 4
numero primo := 2
4² - 1 = 15 = 3*5 -> 15 no es primo

Siguiente problema. Esa función <esPrimo()>...

Código [Seleccionar] Expandir


numero := 49
49 = 7² -> 49 no es primo
Segun la funcion: EsPrimo(49) = true
Es decir esa función no es correcta. Tienes que echarle un vistazo a ver si eres capaz de solucionarlo antes de que te diga cómo se hace.
Aparte y esto es más tontería, como son <return> no hacen falta los <else> ya que si se ejecuta un <return>, va a salir de la función y no sé ejecuta el resto:

Código (cpp) [Seleccionar] Expandir


if(x == a)
   return 1;
else if(x == b)
   return 2;
else
   return 3;

// Se puede dejar en
if(x == a) return 1;
if(x == b) return 2;
return 3;
Así queda más limpio y más simple al compilarlo.

Luego veamos la función <Potencia()>
Según el enunciado se te pide lo siguiente:

diseña, para ayudarte, una función 'Potencia' que eleve una base entera a una potencia entera y devuelva un 'unsigned long long' (¡no utilices la función 'pow'!).

Y tú creas esto:

Código (cpp) [Seleccionar] Expandir


// Cuidado que en el prototipo tienes un parametro y en la implementacion otro (unsigned int != unsigned long long)
// Funcion que calcula la potencia indicada en el parametro de 2, es decir, 2^exponente
unsigned long long Potencia(unsigned int exponente); // lo llamo exponente para que se entienda mejor
No has creado una función que eleve una base entera a una potencia entera. Has creado una función que eleva el 2 a una potencia NATURAL/entera positiva (0 incluido) (unsigned). Solo te lo comento para que veas la diferencia entre lo que te piden y lo que implementas. Lo suyo sería algo así:

Código (cpp) [Seleccionar] Expandir


unsigned long long Potencia2(int exponente); // dejar claro que esa funcion calcula potencias de 2
unsigned long long Potencia(int base, int exponente); // lo que te pide el enunciado

Y después de todo esta parrafada, te comento lo que tienes que hacer. Los números perfectos se pueden obtener a partir de la fórmula que has comentado arriba aunque primero dejemos claro un par de notaciones para poder explicarte el ejercicio:

Código [Seleccionar] Expandir


Pi := numero perfecto i
Mi(p) := numero de Mersenne i cuya formula es 2^p-1. Se suele representar como Mp, por ejemplo, M7 = 2⁷-1 = 127 pero te lo representare como M4(7), es decir, el 4º numero primo de Mersenne (que se calcula con p = 7)
Entonces tenemos que: Pi = Mi(p) * 2^p
Un número se considera de Mersenne si p es primo y 2^p-1 también es primo. Los 10 primeros p que cumplen esta condición son {2, 3, 5, 7, 13, 17, 19, 31, 61, 89} y los números de Mersenne que genera cada p son {3, 7, 31, 127, 8191, 131071, 524287, 2147483647, 2305843009213693951, 618970019...449562111} respectivamente (están en Wikipedia estos datos: https://es.wikipedia.org/wiki/N%C3%BAmero_primo_de_Mersenne)

Te pongo una forma de hacerlo para que tengas una idea

Código [Seleccionar] Expandir


p := 2 // uso el mismo nombre que en las formulas anteriores
num_perfectos := 0
mientras num_perfectos < 10
   si esPrimo(p)
       numero_mersenne := Potencia(2,p)-1
       si esPrimo(numero_mersenne)
           numero_perfecto[num_perfecto] := numero_mersenne * Potencia(2, p-1)
           num_perfecto := num_perfecto + 1
       fin si
   fin si
   p := p + 1
fin mientras

Lo siento por el mensaje tan largo pero espero haberlo explicado todo con claridad.

Existe la función <ceil()> de la librería <cmath> (en C++) o <math.h> (en C).
De todas formas puedes crear una función, simplemente suma una unidad al número original y luego trúncalo.

Cuando creas un puntero, ese puntero guarda una dirección de memoria. Si el puntero no lo inicializas al crearlo, este apuntará a una dirección de memoria cualquiera que puedes ver pero no puedes usar porque no sabes a qué está apuntando. Se puede hacer que apunte a NULL para tener una referencia de que ese puntero no está en uso en ese momento.

Y ten cuidado con lo del arreglo... Un puntero no es un arreglo. Un puntero apunta al comienzo de un arreglo en el caso de que hayas reservado memoria o que sea un array estático, que no es el caso.

Bueno varias cosas. El programa como ya te han dicho se puede hacer más legible y debes ponerlo entre etiquetas de código GeSHi.
El programa no tiene ningún error y finaliza cuando introduces el número 9999 como cliente. Pero antes debes introducir las otras dos variables que pides. Si no quieres que pase esto debes pedir el número del cliente antes de empezar el <while> y justo antes de terminarlo y las otras dos variables pedirlas únicamente dentro del <while>.

Para mostrar una variable es así:

Código (cpp) [Seleccionar] Expandir


cout << "La distancia es: " << distancia << endl; // el << endl es un salto de linea
Con <cin> lo que haces es coger el valor que teclee el usuario.

Aparte te comento que las librerías que terminan en .h son de C. La versión de las mismas pero para C++ son quitando el .h y poniendo una c delante <cmath>.

Lo que te piden es que crees tu propia estructura de cola con prioridad (priority_queue). Puedes ver cómo funciona aquí: http://www.cplusplus.com/reference/queue/priority_queue/
En el fondo es esto. Es una cola en la que los elementos se almacenan siguiendo un orden de prioridad. Es una cola en la que las inserciones se hacen según la prioridad que tienen asignadas y las expulsiones se hacen por uno de los extremos de la cola.

Puedes entenderlo como un vector/array en el que los elementos están ordenados según su prioridad. array[0] = {elemento de menor prioridad} y array[size-1] = {elemento de mayor prioridad}. Te pongo un ejemplo:

Código [Seleccionar] Expandir


Nomenglatura usada: objeto(prioridad)
Segun tu caso: numero menor = mas prioridad
priority_queue = { }
insert(A(5)) -> priority_queue = { A(5) }
insert(B(8)) -> priority_queue = { B(8), A(5) }
insert(C(1)) -> priority_queue = { B(8), A(5), C(1) }
insert(D(4)) -> priority_queue = { B(8), A(5), D(4), C(1) }
sacarTop() -> priority_queue = { A(8), B(5), D(4) }

Entonces lo que te piden es crear usando un array, una estructura que funcione así.
Las operaciones típicas que debe soportar son:

• insert(cola, elemento) -> inserta el elemento en la posición correcta
  
• removeFirst(cola) -> elimina el objeto con mas prioridad
  
• Te recomiendo hacer un top() -> muestra el elemento con mas prioridad. Ya que es recomendable que una función sólo lo muestre y el otro sólo lo elimine (removeFirst). Creo que eso es lo que vas a implementar tú en la función <peek()>.
  Y las funciones adicionales que te piden que son:
  
• display(cola) -> muestra toda la cola.
  
• create(cola) -> inicializa la cola con valores. Yo lo haría de forma random. O sea <create(cola, num_elementos)> y que meta <num_elementos> elementos en la cola creados de forma aleatoria.
  
  Ahora vamos al programa en si.
  En lugar de crearlo de forma global todo, te recomiendo hacerlo dentro del <main> tanto el array como la instancia <proceso> del <struct> <proceso> (mejor cambia el nombre: proceso_x (instancia) Proceso(struct) para evitar confusión).
  
  Te pongo un ejemplo de uso de cómo lo haría yo para que veas a lo que me refiero. Te pondré las partes necesarias de las funciones y del <main> pero las implementaciones de las funciones te las dejaré a ti.
  
  Código (c) [Seleccionar] Expandir
  
struct Proceso{
    int prioridad; // define la prioridad de un proceso
    int datos; // define los datos de ese proceso. Esto no tiene importancia
};

struct ColaPrioridad{
    Proceso cola_interna[SIZE]; // un array de Procesos que es nuestra cola con prioridad
    int size; // determina la cantidad de elementos que tiene la cola_interna.
};

// inserta <num_elementos> elementos en la cola (mi_cola.size = num_elementos)
// puede ser void o ser bool y retornar true si num_elementos <= SIZE y se han guardado bien o false si num_elementos > SIZE
void/bool create(ColaPrioridad mi_cola, int num_elementos);

// insertar un elemento en la cola en su posicion correspondiente segun su prioridad
// puede ser void o bool y retornar true si no se ha superado el limite de elementos (mi_cola.size < SIZE) o false en caso contrario
void/bool insert(ColaPrioridad mi_cola, Proceso nuevo_proceso);

// elimina el elemento con mayor prioridad
// puede ser void o bool y retornar true si la cola no esta vacia y se ha eliminado bien o false en caso contrario
void/bool removeFirst(ColaPrioridad);

// retorna el elemento de mayor prioridad de la cola sin eliminarlo de esta
Proceso top(ColaPrioridad);

// muestra la cola completa
void display(ColaPrioridad);

int main(){
    ColaPrioridad mi_cola;
    create(mi_cola, 5); // insertamos 5 procesos aleatorios en la cola
    display(mi_cola); // vemos el contenido
    Proceso proceso_nuevo1, proceso_nuevo2; // creamos dos procesos nuevos
    // damos valores a prioridad y datos de proceso_nuevo1 y proceso_nuevo2
   
    // insertamos los nuevos procesos despues de haberles dado valores en la cola
    insert(mi_cola, proceso_nuevo1);
    insert(mi_cola, proceso_nuevo2);
    display(mi_cola); // vemos el contenido
   
    removeFirst(mi_cola); // eliminamos el Proceso con mayor prioridad (es decir, con el atributo prioridad menor)
    display(mi_cola); // vemos el contenido
}
  
  En un principio puede parecer que tienes que introducir los elementos en el array de más prioridad a menos para eliminar el "primer elemento" que es el de mayor prioridad. Sin embargo, si los ordenas de menos a más prioridad, el elemento con más prioridad es <cola_interna[size-1]> y cuando tengas que eliminar el elemento de mayor prioridad (la función <removePrio()> sobra, solo se usa <removeFirst()>) solo tienes que hacer <size-->. Así ahora el último elemento ya es el anterior y cuando introduzcas un elemento nuevo sobrescribes el que se supone que habías borrado con desplazamientos.
  
  Si tienes alguna duda para implementar alguna de las funciones o sobre algo de lo que te he comentado, recuerda, de ser necesario, poner tus avances para poder ayudarte mejor. Suerte

Hola amigos..

Estoy experimentando con el contenedor set y tengo duda con el operador de sobrecarga que se necesita para meter al contenedor un tipo creado por mi mismo...

Según estuve leyendo y alguien me dijo también que necesito sobrecargar el operador <

Pero este operador menor que, en que forma hace la comparación de elementos?, el contenedor set no permite objetos duplicados, no seria mas lógico sobrecargar == en vez de < para comparar si el elemento ya existe?

Creo que a lo que te refieres es al tipo de ordenación interno del <set>. Un <set> es un conjunto de valores no repetidos y ordenados según un criterio que puedes elegir tú (criterio por defecto: less<T>). Es por esto que si creas un <set> para almacenar objetos deben poder ordenarse de menor a mayor y para ello tienes dos opciones:

• Sobrecargar el operador <.
  
• Crear un functor. (Verás que se hablan mucho de functores para <set> y <priority_queue>.
  
  
  Código (cpp) [Seleccionar] Expandir
  
// OPCION 1: Sobrecarga de <
struct foo{
    // miembros
    bool operator<(const foo &f)const{/*...*/}
};
std::set<foo> my_set; // equivalente a std::set<foo, less<foo>, allocator<foo>> se necesita el operador para el criterio less<foo>

// OPCION 2: Functor
struct foo{
    // miembros
};

struct comparaFoo{
    bool operator()(const foo &f1, const foo &f2)const{/*...*/}
};
std::set<foo, comparaFoo> my_set; // cambiamos el criterio por defecto por el nuestro
  
  Si quieres saber más sobre esto: http://www.cplusplus.com/reference/set/set/
  Puedes leer la teoría. Es muy concisa pero precisa, creo que está muy bien para entenderlo (aunque en inglés, pero es un inglés sencillo). Suerte

[Solo quiero dejar claro que tanto el comentario anterior como este son críticas constructivas. No lo hago por tocar las narices ni nada pero en el fondo todos tenemos nuestro ego y nos gusta defenderlo. Y personalmente me gusta explicar el porqué de lo que hago y digo en un mundo que cada vez más se usa el motivo del porque sí hasta en el sistema educativo, sin ningún tipo de razonamiento en el que apoyarse. Ahora que ya he soltado mi reivindicación y he mostrado las posibilidades que hay hasta para hacer la función más simple del mundo. Suerte a todos y ánimo con la programación]

Propones una funcion que no funciona. No contempla que los valpres almacenados en las variables sean iguales.

Te invito a buscar cualquier ejemplo o analizar el funcionamiento de la función para ver si es cierto que no contempla que los valores sean iguales. Se empieza asignando como mayor a <numero1> y se actualiza en caso de que otro de los números sea mayor estricto. ¿Qué más da que dos números sean iguales? mayor{5,5} = 5. Que más da que el mayor sea el primero o el segundo, si son iguales. Mejor tratar al primero como mayor y nos ahorramos una asignación más a lo tonto.
Esto se usa siempre para determinar el mayor de dos números:

Código (cpp) [Seleccionar] Expandir


// Lo que se le pasa a alguien por la cabeza cuando esta empezando
// Aqui si es cierto que si no ponemos >= en la condicion tendriamos un problema si numero1 == numero2
int mayor;
if(numero1 >= numero2)
    mayor = numero1;
else
    mayor = numero2;

// Como se suele hacer para optimizar
int mayor = numero1; // suponemos que numero1 es mayor
if(numero2 > mayor) // solo si numero2 es mayor estricto actualizamos el mayor, si son iguales mantenemos numero1 ya que es correcto
    mayor = numero2;

Propones utilizar arrays en un programa que se presupone que el usuario puede introducir la cantidad de valores que quiera. En lugar de usar vectores que no dejan de estar implementados con arrays.

Los contenedores de la STL están muy bien pero para una tarea trivial como es esta no recomiendo su uso. Estás metiendo una enorme cantidad de código (funciones, constantes, etc) que traen consigo cada una de las librerías dedicadas a un contenedor cuando con un array que no añade nada más se puede solucionar.
Además creo que los contenedores de la STL no deberían usarse hasta haber hecho algún algoritmo tedioso con arrays:
1º Para saber desenvolverse en situaciones difíciles en las que por un motivo u otro, sea obligatorio usar arrays.
2º Para comprender mejor el potencial de los contenedores y ver la de trabajo que quitan.
Seguro que hay más razones pero sólo destacaré esas. Imagina que empiezas a programar usando desde el principio la librería <vector> y un día te dicen "¿cómo llevas trabajar con memoria dinámica?" o piensas "¿por qué la gente se esfuerza en aprender memoria dinámica y a usar <new> y <delete> cuando el <vector> lo hace todo solo?"

Siguiendo por esa linea, seria mas eficiente usar set como contenedor.

Depende lo que entiendas por eficiente... Crear un set de valores donde vamos a meter un array ponte de 1000000 números en los que hay 20 repetidos. Habrá quien diga que mejor un set "así evitas meter los valores que son iguales. Al final coges el último y ya está" Y... El set se ordena por arte de magia? De verdad alguien piensa eso? Requiere tiempo de ejecución que aunque no se vea de forma explícita, está ahí. Habrá quien diga que mejor una cola con prioridad, con las operaciones suficientes para resolver esa tarea y menos costosa y habrá quien no se quede ahí y diga "cuando la cola con prioridad no esté vacía comparas el valor que vas a meter con el top y solo lo introduces si el nuevo valor es mayor, así no introduces todos los valores y por ende no requieres de tanto espacio" Y yo me pregunto al final eso no acaba siendo un bucle que determina el mayor entre el mayor actual y el siguiente número del array?? Mejor saber sacarse las castañas del fuego sin tanto contenedor de la STL aunque no digo que no tengan su utilidad, pero no para algo tan trivial...

Suprimi el valor decimal a proposito aunque lo correcto sea redondear porque no queria solucionarle la tarea.

Muy bien, entonces digamos que lo comenté para que si alguien lo iba a pasar por alto, se parara a pensarlo. Ya que al final siempre alguien acaba liado preguntándose "¿por qué me salen estos dos porcentajes iguales si uno vale 20,99% y el otro 20,02%? Por no haber hecho un cast en la división.

En base al resto que comentas intente acercar el codigo al lenguaje humano para que lo entienda.

Para acercarse al lenguaje humano están los comentarios a los que no pondré quejas ya que explicas todo lo que vas haciendo y eso está bien sobre todo para la gente que empieza o el pseudocódigo el cual ya cada cual puede encargarse de traducir a su manera.
Pero por ejemplo crear una variable para guardar el enter del final... Si alguien está empezando y se acostumbra a hacerlo así porque es lo que vio cuando él estaba empezando a programar, algún día le harán preguntas como "¿por qué creas esa variable?" o "¿por qué de tipo int si vas a guardar un enter"? o podrá pensar que eso funciona cuando pulsas enter hasta que un día se equivoque y le dé a otra tecla y se diga "¿por qué pido que pulsen Enter para salir si cualquier tecla sirve?" Son pequeños detalles pero que la gente cuando lo ve debería preguntarse ese tipo de cosas y en cambio muchos lo pasan por alto y dicen "pues se hace así y ya está". Y no es que se haga así, cada uno podrá hacerlo como quiera al final, pero que sepan las opciones que tienen.

Solo quiero dejar claro que tanto el comentario anterior como este son críticas constructivas. No lo hago por tocar las narices ni nada pero en el fondo todos tenemos nuestro ego y nos gusta defenderlo. Y personalmente me gusta explicar el porqué de lo que hago y digo en un mundo que cada vez más se usa el motivo del porque sí hasta en el sistema educativo, sin ningún tipo de razonamiento en el que apoyarse. Ahora que ya he soltado mi reivindicación y he mostrado las posibilidades que hay hasta para hacer la función más simple del mundo. Suerte a todos y ánimo con la programación

Para la función de <numeroMayor> te puedes ahorrar condiciones si empiezas suponiendo un valor como máximo que es lo que se suele hacer en estos casos. Además poner un <if> vacío para hacer algo en el <else> es mejor darle la vuelta a la condición para hacer lo del <else> en el <if> y no poner el <else>. Algo así:

Código (cpp) [Seleccionar] Expandir


int numeroMayor(int numero1, int numero2, int numero3){
    int mayor = numero1;
    if(numero2 > mayor)
        mayor = numero2;
    if(numero3 > mayor)
        mayor = numero3;
    return mayor;
}
De todas formas hacerlo para 3 números queda un poco feo porque no te vale para 2 que es el caso base, ni para un número aleatorio por lo que lo suyo sería:

• Crear la función para 2 parámetros y llamar a la función desde la propia función:
  
  Código (cpp) [Seleccionar] Expandir
  
int mayor = numeroMayor(numeroMayor(numero1, numero2), numero3);
  
• Crear la función para un array:
  
  Código (cpp) [Seleccionar] Expandir
  
int numeroMayor(int *numeros, int size);
  
  La función de <FuncionPromedio()> mejor hacerla de tipo <double/float> porque un promedio usando enteros queda un poco limitado. Recordar hacer un cast en la división para pasar de enteros a reales. Y lo mismo de antes, mejor que reciba un array de números:
  
  Código (cpp) [Seleccionar] Expandir
  
double calcularPromedio(int *numeros, int size);
  
  Esto a decisión de cada uno (bueno como todo) pero la función del menú haría que retorne ya la opción elegida. De esta forma puedes meter un filtro <do while> para controlar la opción que se elige. Así además nos ahorramos un <case> ya que no aceptamos ningún valor distinto de {1, 2, 3}:
  
  Código (cpp) [Seleccionar] Expandir
  
int opcion_elegida = menu();
  
  Limpias la pantalla al comienzo de cada <case>. Llama a la función una única vez antes de empezar el <switch>. También escribes unos cuantos saltos de línea al final de cada <case>; más de lo mismo, ponlo una única vez después del <switch>. De todas formas esto son funciones fanzy (funciones de adorno) que no debes prestar mucha atención ya que no es lo importante.
  
  Las variables de tipo <bool> en una condición queda mejor poner <if/while(condicion)> para <if/while(condicion == true)> y <if/while(!condicion)> para <if/while(condicion == false)>:
  
  Código (cpp) [Seleccionar] Expandir
  
while(!fin);
  
  

  
  

  Código (cpp) [Seleccionar] Expandir

  
//Nos ahorramos la llamada a system pause:
int PausaDelSistema;
cout << "El programa a finalizado." << endl
<<"Introduce cualquier caracter y pulsa enter para finalizar" << endl;
cin >> PausaDelSistema;

  Todo esto para no usar <system("pause")>? Con un <cin.get()> solucionado.
  
  Código (cpp) [Seleccionar] Expandir
  
cin.get();