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:


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


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:


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.

Hola ya cree la clase y le paso los datos pero ahora me dice.
lamento preguntar tanto. pero me quiero arrancar la cabeza.

Hola pense que era por que no habia includio la libreria de string o el usign namespace std; pero no.

y se que hace referencia al constructor de la clase camion pero veo que le mando los parametros o argumentos correctos.

Ya note donde está el problema es que no estoy apuntando a nada. Según leí  Cuando se usa el operador new se tiene que usar apuntadores a fuerza. Y ese es el problema espero resolverlo pronto.

#ifndef LISTACAMIONES_H
#define LISTACAMIONES_H
#include "Camion.h"
#define Maximo 100
 
class listaCamiones
{
      Camion camiones[Maximo];
      int nCamiones;
 
      //Ingresa un nuevo camion
void listaCamiones::ingresarCamion()
{
     int idCamion, anioCamion, cilindrajeCamion, nPuertasCamion;
     double precioCamion;
     string colorCamion, marcaCamion, modeloCamion; 
    //listaDeCamiones = new Camion*[Maximo];// arreglo de 100
 
   if (nCamiones < Maximo)
   { 
     system("cls");
     cout << "Ingrese los datos del camion\n";
     cout << "Ingrese el ID del camion: ";
     cin  >> idCamion;
 
     cout << "Ingrese la Marca del Camion: ";
     cin  >> marcaCamion;
 
     cout << "Ingrese el Modelo del camion: ";
     cin  >> modeloCamion;
 
     cout << "Ingrese el año del Camion: ";
     cin  >> anioCamion;
 
     cout << "Ingrese el cilindraje del camion: ";
     cin  >> cilindrajeCamion;
 
     cout << "Ingrese el numero de puertas: ";
     cin  >>  nPuertasCamion;
 
     cout << "Ingrese el color del camion: ";
     cin  >> colorCamion;
 
     cout << "Ingrese el presio del camion: ";
     cin  >> precioCamion;
 
     Camion nuevoCamion = new Camion(idCamion, cilindrajeCamion, nPuertasCamion, 
                                     anioCamion, precioCamion, marcaCamion, modeloCamion,
                                     colorCamion);
 
     camiones [nCamiones++] = nuevoCamion;
 
     cout << endl <<"Los datos del camion fueron ingresados correctamente\n";
   }
   else
   {
       system("cls");
       cout << "Ya no hay espacio disponible para mas camiones\n"; 
   }
}
 
};
 
#endif

 Camion(int =0, int=0, int=0, int=0, double = 0.0, string = "", string = "", string = "");

Esta declaración será broma, no???

No te recomiendo crear, de buenas a primeras, funciones que usen más de 4 argumentos porque es poco usable... si cometes el error de invertir dos argumentos te vas a dar de cabezazos hasta que des con el problema.

Además es altamente recomendable que en la declaración de las funciones aparezcan los nombres de los argumentos... normalmente cuando estés programando mirarás el archivo de cabecera para recordar el uso de las funciones, ya que suelen ser más sencillos de consultar... si tienen 20 argumentos y encima no están etiquetados te quedas sin esta opción.

Por otro lado, otra sugerencia, deberías eliminar el using namespace std de los archivos de cabecera. Usar espacios de nombres en los archivos de cabecera es una mala práctica porque obliga a arrastrar ese uso a todos los archivos que incluyan esa cabecera... y en algunos casos puede ser contraproducente... por ejemplo si dos funciones o clases se llaman igual y están en espacios de nombres diferentes.

namespace N1
{
  void func( );
}
 
namespace N2
{
  void func( );
}
 
using namespace N1;
using namespace N2;
 
void main( )
{
  // a que func estamos llamando??
  func( );
}

Más cosillas, si estás usando C++... por qué no usas los contenedores para almacenar la lista de camiones?? Son más potentes, versátiles y seguros que los arreglos.

* Potentes porque ofrecen una interfaz... los arreglos no.

* Versátiles porque se adaptan perfectamente a las necesidades de cada programa, solo hay que elegir correctamente el contenedor a utilizar.

* Seguros porque previenen desbordamientos y otros fallos típicos del uso de memoria dinámica.

Y además son muy sencillos de usar:

std::vector< Camion* > Camiones;
Camiones.push_back( new_camion );
 
Camion* camion = Camiones[ 0 ];
 

Si "Camiones" es un arreglo de punteros... "*nuevoCamion" debería ser "nuevoCamion", ya que con el asterisco pasas a usar una variable estática, no un puntero.

Además no has inicializado la variable nCamiones... por lo que ésta pasa a tener un valor aleatorio y, tirando un poco de estadística... si un int ocupa 32 bits y lo llenamos con basura... ¿que posibilidades hay de que el número resultante esté entre cero y 100?? hago constar que con 32 bits el rango de valores va de –2.147.483.648 a 2.147.483.647.

Sin embargo, sacando a relucir el tema del contenedor, el código podría quedar tal que

std::vector< Camion* > camiones;
 
// ...
 
if ( camiones.size( ) < Maximo )
{
  // ...
 
  camiones.push_back( new_camion );
}
else
{
  // ...
}

Hola Muchas gracias a todos, me da hasta un poco de pena molestarlos.
Y antes que nada entiendo si ya no quieren contestar.
Pero como pueden ver no soy muy bueno en C++ y quiero aprenderlo.

Creeo que esta es la parte fea de C++

Tengo una duda no se si es por que no he dormido

En Camion.cpp tengo el maximo ya lo quite ya que lo defini en la clase listasCamiones.cpp.

Maximo =100;
cantidadDeCamiones =0;

Y en Camion.h eso está bien como lo he modificado tanto que así lo tenía cuando funcionaba pero no de la forma correcta pero ahora que estoy hice clase listaCamiones no sé si sean necesarias.

private:
     Camion**listaDeCamiones;
     //int Maximo;
     int cantidadDeCamiones;

Si se fijan estoy probando tanto vectores me señalo eferion y con arreglos por que se, de que de las dos formas es impórtate hacerlo.

Y este es el error con arreglo de punteros. Que es el que mencionaba de la forma de yoel_alejandro.



Y este es la forma en que me señala eferion.

El de vectores ya esta, si funciono y me confundi en esta parte por eso no sabia donde declarar esa varible Gracias.



//Codigo arreglo de punteros
//Camiones.h

#ifndef CAMION_H
#define CAMION_H
#include <iostream>
using namespace std;
// Variables globales si la hay
 
class Camion
{
      //Variables Privadas
      private:
      int idCamion;
      int cilindrajeCamion;
      int nPuertasCamion;
      int anioCamion;
      double precioCamion;
      string marcaCamion, modeloCamion, colorCamion;
 
 
      public:
 
      //Constructores.
      Camion(int =0, int=0, int=0, int=0);
      Camion(double =0.0);
      Camion(string = "", string = "", string = "");
 
      //Funciones o metodos publicos 
      void setIdCamion(int);         //Devuelve el Id del Camion.
      void setCilindrajeCamion(int); //Devuelve el cilindrage del camion
      void setNPuertasCamion(int);   //Devuelve el numero de puertas del camion
      void setanioCamion(int);       //Devuelve el año del camion
      void setPrecioCamion(double);  //Devuelve el precio del camion
      void setMarcaCamion(string);   //Devuelve la marca del camion
      void setModeloCamion(string);  //Devuelve el modelo del camion
      void setColorCamion(string);   //Devuelve el color del camion
 
      int getIdCamion() const;         //Obtiene Id del Camion.
      int getCilindrajeCamion() const; //Obtiene el cilindrage del camion
      int getnPuertasCamion() const;   //Obtiene numero de puertas del camion
      int getanioCamion() const;       //Obtiene el año del camion
      double getPrecioCamion() const;  //Obtiene el precio del camion
      string getMarcaCamion() const;   //Obtiene la marca del camion
      string getModeloCamion() const;  //Obtiene el modelo del camion
      string getColorCamion() const;   //Obtiene el color del camion
 
 
      //Otros Metodos
      void ingresarCamion();
      void flistaDeCamiones();
      void imprimir();
      int buscarCamion(int);
      void modificarCamion();
      void eliminarCamion();
 
      private:
      Camion**listaDeCamiones;
      int cantidadDeCamiones;
 
};
#endif

//Camion.cpp

#include "Camion.h"
#include <iostream>
#include <iomanip>
#include <string>
 
//Constructores valores enteros
Camion::Camion (int idCam, int cilindrajeCam, int puertasCam, int anioCam)
{
  idCamion = idCam;
  cilindrajeCamion = cilindrajeCam;
  nPuertasCamion = puertasCam;
  anioCamion = anioCam;
  cantidadDeCamiones =0;
}
 
//Constructores valores double
Camion::Camion(double precioCam)
{
  precioCamion = precioCam;
}
 
//Constructores valores string
Camion::Camion(string marcaCam, string modeloCam,string colorCam)
{
   marcaCamion = marcaCam;
   modeloCamion = modeloCam;
   colorCamion = colorCam;
}
 
//Funciones set
void Camion::setIdCamion(int idCam)
{
     idCamion = idCam;
}
 
void Camion::setCilindrajeCamion(int cilindrajeCam)
{
     cilindrajeCamion = cilindrajeCam;
}
 
void Camion::setNPuertasCamion(int puertasCam)
{
     nPuertasCamion = puertasCam;
}
 
void Camion::setanioCamion(int anioCam)
{
     anioCamion = anioCam;
}
 
void Camion::setPrecioCamion(double precioCam)
{
     precioCamion = precioCam;
}
 
void Camion::setMarcaCamion(string marcaCam)
{
     marcaCamion = marcaCam;
}
 
void Camion::setModeloCamion(string modeloCam)
{
     modeloCamion = modeloCam;
}
 
void Camion::setColorCamion(string colorCam)
{
     colorCamion = colorCam;
}
 
//Funciones get
int Camion::getIdCamion() const
{
    return idCamion;
}
 
int Camion::getCilindrajeCamion() const
{
    return cilindrajeCamion;
}
 
int Camion::getnPuertasCamion() const
{
    return nPuertasCamion;
}
 
int Camion::getanioCamion()const
{
    return anioCamion;
}
 
double Camion::getPrecioCamion() const
{
       return precioCamion;
}
 
string Camion::getMarcaCamion() const
{
       return marcaCamion;
}
 
string Camion::getModeloCamion() const
{
       return modeloCamion;
}
 
string Camion::getColorCamion() const
{
       return colorCamion;
}

//ListaCamiones.cpp

#ifndef LISTADECAMIONES_H 
#define LISTADECAMIONES_H
#include "Camion.h"
#define MAXIMO 100
 
class listaDeCamiones
{
      //Variables para esta clase
      Camion Camiones[MAXIMO];
      int nCamiones;
 
      void listaDeCamiones::ingresarCamion()
      {
           int idCam, cilindrajeCam, nPuertasCam, anioCam;
           string marcaCam, modeloCam, colorCam;
           double precioCam;
 
           nCamiones =0; //Inicializo variable nCamiones.
 
           //If No sobre pase la cantidad de camiones 
           if (nCamiones < MAXIMO)
           {
            system("cls");
            cout << "Ingrese los datos del camion\n";
            cout << "Ingrese el ID del camion: ";
            cin  >> idCam;
 
            cout << "Ingrese el cilindraje del camion: ";
            cin  >> cilindrajeCam;
 
            cout << "Ingrese el numero de puertas: ";
            cin  >>  nPuertasCam;
 
            cout << "Ingrese el año del Camion: ";
            cin  >> anioCam;
 
            cout << "Ingrese el presio del camion: ";
            cin  >> precioCam;
 
            cout << "Ingrese la Marca del Camion: ";
            cin  >> marcaCam;
 
            cout << "Ingrese el Modelo del camion: ";
            cin  >> modeloCam;
 
            cout << "Ingrese el color del camion: ";
            cin  >> colorCam;
 
            //Instancia de camion y separado por cada constructo     
            Camion *nuevoCamion1 = new Camion(idCam, cilindrajeCam, nPuertasCam, anioCam);
            Camion *nuevoCamion2 = new Camion(precioCam);
            Camion *nuevoCamion3 = new Camion(marcaCam, modeloCam, colorCam);
 
            //Añade al arreglo y lo actualiza                                         
            Camiones[nCamiones++] = new_nuevoCamion;
            cout << endl <<"Los datos del camion fueron ingresados correctamente\n";
            }
 
        else
        {
         system("cls");
         cout << "Ya no hay espacio disponible para mas camiones\n";
        }
     }
};
 
#endif

//Esta parte ya la había probado y estas en lo correcto no tira error de esa forma.

 Camion *nuevoCamion1 = new Camion(idCam, cilindrajeCam, nPuertasCam, anioCam);
            Camion *nuevoCamion2 = new Camion(precioCam);
            Camion *nuevoCamion3 = new Camion(marcaCam, modeloCam, colorCam);

//Ahora el error es acá. Entonces eso quiere decir que ahora tendré que crear un arreglo y que lo actualice de acuerdo a sus argumentos.

 Camiones[nCamiones++] = new_nuevoCamion1;
Camiones[nCamiones++] = new_nuevoCamion2;
Camiones[nCamiones++] = new_nuevoCamion3;

//En esta parte tambien pense lo mismo y era lo que preguntaba mas arriba que si //era asi que es lo que tu mecomentas.

Camion nuevoCamion* = new Camion(idCam, cilindrajeCam, nPuertasCam, anioCam);

En cuanto a la liberación de memoria tengo estas funciones y hay una donde lo hace lo tengo en mente pero no puedo implementarlas si no puedo hacer la primera función que es la de ingresarlos porque estas irían en listaCamiones.Y tengo claro que cambiaran por supuesto y que tengo que arreglarlos también.

//Muestra los datos del camion
void Camion::flistaDeCamiones()
{
     if (cantidadDeCamiones==0)
     {
       system("cls");
       cout<<"No se a registrado ninguna Camion todavía"<<endl;
     }
       else
       {
           cout<<"..:::Lista de Camiones:::.."<<endl<<endl;
           cout << setw(10)<<"Id Camion"<<setw(15)<<"Modelo"<<setw(15)<<"marca"<<endl;
           cout<<"================================================="<<endl;
 
           //Imprimmir todos los camiones almacenadas en el arreglo
           for (int i=0; i<cantidadDeCamiones; i++)
           {
             listaDeCamiones[i]->imprimir(); //PROBLEMA Y NO LO IDENTIFICO
           }
           cout<<endl<<"*******Fin de la lista **********"<<endl<<endl;
       }
}
//Busca ese camion
int Camion::buscarCamion(int codigo)
{
    for (int i=0; i < cantidadDeCamiones; i++)
    {
        if(listaDeCamiones[i]->getIdCamion() == codigo)
        {
          return i;
        }
    }
    return -1;
}
 
//Modifica ese Camion.
void Camion::modificarCamion()
{
     if (cantidadDeCamiones == 0)
     {
       system("cls");
       cout << "No se ha registrado ningun camion tadavia\n";
     }
     else
     {
         cout << "Modificar Camion\n\n";
         int codigoCamion;
         cout << "Ingrese el codigo del camion: ";
         cin >> codigoCamion;
 
         int ubicacion = buscarCamion(codigoCamion);
         if (ubicacion == -1)
         {
           cout << "Lo sentimos ese codigo del camion no existe\n";
         }
         else
         {
             cout << "El codigo se encontro\n\n";
             cout << setw(10)<<"Id"<<setw(15)<<"Modelo"<<setw(15)<<"marca"<<endl;
             cout<<"================================================="<<endl;
 
             listaDeCamiones[ubicacion]->imprimir();
             cout << "\n\n";
             cout  << "Ingrese los nuevos datos del Camion\n\n";
 
             cout <<  "Marca";
             cin  >> marcaCamion;
 
             cout << "Modelo del camion: ";
             cin  >> modeloCamion;
 
             cout << "Año del Camion: ";
             cin  >> anioCamion;
 
             cout << "Cilindraje del camion: ";
             cin  >> cilindrajeCamion;
 
             cout << "numero de puertas: ";
             cin  >>  nPuertasCamion;
 
             cout << "Color del camion: ";
             cin  >> colorCamion;
 
             cout << "Presio del camion: ";
             cin  >> precioCamion;
 
             listaDeCamiones[ubicacion]->setMarcaCamion(marcaCamion);
             listaDeCamiones[ubicacion]->setModeloCamion(modeloCamion);
             listaDeCamiones[ubicacion]->setanioCamion(anioCamion);
             listaDeCamiones[ubicacion]->setCilindrajeCamion(cilindrajeCamion);
             listaDeCamiones[ubicacion]->setNPuertasCamion(nPuertasCamion);
             listaDeCamiones[ubicacion]->setColorCamion(colorCamion);
             listaDeCamiones[ubicacion]->setPrecioCamion(precioCamion);
 
             cout << "El camion fue modificado Exitosamente.\n";
         }
     }
}
 
void Camion::eliminarCamion()
{
     if (cantidadDeCamiones == 0)
     {
       system("cls");
       cout << "No se ha registrado ningun camion tadavia\n";
     }
     else
     {
         cout << "Eliminar Camion\n\n";
         int codigoCamion;
         cout << "Ingrese el codigo a eliminar: ";
         cin >> codigoCamion;
 
         int ubicacion = buscarCamion(codigoCamion);
         if (ubicacion == -1)
         {
           cout << "Lo sentimos ese codigo del camion no existe\n";
         }
         else
         {
             cout << "El codigo se encontro\n\n";
             cout << setw(10)<<"Id"<<setw(15)<<"Modelo"<<setw(15)<<"marca"<<endl;
             cout<<"================================================="<<endl;
 
             listaDeCamiones[ubicacion]->imprimir();
             cout << "\n\n";
 
             cout << "Presione enter para eliminar ese camion\n\n";
             system("pause");
 
             //Pasa a eliminar usando una copia del arreglo
             Camion**temporalListaDeCamiones = new Camion*[Maximo];
             int temporalCantidadDeCamiones = 0;
 
             //Se copia el arreglo en otro arreglo exepto el que se quiere eliminar
             for(int i =0; i < cantidadDeCamiones; i++)
             {
               if(i!=ubicacion)
               {
                 temporalListaDeCamiones[temporalCantidadDeCamiones] = new Camion(listaDeCamiones[i]->getIdCamion(),
                                                                                  listaDeCamiones[i]->getCilindrajeCamion(),
                                                                                  listaDeCamiones[i]->getnPuertasCamion(),
                                                                                  listaDeCamiones[i]->getanioCamion(),
                                                                                  listaDeCamiones[i]->getPrecioCamion(),
                                                                                  listaDeCamiones[i]->getMarcaCamion(),
                                                                                  listaDeCamiones[i]->getModeloCamion(),
                                                                                  listaDeCamiones[i]->getColorCamion());
                 temporalCantidadDeCamiones++;
               }//Fin if
             }//Fin for
 
             //Limpio la memoria usada por el arreglo principal de camiones
             for(int i=0; i<cantidadDeCamiones; i++)
             {
               listaDeCamiones[i]->~Camion();
             }
 
             //copia el arreglo temporal al principio
             cantidadDeCamiones = 0;
             for(int i =0; i<temporalCantidadDeCamiones; i++)
             {
                listaDeCamiones[cantidadDeCamiones] = new Camion(temporalListaDeCamiones[i]->getIdCamion(),
                                                                 temporalListaDeCamiones[i]->getCilindrajeCamion(),
                                                                 temporalListaDeCamiones[i]->getnPuertasCamion(),
                                                                 temporalListaDeCamiones[i]->getanioCamion(),
                                                                 temporalListaDeCamiones[i]->getPrecioCamion(),
                                                                 temporalListaDeCamiones[i]->getMarcaCamion(),
                                                                 temporalListaDeCamiones[i]->getModeloCamion(),
                                                                 temporalListaDeCamiones[i]->getColorCamion());
                cantidadDeCamiones++;
             }//Fin for
             cout << "El camion fue eliminado exitosamente\n\n";
         }//fin else
     }
 
}
 
//Imprime los datos del Camion
void Camion::imprimir()
{
     cout<<setw(10)<<idCamion<<setw(15)<<modeloCamion<<setw(15)<<marcaCamion<<endl;
}