The two-dimensional array is broken!

We are constantly faced with the problem of two-dimensional arrays, and we are always afraid of them. The pointers are really annoying, and the memory is even more annoying.

Summary today: for future reference.
Write only the most commonly used
1: allocate int A [m] [N] on the stack.
Disadvantage, m, n must be known
Function parameter call
Fun (int A [] [N], int dims_ I, int dims_j)
{
A [I] [J] = 0;
}

2: Dynamic Allocation-use STL
Highly recommended !!! Although this method may cause memory disconnections, it is more intuitive to call than the code, and you do not need to manage the memory yourself. The disadvantages are negligible !!!

1. Int M = 3;
2. Int n = 3;
3. Vector <vector <int> myvec (M, vector <int> (n ));
4. For (INT I = 0; I <m; ++ I)
5. {
6. For (Int J = 0; j <n; ++ J)
7. {
8. Myvec [I] [J] = I * J;
9. }
10. }

1. Vector <vector <int>;
3. A. Resize (m); // m rows
4. For (INT I = 1; I <n; I ++ )//
5. {
6. Ga [I]. Resize (n); // n Column
7. }

3: dynamically allocate and manage the memory by yourself
In essence, to dynamically implement a two-dimensional array, you need to apply for more memory points, that is, to store the memory of one-dimensional array pointers.
The following method puts "memory for storing one-dimensional array Pointers" indexsize and memory H * rowsize for storing data together. This is really clever,
When the memory is released, delete the statement.

1. Void ** malloc2d (int w, int H, int size)
2. {
3. Int J;
4. Int rowsize = W * size;
5. Int indexsize = H * sizeof (void *);
6. Void ** A = (void **) malloc (indexsize + H * rowsize );
7. Char * datastart = (char *) A + indexsize;
8. For (j = 0; j
9. A [J] = datastart + J * rowsize;
10. Return;
11. }

The W and H parameters are the columns and rows of the applied two-dimensional array, and the size is the number of bytes of the array unit. For example, to apply for a 4*5 Int-type two-dimensional array, use:
Int ** M = (INT **) malloc2d (5, 5, sizeof (INT ));
Directly use M [x] [Y] to reference the value of column Y in row X.
Use free (m) directly when returning.

Reference: http://blog.csdn.net/hanbf/archive/2007/08/31/1767645.aspx

 

//////////////////////////////////////// ////////////////////
The following is common in programming. After the two-dimensional array address is passed through the function pointer,
How to access array elements in a function is discussed here.
1) if the raw data is essentially one-dimensional, the occupied space only contains the size of the raw data and does not include the storage space for row pointers.
Then, eg int A [2] [2]; // memory allocated on the stack. sizeof (A) = 2*2 * sizeof (INT)
You can only access array elements in one dimension.

1. Void test3 (INT ** A, int dim_ I, int dim_j)
2. {// Int ** A is passed here, which is meaningless and must be converted to int *
3. // Note that here, A is just a pure pointer, and the length of the dimension maintained by the compiler is lost. Therefore,
4. // It can only be used as a one-dimensional array
7. Int * P = (int *) A; // you can honestly access data by using a one-dimensional array.
8. For (INT I = 0; I <dim_ I; ++ I)
9. {
10. For (Int J = 0; j <dim_j; ++ J)
11. {
12. * (P + I * dim_j + J) = I * J;
13. }
14. }
16. Return;
17. }

2: If the applied memory contains not only space occupied by data, but also space occupied by row pointers, you can access it through.

See test4 in the following function.

 

1. Void Test2 (int A [] [2], int dim_ I, int dim_j)
2. {
3. A [1] [1] = 1;
4. Return;
5. }
7. //: Applicable to two-dimensional arrays without row pointers.
8. //: A two-dimensional array classified by EG 1 on the stack, or an int A [2] [2] without a row pointer
9. //: Eg 2 int ** Pa = (INT **) malloc (sizeof (INT) * 2*2). Two rows and two columns
10. Void test3 (INT ** A, int dim_ I, int dim_j)
11. {
12. // Note that here, A is just a pure pointer, and the length of the dimension maintained by the compiler is lost. Therefore,
13. // It can only be used as a one-dimensional array
15. Int * P = (int *) A; // you can honestly access data by using a one-dimensional array.
16. For (INT I = 0; I <dim_ I; ++ I)
17. {
18. For (Int J = 0; j <dim_j; ++ J)
19. {
20. * (P + I * dim_j + J) = I * J;
21. }
22. }
24. Return;
25. }
27. //: Applicable to two-dimensional arrays containing row pointer data
28. //: EG malloc2d
29. Void test4 (INT ** A, int dim_ I, int dim_j)
30. {
31. For (INT I = 0; I <dim_ I; ++ I)
32. {
33. For (Int J = 0; j <dim_j; ++ J)
34. {
35. A [I] [J] = (I + 1) * (J + 1 );
36. }
37. }
39. Return;
40. }
42. Void ** malloc2d (int w, int H, int size)
43. {
44. Int J;
45. Int rowsize = W * size;
46. Int indexsize = H * sizeof (void *);
47. Void ** A = (void **) malloc (indexsize + H * rowsize );
48. Char * datastart = (char *) A + indexsize;
49. For (j = 0; j
50. A [J] = datastart + J * rowsize;
51. Return;
52. }
54. Int main ()
55. {
56. // Method 1
57. Int ** pa2 = (INT **) malloc2d (2, 2, sizeof (INT ));
58. Test4 (pa2, 2, 2 );
59. Cout <"pa2 [1] [1]" <pa2 [1] [1] <Endl;
61. // Method 2
62. Int A [2] [2] = {0, 0}, {0, 0 }};
63. Test3 (INT **) A, 2, 2 );
65. // Method 3
66. Int M = 3;
67. Int n = 3;
68. Vector <vector <int> myvec (M, vector <int> (n ));
69. For (INT I = 0; I <m; ++ I)
70. {
71. For (Int J = 0; j <n; ++ J)
72. {
73. Myvec [I] [J] = I * J;
74. }
75. }
76. }

There are also many other methods, which are not listed here:
For other methods, refer to the following address:
Http://blog.csdn.net/smilelance/archive/2006/10/09/1327326.aspx

Transferred from shuimu Tsinghua
1.
A (* GA) [N] = new A [m] [N];
...
Delete [] GA;
Disadvantage: N must be known
Advantages: intuitive calling, continuous storage, and simple program (tested, the Destructor can be correctly called)

2. A ** GA = new A * [m];
For (INT I = 0; I <m; I ++)
Ga [I] = new A [n];
...
For (INT I = 0; I <m; I ++)
Delete [] Ga [I];
Delete [] GA;
Disadvantages: non-continuous storage, cumbersome procedures, GA is a ** type
Advantage: The call is intuitive. N can be unknown.

3. A * GA = new A [M * n];
...
Delete [] GA;
Disadvantage: The call is not intuitive enough.
Advantage: continuous storage, N can be unknown

4. Vector <vector <A> ga;
Ga. Resize (m); // these three rows can be used
For (INT I = 1; I <n; I ++ )//
Ga [I]. Resize (n );//
...

Disadvantages: non-continuous storage, inconvenient debugging, lower Compilation speed, and program expansion (the actual speed is not much different)
Advantage: intuitive call, automatic analysis and memory release, can call STL related functions, dynamic growth

5. Vector <A> ga;
Ga. Resize (M * n );
Combination of method 3 and 4

Release (provided by Penrose, thank you)
A ** GA = new A * [m];
Ga [0] = new A [M * n];
For (INT I = 1; I <m; I ++)
Ga [I] = Ga [I-1] + N;
...
Delete [] Ga [0];
Delete [] GA;
Disadvantage: The program is cumbersome. GA is of the ** type.
Advantage: continuous storage and intuitive calling. N can be unknown.