C ++ Violación de matriz de acceso dinámico

Question

**** Lo siento por la confusión con respecto a numCars en el post original. He modificado el código para ser compatible con el original ******

El siguiente programa académico es una versión simplificada del problema original, pero se centra en la cuestión de que todavía tengo que resolver. Hay 2 clases y un método principal para este problema y las 2 clases consisten en una clase de distribuidores y una clase de coches. La clase del distribuidor tiene un puntero privada de coches * que se inicializa a una matriz dinámica en el constructor del distribuidor. El error se produce en el método principal cuando se invoca el método addCar del repartidor. En el método principal Paso intencionalmente la variable del distribuidor con el método addCar (Comerciante y d) para imitar la estructura de la solicitud original. El método addCar continuación, llama al método en que la violación de acceso cuando ejecuto coches [numCars ++] = coche addCar del distribuidor (const auto y coche); ¿Puede explicar por qué los coches [numCars ++] = resultados de coche en una violación de acceso

/**********************************Dealer.h**************************/
#include <cstdlib>
#include "Car.h"

using namespace std;

class Dealer
{
    public:
        Dealer(int maxCars = DEFAULT_MAX_CARS)

: numCars (0) {Coches = nuevo coche [maxCars];}

        ~Dealer(){delete [] cars;}

        int getTotalCars() const { return numCars;}

        void addCar(const Car& car)
        {       
             cars[numCars++] = car; // Access Violation
        }

        Car* begin(){return cars;};

        Car* end(){ return cars + numCars;} 

setNumCars (recuento int) {numCars = contar;}

    private:
        static const int DEFAULT_MAX_CARS = 10;
        Car* cars;
        int numCars;
};

/**********************************Car.h**********************/
#include <cstdlib>
#include <string>

using namespace std;


class Car{
    public:

        Car()
            : year(0), make(""), model("")
        {}

        Car(int year, string make, string model)
            : year(year), make(make), model(model)
        {}      

        string getMake() const {return make;}
        void setMake(string make){this->make=make;}

        string getModel() const {return model;}
        void setModel(string model){this->model=model;}

        int getYear() const {return year;}
        void setYear(int year){this->year=year;}

    private:
        int year;
        string make;
        string model;       
};


ostream& operator<< (ostream& out, const Car& car)
{
    out << car.getYear() << " " << car.getMake() << " " << car.getModel();
    return out;
}

/**********************************Main.cpp**********************/
#include &lt;cstdlib&gt;
#include &lt;iostream&gt;
#include "Dealer.h"

using namespace std;

void addCar(Dealer& d);

int main(int argc, char *argv[])
{
    Dealer d;

    addCar(d);  

    system("PAUSE");
    return EXIT_SUCCESS;
}

void addCar(Dealer& d)
{
    d = Dealer();

    d.addCar(Car(2007, "Honda", "Civic"));

    cout << d.getTotalCars() << " total cars" << endl;
}

Answer 1

void addCar(const Car& car)
{
     cars[numCars++] = car; // Access Violation
}

Nunca inicializar numCars - contiene algún valor del montón, que casi sin duda es distinto de cero. Esto hace que se lee más allá del final de la matriz coches y en la memoria inaccesible. Debe establecer numCars a 0 en su constructor.

Además de esto, usted debe tener algunas comprobaciones en addCar de modo que usted no está invadido la matriz coches.

EDIT:

Hay algunos otros problemas con el código - por ejemplo, "d = Distribuidor ();" crea un nuevo distribuidor y sobrescribe el que se pasa por referencia a addCars lo cual no parece ser lo que quiere hacer.

Trate de añadir un poco de seguimiento adicional al constructor / destructores para verificar que los constructores que considera que están siendo llamados en realidad son - parece que Dealer () debe ser invocando el constructor con un argumento predeterminado que ha especificado, pero si no se está haciendo el constructor por defecto.

Answer 2

No está inicializando numCars en cualquier lugar, debe ponerlo a 0:

Dealer(int maxCars = DEFAULT_MAX_CARS) :
numCars(0)
{
    cars = new Car[maxCars];
}

¿Tiene utilizar punteros primas? ¿Por qué no lo envuelve y utilizar en su lugar std::vector?

Answer 3

No hay nada en el código anterior inicializa Comerciante :: numCars. Por lo tanto, puede ser cualquier basura aleatoria.

Answer 4

Tal vez no lo veo, pero ¿dónde se configura inicialmente numCars?

Answer 5

Esto parece un pérdida de memoria a mí, ya que, no se libera la memoria anterior, celebrada por el coches puntero:

setNumCars(0) {cars = new Car[maxCars];}

y este código debe realmente debe protegerse de la condición de desbordamiento:

void addCar(const Car& car)        
{                                
   cars[numCars++] = car; // Access Violation        '
}

haciendo algo como esto:

void addCar(const Car& car)        
{                                
   if (numCars < maxCars)
      cars[numCars++] = car;        '
   else
      // throw and exception .....
      // or better still grow the cars buffer
}

Answer 6

cars[numCars++] = car; // Access Violation

No veo ningún problema desde el código publicado. Puede ser un problema está en otra parte?

Probablemente puede probar lo siguiente:

• matrices de cambio a vectores y tratar de usar al () para atrapar out_of_range excepción. algo como:

     std::vector<int> myVec;
     try
     {
      int x = myVec.at(0);
  
     }
     catch(std::out_of_range& oor)
     {
          printf("\nout of range ");
     }