치명적인 오류 코드의 작은 덩어리로이 문제를 갖는 2 차원 배열

Question

임 인쇄시 :

for(x = 0; x < 8; x++){ 
for(y = 0; y < 8; y++){ 
printf(" %d", occupy[x][y]); 
} 
printf(" \n"); 
} 

나는 게임 보이를 위해 임의로 생성 된 미로 게임을 만들고 있어요, 나는 2 차원 배열을 사용하고 있습니다 각 화면이 미로 어디에 있는지 알기. 테스트를 위해 필자는이 어레이를 인쇄하려고 시도하고 있으므로 계속 진행하기 전에 제대로 생성되는지 확인할 수 있습니다. 그 작은 덩어리의 코드로 컴파일하려고 할 때, 그 맨 윗줄에 오류가 생기면 파일에있는 치명적인 컴파일러 내부 오류가 나옵니다. 내가 알지 못하는 코드에 큰 no-no가 있습니까?

전체 코드는 : 내가 변경 한 그것을 수정 무엇을 왜 모르겠어요하지만

#include <gb\gb.h> 
#include <stdio.h> 
#include <rand.h> 


#define UP 0x01U 
#define RIGHT 0x02U 
#define DOWN 0x04U 
#define LEFT 0x08U 

int occupy[8][8]= { 
{0,0,0,0,0,0,0,0}, 
{0,0,0,0,0,0,0,0}, 
{0,0,0,0,0,0,0,0}, 
{0,0,0,0,0,0,0,0}, 
{0,0,0,0,0,0,0,0}, 
{0,0,0,0,0,0,0,0}, 
{0,0,0,0,0,0,0,0} 
}; 


void generate(){ 
int temp; 
int x; 
int y; 
UBYTE restrict; 
UBYTE direction; 
for(x = 0; x < 8; x++){ 
for(y = 0; y < 8; y++){ 
occupy[x][y] = 0; 
} 
} 
/* ========Occupy=Cleared========== */ 
restrict = 0x00U; 
x = rand() & 7; 
y = rand() & 7; 

if(x == 6 || x == 7){ restrict += RIGHT;} 
if(x == 0 || x == 1){ restrict += LEFT;} 
if(y == 0 || y == 1){ restrict += UP;} 
if(y == 6 || y == 7){ restrict += DOWN;} 

/* in the rest of generation wrap this block in if(restrict != 0x0FU){ */ 

do{ 
temp = rand() & 3; 
if(temp == 0){ direction = UP;} 
if(temp == 1){ direction = RIGHT;} 
if(temp == 2){ direction = DOWN;} 
if(temp == 3){ direction = LEFT;} 
}while(restrict & direction); 


occupy[x][y] = 5; 
if(direction == UP){ occupy[x][y-1] = 1;} 
if(direction == RIGHT){ occupy[x+1][y] = 2;} 
if(direction == DOWN){ occupy[x][y+1] = 3;} 
if(direction == LEFT){ occupy[x-1][y] = 4;} 

for(x = 0; x < 8; x++){ 
for(y = 0; y < 8; y++){ 
printf(" %d", occupy[x][y]); 
} 
printf(" \n"); 
} 

} 


void main(){ 
generate(); 

} 

Answer 1

이, GBDK 벌금의 내 버전에서 컴파일합니다.

변경했다 :

• occupy
  오히려 단지 int보다 unsigned int 배열 (변경없이 sdcc 충돌)의 값은 그대로 (" %u"에 " %d"에서 변경된 루프 내부
• printf 호 지금 부호 없음)

• 의 주소를 나타내는 printf이 추가되었습니다. 제거하거나 다른 작업을 수행하기 위해 변경하면 sdcc 충돌이 발생합니다. 이것은 바보 같지만 꼭 필요한 것 같습니다. 나는 무의미한 것을 필요로하지 않는 대안을 찾고있다. printf. (이 $0000를 해결하기 위해 쓰려고 같이하지만 읽기 전용 실패하는 것) 아무것도 결과 다음 대신 사용할 수 있다는

  • 주, 인쇄되고. 여전히 바보 같지만 아무것도 표시하지 않습니다. 그것은 아직도 약간 감속을 일으키는 원인이 될지도 모르다.

    sprintf(0, "", &occupy); 
    

• 또한 들여 쓰기를 향상시켰다.

  • 당신은 이제까지 RNG를 초기화하지 않기 때문에 그 결과는 항상 동일합니다 :

  #include <gb\gb.h> 
  #include <stdio.h> 
  #include <rand.h> 
  
  
  #define UP 0x01U 
  #define RIGHT 0x02U 
  #define DOWN 0x04U 
  #define LEFT 0x08U 
  
  unsigned int occupy[8][8] = { 
      {0,0,0,0,0,0,0,0}, 
      {0,0,0,0,0,0,0,0}, 
      {0,0,0,0,0,0,0,0}, 
      {0,0,0,0,0,0,0,0}, 
      {0,0,0,0,0,0,0,0}, 
      {0,0,0,0,0,0,0,0}, 
      {0,0,0,0,0,0,0,0}, 
      {0,0,0,0,0,0,0,0} 
  }; 
  
  void generate(){ 
      int temp; 
      int x; 
      int y; 
      UBYTE restrict; 
      UBYTE direction; 
  
      for(x = 0; x < 8; x++){ 
       for(y = 0; y < 8; y++){ 
        occupy[x][y] = 0; 
       } 
      } 
      /* ========Occupy=Cleared========== */ 
      restrict = 0x00U; 
      x = rand() & 7; 
      y = rand() & 7; 
  
      if(x == 6 || x == 7){ restrict += RIGHT;} 
      if(x == 0 || x == 1){ restrict += LEFT;} 
      if(y == 0 || y == 1){ restrict += UP;} 
      if(y == 6 || y == 7){ restrict += DOWN;} 
  
      /* in the rest of generation wrap this block in if(restrict != 0x0FU){ */ 
  
      do{ 
       temp = rand() & 3; 
       if(temp == 0){ direction = UP;} 
       if(temp == 1){ direction = RIGHT;} 
       if(temp == 2){ direction = DOWN;} 
       if(temp == 3){ direction = LEFT;} 
      }while(restrict & direction); 
  
  
      occupy[x][y] = 5; 
      if(direction == UP){ occupy[x][y-1] = 1;} 
      if(direction == RIGHT){ occupy[x+1][y] = 2;} 
      if(direction == DOWN){ occupy[x][y+1] = 3;} 
      if(direction == LEFT){ occupy[x-1][y] = 4;} 
  
      printf(" %x\n", &occupy); //Strangely without this printf it doesn't compile??? 
      for(x = 0; x < 8; x++){ 
       for(y = 0; y < 8; y++){ 
        printf(" %u", occupy[x][y]); 
       } 
       printf(" \n"); 
      } 
  
  } 
  
  
  void main(){ 
      generate(); 
  } 
  

  다음은 코드에 대한 몇 가지 다른 의견입니다. 시드를 설정하는 몇 가지 방법이 있습니다. 일반적으로 제목 화면에서 시간을내어 수행하거나 시드 선택기를 사용할 수 있습니다.

  //Seeds RNG by time taken to press start 
  void seedRNG() { 
      UINT16 seed = 0; 
  
      printf("Press start\n"); 
      while (!(joypad() & J_START)) { 
       seed++; 
      } 
      initrand(seed); 
  } 
  

  //Seeds RNG with a user-chosen number. 
  //Requires inclusion of <gb\console.h>. 
  void seedRNG() { 
      UINT16 seed = 0x8000U; //In the middle to prevent over/underflow issues 
  
      printf("Seed:"); 
  
      while (!(joypad() & J_START)) { 
       if (joypad() & J_UP) { seed++; } 
       if (joypad() & J_DOWN) { seed--; } 
       gotoxy(0,1); 
       printf("%x\n", seed); 
       delay(10); 
      } 
      initrand(seed); 
  } 
  

• 당신은 실제로 당신이 대부분의 에뮬레이터에있는 "메모리 뷰어"를 사용할 수 있기 때문에,이 경우를 볼 수 물건을 인쇄 할 필요가 없습니다. 위치는 -Wl-j 또는 -Wl-m 옵션으로 생성 된 RAM 맵에서 찾을 수 있습니다.

• 나는 그들의 이름에 크기를 포함로, 요법 INT16 또는 WORD보다는 int 및 UINT16 또는 UWORD보다는 unsigned int을 사용하는 것이 좋습니다. UBYTE 등도 사용하기에 좋습니다.

Answer 2

the following compiles 



#include <stdio.h> 
#include <stdlib.h> // contains rand and srand function prototypes 
#include <time.h> 
//#include "gb\gb.h" 

void generate(void); 

#define UP 0x01U 
#define RIGHT 0x02U 
#define DOWN 0x04U 
#define LEFT 0x08U 
typedef unsigned char UBYTE; 

int occupy[8][8] = 
{ 
    {0,0,0,0,0,0,0,0}, 
    {0,0,0,0,0,0,0,0}, 
    {0,0,0,0,0,0,0,0}, 
    {0,0,0,0,0,0,0,0}, 
    {0,0,0,0,0,0,0,0}, 
    {0,0,0,0,0,0,0,0}, 
    {0,0,0,0,0,0,0,0}, 
    {0,0,0,0,0,0,0,0} 
}; 

int main() 
{ 
    generate(); 
    return(0); 
} 


void generate() 
{ 
    int temp; 
    int x; 
    int y; 
    UBYTE block; 
    UBYTE direction; 

    for(x = 0; x < 8; x++) 
    { 
     for(y = 0; y < 8; y++) 
     { 
      occupy[x][y] = 0; 
     } 
    } 
    /* ========Occupy=Cleared========== */ 
    block = 0x00U; 
    srand(time(NULL)); // initialize rand() 
    x = rand() & 8; 
    y = rand() & 8; 

    if(x == 6 || x == 7){ block += RIGHT;} 
    if(x == 0 || x == 1){ block += LEFT;} 
    if(y == 0 || y == 1){ block += UP;} 
    if(y == 6 || y == 7){ block += DOWN;} 

    /* in the rest of generation wrap this block in if(block != 0x0FU){ */ 

    // NOTE: 
    // in the following while loop if direction is not the same a block 
    // then the loop will immediately exit 
    // probably not what you want to do. 
    do{ 
     temp = rand() & 4; 
     if(temp == 0){ direction = UP;} 
     if(temp == 1){ direction = RIGHT;} 
     if(temp == 2){ direction = DOWN;} 
     if(temp == 3){ direction = LEFT;} 
    } while(block & direction); 


    // NOTE: 
    // in the following code, 
    // 'x' and/or 'y' could be 0 or 7 
    // in either case, one or more of the following statements 
    // can/will cause accessing outside of the bounds 
    // of the occupy[][] array 
    occupy[x][y] = 5; 
    if(direction == UP) { occupy[x][y-1] = 1;} 
    if(direction == RIGHT){ occupy[x+1][y] = 2;} 
    if(direction == DOWN) { occupy[x][y+1] = 3;} 
    if(direction == LEFT) { occupy[x-1][y] = 4;} 

    for(x = 0; x < 8; x++) 
    { 
     for(y = 0; y < 8; y++) 
     { 
      printf(" %d", occupy[x][y]); 
     } 
     printf(" \n"); 
    } 
}