Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
C/C++ - [help] allocazione dinamica matrice
Forum - C/C++ - [help] allocazione dinamica matrice

Avatar
norbix (Ex-Member)
Newbie


Messaggi: 15
Iscritto: 14/09/2008

Segnala al moderatore
Postato alle 2:03
Venerdì, 26/09/2008
funzione fill_matrix(), riesce a scrivere solo le prime 10 righe, non oltre, perchè?

ho controllato la funzione build_matrix(), funziona correttamente, anche perchè tutte e 25 le righe della matrice possono essere lette (anche se contengono caratteri strani dato che non sono state settate)

Codice sorgente - presumibilmente C++

  1. // nxsnake == NorbiX's Snake
  2.  
  3. // Author: NorbiX
  4. // MSN:    bobcat01@hotmail.com
  5. // e-mail: xibron[at]gmail[dot]com
  6.  
  7. #include <stdio.h>
  8. #include <conio.h>
  9. #include <windows.h>
  10.  
  11. void start_game(void);
  12. char **build_matrix(int x, int y);
  13. void fill_matrix(char **matrix, int x, int y, char c);
  14. void print_matrix(char **matrix, int x, int y);
  15. void get_matrix_size(char **matrix, int *x, int *y);
  16. void get_console_size(int *x, int *y);
  17. void clear(void);
  18. char *fast_clear_init(void);
  19. void fast_clear(char *text);
  20. void gotoXY(int x, int y);
  21.  
  22. // eliminare get_matrix_size(), dato che non è possibile implementarla
  23. int main()
  24. {
  25.      int x, y;
  26.      char **matrix;
  27.  
  28.      get_console_size(&x, &y);
  29.      printf("console size: %dx%d\n", x, y);
  30.      getch();
  31.  
  32.      matrix = build_matrix(x, y);
  33.      fill_matrix(matrix, x, y, 'X');
  34.      //print_matrix(matrix, x, y);
  35.  
  36.      printf("matrix size: %dx%d\n", x, y);
  37.      getch();
  38.  
  39.      //start_game();
  40. }
  41.  
  42. void start_game(void)
  43. {
  44. /*     int x, y;
  45.      char **matrix;
  46.  
  47.      get_console_size(&x, &y);
  48.      build_matrix(x, y);
  49.  
  50.      fill_matrix(matrix, x, y, 'X');
  51.      print_matrix(matrix, x, y);*/
  52. }
  53.  
  54. char **build_matrix(int x, int y)
  55. {
  56.      int i;
  57.      char **matrix = (char **)malloc(y);
  58.  
  59.      if(matrix == NULL) return NULL;
  60.  
  61.      for(i = 0; i < y; i++)
  62.      {
  63.           matrix[i] = (char *)malloc(x);
  64.           //printf("matrix[%d] allocated\n", i);
  65.           if(matrix[i] == NULL) return NULL;
  66.      }
  67.  
  68.      return matrix;
  69. }
  70.  
  71. void fill_matrix(char **matrix, int x, int y, char c)
  72. {
  73.      int i;
  74.  
  75.      for(i = 0; i < y; i++)
  76.      {
  77.           // riesce a scrivere solo le prime 10 righe, non oltre, perchè?
  78.           memset(matrix[i], c, x);
  79.           //puts(matrix[i]);
  80.           // riesce a leggere tutti le 25 righe, non oltre
  81.           printf("\rmatrix[%d] filled\n", i);
  82.      }
  83. }
  84.  
  85. void print_matrix(char **matrix, int x, int y)
  86. {
  87.      int i;
  88.  
  89.      for(i = 0; i < y; i++)
  90.      {
  91.           puts(matrix[i]);
  92.      }
  93. }
  94.  
  95. void get_matrix_size(char **matrix, int *x, int *y)
  96. {
  97.      *y = strrchr(matrix[0], 0) - matrix[0];
  98. }
  99.  
  100. void get_console_size(int *x, int *y)
  101. {
  102.      CONSOLE_SCREEN_BUFFER_INFO c_info;
  103.      HANDLE h_stdout;
  104.  
  105.      h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
  106.      GetConsoleScreenBufferInfo(h_stdout, &c_info);
  107.  
  108.      *x = c_info.srWindow.Right + 1;
  109.      *y = c_info.srWindow.Bottom + 1;
  110. }
  111.  
  112. // creare un fast_clear() che pulisce velocemente, gli si passa la dimensione della console
  113. void clear(void)
  114. {
  115.      CONSOLE_SCREEN_BUFFER_INFO c_info;
  116.      HANDLE h_stdout;
  117.      char *text;
  118.  
  119.      h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
  120.      GetConsoleScreenBufferInfo(h_stdout, &c_info);
  121.  
  122.      // printf("Screen size: %dx%d\n", c_info.dwSize.X, c_info.dwSize.Y);
  123.      // printf("Screen size MAX: %dx%d\n", c_info.dwMaximumWindowSize.X, c_info.dwMaximumWindowSize.Y);
  124.      // printf("Cursor position: %d, %d\n", c_info.dwCursorPosition.X, c_info.dwCursorPosition.Y);
  125.      // printf("Boh: left: %d, right: %d, top: %d, bottom: %d\n", c_info.srWindow.Left, c_info.srWindow.Right, c_info.srWindow.Top, c_info.srWindow.Bottom);
  126.  
  127.      // getchar();
  128.  
  129.      // posiziono il cursore sull'angolo nord ovest della console
  130.      gotoXY(0, 0);
  131.      // alloco uno spazio equivalente al prodotto di righe e colonne della console
  132.      text = (char *)malloc((c_info.srWindow.Right + 1) * (c_info.srWindow.Bottom + 1));
  133.      // riempio la stringa ottenuta con spazi bianchi
  134.      memset(text, ' ', (c_info.srWindow.Right + 1) * (c_info.srWindow.Bottom + 1));
  135.      // pulisco lo schermo inserendo spazi bianchi dappertutto
  136.      puts(text);
  137.      // libero la memoria precedentemente allocata
  138.      free(text);
  139.      // riposiziono il cursore sull'angolo nord ovest della console
  140.      gotoXY(0, 0);
  141. }
  142.  
  143. char *fast_clear_init(void)
  144. {
  145.      CONSOLE_SCREEN_BUFFER_INFO c_info;
  146.      HANDLE h_stdout;
  147.      char *text;
  148.  
  149.      h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
  150.      GetConsoleScreenBufferInfo(h_stdout, &c_info);
  151.  
  152.      text = (char *)malloc((c_info.srWindow.Right + 1) * (c_info.srWindow.Bottom + 1));
  153.      memset(text, ' ', (c_info.srWindow.Right + 1) * (c_info.srWindow.Bottom + 1));
  154.  
  155.      return text;
  156. }
  157.  
  158. void fast_clear(char *text)
  159. {
  160.      gotoXY(0, 0);
  161.      puts(text);
  162.      gotoXY(0, 0);
  163. }
  164.  
  165. void gotoXY(int x, int y)
  166. {
  167.      HANDLE h_stdout;
  168.      COORD coord;
  169.  
  170.      coord.X = x;
  171.      coord.Y = y;
  172.  
  173.      h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
  174.      SetConsoleCursorPosition(h_stdout, coord);
  175. }


PM Quote
Avatar
pierotofy (Admin)
Guru^2


Messaggi: 6116
Iscritto: 04/12/2003

Segnala al moderatore
Postato alle 23:10
Domenica, 28/09/2008
Testo quotato


ho controllato la funzione build_matrix(), funziona correttamente, anche perchè tutte e 25 le righe della matrice possono essere lette (anche se contengono caratteri strani dato che non sono state settate)



Non ho avuto il tempo di guardare e provare tutto il codice, ma non puoi affermare che la funzione build_matrix() funziona solo perchè puoi leggere oltre i limiti dell'array. Ricordati che questo non è C# o Java, se tu dici al C di andare a leggere uno spazio di memoria che non hai correttamente inizializzato o allocato il C lo fa senza farsi troppi problemi. Quei "caratteri strani" possono essere dati di altri programmi caricati in memoria o chissà di cos'altro. Io concentrerei i miei sforzi cercando di capire cos'è il problema lì.


Seguimi su Twitter: http://www.twitter.com/pierotofy

Fai quello che ti piace, e fallo bene.
PM Quote
Avatar
norbix (Ex-Member)
Newbie


Messaggi: 15
Iscritto: 14/09/2008

Segnala al moderatore
Postato alle 15:23
Lunedì, 29/09/2008
devo contraddirti, ho provato a leggere oltre il 25esimo elemento della matrice, ma da errore, avevo comunque inserito un controllo sul puntatore di ogni elemento della matrice al momento dell'allocazione, nessun errore, quindi.. la matrice viene allocata correttamente, almeno da quanto ho visto

PM Quote