C ++ Violação matriz de acesso dinâmico

Question

**** Desculpe pela confusão a respeito numCars no post original. Eu modifiquei o código para ser coerente com o original ******

O programa acadêmico que se segue é uma versão simplificada do problema original, mas centra-se sobre a questão que eu ainda tenho que resolver. Existem 2 classes e um método principal para este problema e as 2 classes consistem em uma classe Comerciantes e uma classe Car. A classe Dealer tem um carro particular * ponteiro que é inicializado com uma matriz dinâmica no construtor do Dealer. O erro ocorre no método principal quando o método addCar do Dealer é invocado. No método principal que intencionalmente transmitir a variável negociante para o método addCar (Fornecedor & d) para imitar a estrutura do pedido original. O método addCar então invoca addCar do Dealer (const Car & carro) método onde a violação de acesso ocorre quando eu executar carros [numCars ++] = carro; Você pode explicar por que os carros [numCars ++] = carro resulta em uma violação de acesso

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

using namespace std;

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

: numCars (0) {Carros = carro novo [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 (int count) {numCars = contagem;}

    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
}

Você nunca inicializar numCars - ele contém algum valor da pilha que quase é definitivamente diferente de zero. Isso faz com que você a ler para além do fim da matriz de carros e na memória inacessível. Você deve definir numCars a 0 em seu construtor.

Além de tudo isso, você deve ter algumas verificações em addCar de modo que você não superação da matriz carros.

EDIT:

Existem alguns outros problemas com o código - por exemplo, "d = fornecedor ();" cria um novo Distribuidor e substitui o que você passar por referência a addCars que não parece ser o que você quer fazer.

Tente adicionar alguns rastreamento adicionais para o construtor / destruidores para verificar se os construtores você acha que estão sendo chamados realmente são - parece que o Dealer () deve ser invocando o construtor com um argumento padrão especificado, mas se não está ficando o construtor padrão.

Answer 2

Você não está inicializando numCars em qualquer lugar, você deve configurá-lo para 0:

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

Você tem que usar ponteiros crus? Por que não envolvê-lo e uso std::vector vez?

Answer 3

Nada no código acima inicializa negociante :: numCars. Portanto, pode ser qualquer lixo aleatório.

Answer 4

Talvez eu não estou vendo isso, mas onde você inicialmente definido numCars?

Answer 5

Isto parece um Memória vazamento para mim desde que, você não liberar a memória anterior, realizada pelas carros ponteiro:

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

e este código deve realmente deve precaver-se contra a condição de overflow:

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

fazendo algo parecido com isto:

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

Não vejo qualquer problema do código postado. Pode ser problema está em outro lugar?

Provavelmente você pode tentar seguinte:

• mudanças de matrizes para vector e tentar usar a () para pegar out_of_range excepção. algo como:

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