C++: EXC_BAD_ACCESS lors de la transmission du pointeur de tableau obtenu à partir du vecteur

Question

Edit: Je l'ai compris. Lorsque deflateReadOut() instancie le tableau, il est trop volumineux pour être dans la pile, de sorte qu'il renvoie l'erreur EXC_BAD_ACCESS lors de son appel. Lien utile: link

Cette erreur EXC_BAD_ACCESS m'a dérouté. Ce que mon programme fait jusqu'ici est de faire un tableau vectoriel 2D contenant quatre grands tableaux de chars non signés, remplit celui de la position 0 avec 100s et essaie de passer le pointeur pointant vers ce tableau avec tous les 100s. Cependant, quand il arrive à l'appel de la fonction, l'erreur EXC_BAD_ACCESS se produit. J'ai vérifié l'intégrité de la matrice en imprimant et il imprime bien. Code ci-dessous.

#include <stdint.h> 
#include <map> 
#include <stdio.h> 
#include <iostream> 
#include <time.h> 
#include <string.h> 
#include <assert.h> 
#include <cstdlib> 
#include <sstream> 
#include <zlib.h> 
#include "Hash.h" 

#define CHUNK 16777216 

using namespace std; 

class WSUMap { 
public: 

    vector<vector <unsigned char> > chunk; 
    int xComp[4]; 
    int yComp[4]; 
    vector<int> priority; 
    Hash hashChunk; 

    WSUMap() { 
     chunk.reserve(4); 
     chunk[0] = vector<unsigned char>(CHUNK); 
     chunk[1] = vector<unsigned char>(CHUNK); 
     chunk[2] = vector<unsigned char>(CHUNK); 
     chunk[3] = vector<unsigned char>(CHUNK); 
     priority.push_back(0); 
     priority.push_back(1); 
     priority.push_back(2); 
     priority.push_back(3); 
     xComp[0] = -1; 
     xComp[1] = -1; 
     xComp[2] = -1; 
     xComp[3] = -1; 
     yComp[0] = -1; 
     yComp[1] = -1; 
     yComp[2] = -1; 
     yComp[3] = -1; 
    } 

    //Important part starts here: 

    void generate() { 
     for (int i = 0; i<CHUNK; i++) { 
      chunk[0][i]=100; 
     } 
     for (int i = 0; i < 16; i++) { 
      for (int j = 0; j < 16; j++) { 
       cout << chunk[0][0] << endl; 
       unsigned char* ch = &chunk[0][0]; 
       cout << ch[0] << endl; 
       deflateReadOut(i, j, ch); //EXC_BAD_ACCESS Here 
      } 
     } 
    } 

    void deflateReadOut(int x, int y, unsigned char* chunk) { 


     int ret, flush; 
     unsigned have; 
     z_stream strm; 
     unsigned char out[CHUNK]; 

     /* allocate deflate state */ 
     strm.zalloc = Z_NULL; 
     strm.zfree = Z_NULL; 
     strm.opaque = Z_NULL; 
     ret = deflateInit(&strm, 1); 
     if (ret != Z_OK); 
     //return ret; 

     ostringstream oss; 
     oss << "map/" << x << "x" << y; 
     string str = oss.str(); 
     FILE* dest = fopen(str.c_str(), "w"); 

     /* run deflate() on input until output buffer not full, finish 
      compression if all of source has been read in */ 
     do { 
      strm.avail_out = CHUNK; 
      strm.next_in = chunk; 
      strm.next_out = out; 

      ret = deflate(&strm, flush); /* no bad return value */ 
      assert(ret != Z_STREAM_ERROR); /* state not clobbered */ 

      have = CHUNK - strm.avail_out; 
      if (fwrite(out, 1, have, dest) != have || ferror(dest)) { 
       (void) deflateEnd(&strm); 
       //return Z_ERRNO; 
      } 

     } while (strm.avail_out == 0); 
     assert(strm.avail_in == 0); /* all input will be used */ 

     /* clean up and return */ 
     (void) deflateEnd(&strm); 
    } 

Nous vous remercions de votre aide.

Answer 1

Ce:

chunk.reserve(4); 

devrait être:

chunk.resize(4); 

Sinon, vous êtes juste incrémenter la capacité au lieu de la taille du vecteur réel.

Vous pouvez également initialiser le vecteur dans la liste d'initialisation:

WSUMap() 
: chunk(4, vector<unsigned char>(CHUNK)) 
{ 

} 

C'est équivalent à incrémenter la taille et l'initialisation des vecteurs individuels.