1. inline void mallocSudoku(Sudoku& s)  
   1. {  
   2.     if (s == nullptr)  
   3.     {  
   4.         s = new int* [10];  
   5.         for (int i = 0; i < 10; i++)  
   6.         {  
   7.             s[i] = new int[10];  
   8.         }  
   9. 10.     }  

11. }  

1. 12.   

13. inline void freeSudoku(Sudoku& s)  

14. {  

1. 15.     if (s != nullptr)  
2. 16.     {  
3. 17.         for (int i = 0; i < 10; i++)  
4. 18.         {  
5. 19.             delete[] s[i];  
6. 20.         }  
7. 21.         delete[] s;  
8. 22.         s = nullptr;  
9. 23.     }  

24. }  

1. 25.   

26. inline void readLineFromFile(char* line)  

27. {  

1. 28.     char* tmp = new char;  
2. 29.     DWORD num_bytes_read = 0;  
3. 30.     for (int i = 0; i < 9; i++)//依据约定，一行最多有9个数字  
4. 31.     {  
5. 32.         *tmp = 0;  
6. 33.         while (*tmp < ‘0‘ || *tmp > ‘9‘)  
7. 34.         {  
8. 35.             if (ReadFile(h_sudoku_problem_txt, tmp, 1, &num_bytes_read, NULL) && num_bytes_read == 0)  
9. 36.             {  
10. 37.                 is_end = true;  
11. 38.                 return;  
12. 39.             }  
13. 40.             //num_bytes_read++;  
14. 41.         }  
15. 42.         line[i] = *tmp;  
16. 43.     }  
17. 44.     delete tmp;  

45. }  

1. 46.   

47. inline bool getSudokuFromFile(Sudoku s)  

48. {  

1. 49.     char* line = new char[9];  
2. 50.     for (int i = 0; i < 9; i++)  
3. 51.     {  
4. 52.         readLineFromFile(line);  
5. 53.         if (is_end)  
6. 54.             return false;  
7. 55.         for (int j = 0; j < 9; j++)  
8. 56.             s[i + 1][j + 1] = line[j] - ‘0‘;  
9. 57.     }  
10. 58.   
11. 59.     delete[] line;  
12. 60.     return true;  

61. }  

1. 62.   

63. //一次性读入一千个数独  

64. inline void readSudoku()  

65. {  

1. 66.     for (int i = 0; i < BUFF_SIZE; i++)  
2. 67.     {  
3. 68.         Sudoku tmp = nullptr;  
4. 69.         mallocSudoku(tmp);  
5. 70.         if (getSudokuFromFile(tmp) == false)  
6. 71.         {  
7. 72.             freeSudoku(tmp);  
8. 73.             return;  
9. 74.         }  
10. 75.         buff.push_back(tmp);  
11. 76.     }  
12. 77.     return;  
13. }  

1. inline void toSudoku(char* tmp, DWORD& n_bytes_read)  
   1. {  
   2.     //由于读取时的限制，num_of_sudoku_in_buff <= BUFF_SIZE  
   3.     num_of_sudoku_in_buff = n_bytes_read / num_bytes_of_sudoku_infile;  
   4.     if (is_end)//因为结束时，向下取整，少了一个  
   5.     {  
   6.         num_of_sudoku_in_buff++;  
   7.     }  
   8.     for (int i = 0, j = 0; i < num_of_sudoku_in_buff; i++, j++)  
   9. 10.     {  
   10. 11.         Sudoku s = buff[i];  
   11. 12.         for (int row_idx = 1, col_idx = 1; j < (i + 1) * num_bytes_of_sudoku_infile - 1; j++, j++)  
   12. 13.         {  
   13. 14.             s[row_idx][col_idx++] = tmp[j] - ‘0‘;  
   14. 15.             if (col_idx == 10)  
   15. 16.             {  
   16. 17.                 row_idx++;  
   17. 18.                 col_idx = 1;  
   18. 19.             }  
   19. 20.         }  
   20. 21.     }  

22. }  

1. 23.   

24. //一次性读入一千个数独  

25. inline void readSudoku()  

26. {  

1. 27.     char* tmp = new char[num_bytes_of_sudoku_infile * BUFF_SIZE + 10];  
2. 28.     ReadFile(h_sudoku_problem_txt, tmp, num_bytes_of_sudoku_infile * BUFF_SIZE, &n_bytes_read, NULL);  
3. 29.     if (num_bytes_of_sudoku_infile * BUFF_SIZE > n_bytes_read)  
4. 30.         is_end = true;  
5. 31.     toSudoku(tmp, n_bytes_read);  
6. 32.     return;  
7. }  

1. void swapRow(int n, int m)  
   1. {  
   2.     //for (int i = 0; i < 10; i++)  
   3.     //{  
   4.     //  //std::swap(sudoku[n][i], sudoku[m][i]);  
   5.     //}  
   6.     std::swap(sudoku[n], sudoku[m]);  
   7. }  

 不难发现性能有了显而易见的提升。