Mensajes

Hola nolasco, acabo de revisar tu código. En rasgos generales, pero tienes como un pequeño problema de organización. Fíjate que estás guardando la cantidad de camiones como un miembro de cada objeto (o "instancia") de la clase Camion. Eso es absurdo. Imagínate que creas un primer objeto Camion, entonces su campo cantidadDeCamiones tiene el valor de 1, porque hasta el momento has creado un solito objeto de dicha clase.

Ahora creas otro camión. El primero tiene el campo cantidadDeCamiones = 1, el segundo tiene cantidadDeCamiones = 2, porque (a menos que yo haya leído mal el código) tú no actualizas el campo cantidadDeCamiones en cada uno de los objetos anteriormente creados de la clase Camion (¿verdad?). Y creo que precisamente por eso es que te imprime uno solo, porque la primera instancia creada tiene el valor cantidad de camiones en "1".

En todo caso, hacer esto de esa manera tampoco sería lo ideal. Yo te recomendaría definir una clase aparte listaCamiones con dos únicos campos: Uno un arreglo de camiones y otro un entero indicando la cantidad de camiones creados hasta el momento:

Código [Seleccionar] Expandir


class listaCamiones {
public:
    Camion Camiones[ MAXIMO ];
    int N_Camiones;
}


La constante MAXIMO (que tú quieres sea 100) yo te recomiendo la definas como una macro de cabecera:

Código [Seleccionar] Expandir


#define MAXIMO 100


ya que es un valor que se supone debe permanecer constante durante todo el programa (si la pones como variable int, ¿te imaginas qué pasaría si por error cambias su valor durante el programa?)

Los métodos ingresarCamion(), flistaDeCamiones(), imprimir(), buscarCamion(int), modificarCamion(), eliminarCamion() serían de la clase listaCamiones, y no de la clase individual Camion (¿vas captando la idea?). Al añadir un nuevo camión puedes hacer algo como esto:

Código [Seleccionar] Expandir


void listaCamiones :: ingresarCamion( ) {
   
    /* aquí pides los datos para el nuevo camión */

    /* creas una instancia de Camion */
    Camion new_Camion = new Camion( idCamion, cilindrajeCamion,
        nPuertasCamion, anioCamion,
        precioCamion, marcaCamion,
        modeloCamion,colorCamion);

    /* y la añades al arreglo, actualizando el contador */
    Camiones[ N_Camiones++ ] = new_Camion;
}


Ahora debes definir la función de imprimir lista como un método de la clase listaCamiones, y ya debería imprimir todos los camiones.
En fin, sólo hace falta una pequeña reingeniería del software (mover unas cosas de aquí para allá) y debería estar funcionando bien.

Saludos, y cualquier cosa comenta, .... Yoel.

Por cierto yookino, en el otro foro donde habías puesto la pregunta te puse una respuesta más detallada sobre el (sutils) asunto aquí desarrollado. Era esta:

===========================================================
Aparte del error en el printf, tu programa tiene un problema muy sutil, justo de esa clase que los hace difíciles de localicar. Una de las mayores potencias del lenguaje C es la capacidad de manejar punteros, pero esa ventaja se puede convertir a veces en dolor de cabeza.

La función llenar está codificada de manera de recibir un arreglo de punteros. Aquí debes tener en cuenta la "precedencia" de los operadores de C, pues el operador [] (acceso a elemento arreglo) tiene mayor precedencia que el operador * (indirección). O sea, que la sentencia:


*ptrnumeros[0]=25;


primero ejecuta el "[]", luego el "*". O sea, extrae el primer elemento del arreglo prtnumeros, que debe ser un puntero (o sea, la dirección de un dato en la memoria), y luego obtiene el dato apuntado por dicha dirección.

Ahora, bien, en la sentencia


llenar(&numeros);


no estás pasando un arreglo de punteros sino un arreglo por referencia (que es otra cosa). Si fueras a hacer eso, la función llenar debería esta codificada más bien como:


(*ptrnumeros)[0]=25;


que PRIMERO convierte la dirección al arreglo en un arreglo, y luego accesa a su elemento. Ahí debería funcionar sin problemas.

Los arreglos de punteros se usan por ejemplo para crear matrices bidimensionales y la verdad no tiene nada que ver con tu ejercicio. Para tu caso yo recomendaría una solución más senclla, como:

Código [Seleccionar] Expandir



void llenar(int* numeros)
 {
     numeros[0]=25;
     numeros[1]=50;
 }

void main()
 {
    int numeros[2];

    llenar(numeros);
    printf("%d, %d ",numeros[0],numeros[1]);

    getch();
  }


Puesto que en C un arreglo es un puntero (al primer elemento del array), "numeros" es a la vez un arreglo de int, y un puntero a int. Con esto debería funcionar perfectamente, no se por qué te fuiste por una solución tan complicada.

Espero te ayude  
Yoel.

Hola a todos, continuando con la idea de Benjo (el tema de punteros es amplio, hay MUCHAS maneras y combinaciones para hacer una misma cosa), podríamos escribirlo también así:

Código [Seleccionar] Expandir


    void llenar(int *numero_ptr)
     {
         *numero_ptr = 25;
         *(numero_ptr + 1) = 50;
     }
     
    void main()
     {
        int numeros[2];
     
        llenar(numeros);
        printf("%d, %d ",numeros[0],numeros[1]);
     
        getch();
      }


donde hacemos la aritmética de punteros en la misma línea, sin necesidad de hacerlo por separado. Repito, una de las varias maneras que hay de hacerlo.

Saludos a todos, Yoel

Hola yookino, te explico. Aparte del error en el printf, tu programa tiene un problema muy sutil, justo de esa clase que los hace difíciles de localicar. Una de las mayores potencias del lenguaje C es la capacidad de manejar punteros, pero esa ventaja se puede convertir a veces en dolor de cabeza.

La función llenar está codificada de manera de recibir un arreglo de punteros. Aquí debes tener en cuenta la "precedencia" de los operadores de C, pues el operador [] (acceso a elemento arreglo) tiene mayor precedencia que el operador * (indirección). O sea, que la sentencia:

Código [Seleccionar] Expandir


*ptrnumeros[0]=25;


primero ejecuta el "[]", luego el "*". O sea, extrae el primer elemento del arreglo prtnumeros, que debe ser un puntero (o sea, la dirección de un dato en la memoria), y luego obtiene el dato apuntado por dicha dirección.

Ahora, bien, en la sentencia

Código [Seleccionar] Expandir


llenar(&numeros);


no estás pasando un arreglo de punteros sino un arreglo por referencia (que es otra cosa). Si fueras a hacer eso, la función llenar debería esta codificada más bien como:

Código [Seleccionar] Expandir


(*ptrnumeros)[0]=25;


que PRIMERO convierte la dirección al arreglo en un arreglo, y luego accesa a su elemento. Ahí debería funcionar sin problemas.

Los arreglos de punteros se usan por ejemplo para crear matrices bidimensionales y la verdad no tiene nada que ver con tu ejercicio. Para tu caso yo recomendaría una solución más senclla, como:

Código [Seleccionar] Expandir


void llenar(int* numeros)
  {
      numeros[0]=25;
      numeros[1]=50;
  }

void main()
  {
     int numeros[2];

     llenar(numeros);
     printf("%d, %d ",numeros[0],numeros[1]);

     getch();
   }


Puesto que en C un arreglo es un puntero (al primer elemento del array), "numeros" es a la vez un arreglo de int, y un puntero a int. Con esto debería funcionar perfectamente, no se por qué te fuiste por una solución tan complicada.

Espero te ayude 
Yoel.