Mensajes

Libros no sé ya que yo apenas he leído uno. Es posible que @string Manolo te recomiende alguno ya que he visto otros temas en los que ha recomendado algunos libros. También puedes ver cursos online (posiblemente gratuitos) y sobre todo practicar mucho.
Te dejo un enlace AQUÍ a la página de <cplusplus.com>. Está en inglés pero es un inglés muy fácil de entender. Ahí puedes ver un montón de librerías con sus respectivas funciones y ejemplos de uso. Puede que te sirva.

Personalmente lo que haría sería "quitar los palos". Para este juego lo importante es el valor de la carta, el palo importa más bien poco y al quitar los palos podemos guardar todos los números en un solo array y aplicar el código que te puse para sacar una carta y hacer que no salga más veces.

Código (cpp) [Seleccionar] Expandir


#include <iostream>
#include <cstdlib>
#include <ctime>

const int NUM_CARTAS = 40;

int main(){
    int cartasDisponibles = NUM_CARTAS;
    int cartas[NUM_CARTAS] = {1,2,3,4,5,6,7,10,11,12,1,2,3,4,5,6,7,10,11,12,1,2,3,4,5,6,7,10,11,12,1,2,3,4,5,6,7,10,11,12};

    srand(time(NULL));

    while(cartasDisponibles > 0){
        int indiceAleatorio = rand() % cartasDisponibles;
        int cartaActual = cartas[indiceAleatorio];
        cout << "La carta sacada es: " << cartaActual << endl;
       
        // Guardamos la carta que hemos sacado al final del array para que no salga mas veces
        int auxiliar = cartas[indiceAleatorio];
        cartas[indiceAleatorio] = cartas[cartasDisponibles-1];
        cartas[cartasDisponibles-1] = auxiliar;
        --cartasDisponibles;

        // Si quieres ver las cartas que ya han salido
        cout << "Cartas que ya han salido: ";
        for(size_t i = cartasDisponibles; i < NUM_CARTAS; ++i)
            cout << cartas[i] << "  ";
    }
}
Puedes probar este código para que veas como saca todas las cartas y muestra las que ya han salido. Luego es cosa tuya ver qué cosas puedes aprovechar y cuáles no para tu programa.
En caso de hacerlo con una matriz y con los palos como lo tienes implementado, se complica un poco más el código. Tendrías que llevar 4 contadores: <orosDisponibles>, <copasDisponibles>, <espadasDisponibles> y <bastosDisponibles> y en vez de guardar las cartas que ya han salido al final del array, tendrías que guardarlos al final de la fila correspondiente a ese palo.

También tienes opciones un poco más "profesionales" pero que supongo que no habrás visto todavía como usar un <struct> o <class> llamado <Carta> que tenga <numero> y <palo> y hacer uso de contenedores de la STL como el <multiset>.

Está claro que hay errores. Yo te he mostrado una forma de hacer el ejercicio y he usado nombres de variables para que entiendas el funcionamiento, pero tú no puedes meter mi código en el tuyo y esperar que funcione cuando no has declarado esas variables.
Además:

• Declaras dos veces <cartaAleatoria> (línea 14 y 27)
  
• Creas la variable <indiceAleatorio> (línea 26) pero luego no lo usas en la siguiente instrucción (línea 27)
  
• Estás asignando decimales a variables de tipo <int> (líneas 55 y 73)
  
  PD: Cuida las tabulaciones... No me extraña que si llevas dos meses con este código te duela la cabeza porque ya me duele a mí y lo he visto dos veces.
  PD 2: Te recomendaría usar funciones para hacer el programa más limpio y más fácil de revisar tanto para ti como para nosotros.

No, es mucho más fácil. Generas un número aleatorio entre 0 y numCartasDisponibles-1 y listo:

Código (cpp) [Seleccionar] Expandir


// Obtener una carta aleatoria
int indiceAleatorio = rand() % numCartasDisponibles;
int cartaAleatoria = cartas[indiceAleatorio];

// Eliminamos esa carta de las disponibles
cartas[indiceAleatorio] = cartas[numCartasDisponibles-1];
--numCartasDisponibles;

// Tambien puedes hacer
cartas[indiceAleatorio] = cartas[numCartasDisponibles-1];
cartas[numCartasDisponibles-1] = cartaAleatoria;
--numCartasDisponibles;
Si eliminas la carta de la primera forma estás perdiendo el valor de esa carta en el array mientras que si lo haces de la segunda forma tendrás de <0> a <cartasDisponibles-1> las cartas que aún no han salido y de <cartasDisponibles> a <numCartas> las cartas que ya han salido.
Yo te recomendaría la segunda forma porque es una sola línea de código más y te permite ver en cualquier momento todas las cartas que ya han salido y así puedes llevar un mayor control.

Código (cpp) [Seleccionar] Expandir

#include <iostream>

int main(){
float x = 12.9, aux;
int y = x;

aux = x - y; //aux = 12.9 - 12 = 0.9

if (aux >= 0.5){
++y; // Es igual a y += 1 que es igual a y = y + 1
}

std::cout << y;


std::cin.get();
return 0;
} Si usas

Código (cpp) [Seleccionar] Expandir

using namespace std;

quita los [std::] y ya estaría

Esto redondea a la unidad y lo que están solicitando es un redondeo a la centena...
La solución que sí funciona es la que ha dado @engel lex.

Voy a intentar ayudarte aunque sin revisar tu código ya que al centrarlo creo que me está dando dolor de cabeza leerlo...
Depende de los recursos que quieras/puedas usar:

• Usar contenedores de la STL como <set>, <multiset> u otros.
  
• Usar un array unidimensional de TAM = numCartas y cada vez que escoges una carta, la pones en array[numCartasDisponibles - 1] y decrementas <numCartasDisponibles>.
  Habrá más formas de hacerlo pero creo que esas son las más intuitivas y sencillas haciendo uso o no de la STL.
  PD: Cambia la alineación del código para verlo bien tabulado  y si aprovechas y pones las etiquetas específicas de C++ mejor ya que así resalta la sintaxis. (Para ello en la etiqueta de apertura que pone "code" entre corchetes, añade "=cpp" para que quede <corchete><code=cpp><corchete>

El primer consejo (que espero que sea tenido en cuenta) es: poner el código entre etiquetas de código GeSHi de lenguaje C. Yo creo que este es el más importante de todos así que no lo tomes a la ligera si piensas seguir participando en el foro...

Aparte del consejo estrella pues se me ocurre alguno más:

• Nombre de variables mejorables. No hay nada como leer un código y no tener que volver al principio para recordar qué hacía una variable llamada <a> por ejemplo.
  
• Asignas dos veces 0 a <sum> de forma innecesaria.
  
• Asignas dos veces 0 a <cont> de forma innecesaria.
  
• Las asignaciones que hay dentro de los <printf()> no son nada claras de ver.
  
• No usar "magic numbers".
  
• Primero trabaja con los datos (lee valores, guarda valores, realiza cálculos, etc) y al final muestra los resultados. Así queda más claro el código.
  
  Luego a mí personalmente me gusta dejar los prototipos sin nombres de parámetros (sólo con el tipo) y poner los nombres únicamente a las implementaciones. Así no tengo que andar recordando que nombres puse para poner los mismos y si hago algún cambio no tengo que acordarme de realizarlo en ambos sitios.
  Y las variables de un <struct> prefiero ponerlas una por línea así se ve más fácil cuántas hay y de qué tipo es cada una.
  
  Y si quieres alguna mejora de eficiencia ahí va una aunque te parecerá ridícula: usar en los bucles <for> un contador (i/j) de 64 bits ahorra a la hora de generar el código ensamblador una instrucción que se encarga de transformar los índices de 32 bits en índices de 64 bits.
  
  Yo de momento me fijaría más en los primeros consejos que en este último ya que siempre existirá una lucha entre eficiencia y legibilidad. Un código relativamente pequeño no va a conseguir mucha optimización por este tipo de cambios pero sí puede conseguir que un programador tenga más o menos ganas de leerlo según lo legible que sea.

Por lo que se ve en tu código primero guardas el código del proveedor y después su nombre y la búsqueda la quieres realizar por código. En cambio tal y como lo tienes implementado estás comparando el código a buscar con el nombre de los proveedores por lo que dudo que vayas a obtener alguna coincidencia.
Además las líneas 65 y 66 hacen que te saltes uno de cada dos proveedores.

No estoy seguro de haberte entendido así que te explico más o menos:

Por que hay que usar -> y no se puede usar "."

El operador -> no es necesario. Quiero decir que no es un operador que haga algo que no puedas hacer con otro. El operador flecha se creó para evitar el punto y asterisco juntos.

Código (cpp) [Seleccionar] Expandir


struct Persona{
    string nombre;
    int edad;
};

int main(){
    Persona persona1;
    Persona *punteroPersona = &persona1;

    cout << "Nombre persona: ";
    getline(cin, punteroPersona->nombre); // equivale a: getline(cin, (*punteroPersona).nombre)
    //...
}
Es decir cuando estamos usando un puntero <punteroPersona> y tenemos que:

• Acceder al dato del puntero: <*punteroPersona>
  
• Acceder al dato miembro de ese datos: <(*punteroPersona).nombre>
  Podemos directamente usar el operador flecha para que quede mejor a la vista: <punteroPersona->nombre>
  
  Respecto al otro tema: las variables globales no es necesario pasarlas como parámetros ya que ya son conocidas en todo el programa y por tanto se pueden usar en cualquier parte de este. Supongo que si las pasa como parámetros será para poder ver en el <main> qué variable es la que está pasando a la función o por si te da por cambiar el nombre de la variable global, no tener que cambiarlo x veces en las funciones, sólo lo cambias en el parámetro y listo.
  De todas formas es mejor no usar variables globales ya que puedes tener una global y una local que se llamen igual y en una función prepararla por estar trabajando con la que no querías trabajar. Por eso es más seguro limitar su uso a lo imprescindible.

No le ves la utilidad porque ves muy complejo el hecho de crear una pila para hacer algo que podrías hacer con un array sin tanta complicación. La realidad es que para usar una pila siempre podemos usar la que alguien se preocupó en crear para la STL. Esta tienes sus funciones optimizadas.
Un buen programador no sólo debe limitarse a resolver un problema sino a hacerlo de la forma más eficaz y eficiente que pueda. Existen ocasiones en las que sólo necesitamos conocer el último elemento que hemos introducido, recuerdo un ejercicio: paréntesis correctos. Este ejercicio podría decir algo tal:

Código [Seleccionar] Expandir


Ejercicio: Paréntesis correctos
Dada una frase u operación matemática, comprobar si la secuencia de paréntesis es correcta.
Una secuencia de paréntesis es correcta si todas las llaves de apertura tienen su correspondiente llave de cierre y nunca aparece una llave de cierre antes que su correspondiente llave de apertura.
Si te apetece puedes intentarlo. Además ya tienes una pista: se hace con pilas.

Lo que estás haciendo ahora es recrear el contenedor <stack> de una forma un poco más cutre pero que sirve para entender cómo funciona. Es un ejercicio típico en programación el crear manualmente contenedores que ya existen (pilas, colas, listas enlazadas, listas doblemente enlazadas, etc).

• La función <menu()> sigue haciendo demasiadas cosas y algunas mal... Y sigue recibiendo un parámetro inútil... Además de que le sobran variables...
  
• La función <crearPilaVacia()> sigue retornando un <bool> y en tu caso no retorna nada...
  
• Las funciones <pilaLlena()> y <pilaVacia()> las puedes acortar a una sola línea como te comenté...
  
• A la función <apilar()> le falta el <return> y aunque la función está mejor, cuando la llamas en el <case> vuelves a hacerla inútil...
  
• Las funciones <cima()> está bien.
  
• La función <visualizarElementos()> debe retornar un <float> y no lo hace...
  
• La función <sumaPila()> tiene dos variables para hacer lo que se puede hacer con una...
  Lo único bueno con lo que me quedo es que teniendo el trabajo aprobado sigues intentando comprenderlo y la verdad, un profesor que ve este programa debería saber al instante que no se tienen los conceptos claros y debería aclararlos. Si te ha aprobado sin más... Diría que se la suda lo que sus alumnos aprendan...
  
  La única forma que se me ocurre para poder ayudarte sin tener que volver a escribir un mensaje como el anterior es que me expliques tu razonamiento para:
  
• Mandar <eleccion> como parámetro en <menu()> (línea 24)
  
• Crear la variable <acum> en <menu()> (línea 28)
  
• Llamar a la función <crearPilaVacia()> en el <printf()> (línea 47)
  
• LLamar a las funciones <pilaVacia()> y <pilaLlena()> (líneas 51 y 56)
  
• El bloque del <case 4> (líneas 62 - 64)
  
• La llamada a la función <sumaPila()> (línea 77)
  
• Los valores de retorno <return> que le has asignado a cada función
  Igual entendiendo por qué haces lo que haces pueda ayudarte ya que de momento no hemos avanzado demasiado.