How to make the function return an array

This is a very elementary problem, but it may be a headache for beginners who do not know it. In C ++, the function cannot directly return an array, but the array is actually a pointer, so the function can return a pointer. For example, a matrix multiplication function can be easily written as follows:
1 # include <iostream>
2
3 using namespace std;
4
5 float * MultMatrix (float A [4], float B [4])
6 {
7 float M [4];
8 M [0] = A [0] * B [0] + A [1] * B [2];
9 M [1] = A [0] * B [1] + A [1] * B [3];
10 M [2] = A [2] * B [0] + A [3] * B [2];
11 M [3] = A [2] * B [1] + A [3] * B [3];
12
13 return M;
14}
15
16 int main ()
17 {
18 float A [4] = {1.75, 0.66, 0, 1.75 };
19 float B [4] = {1, 1, 0, 0 };
20 float * M = MultMatrix (A, B );
21 cout <M [0] <"" <M [1] <endl;
22 cout <M [2] <"" <M [3] <endl;
23
24 return 0;
25}
However, the result after running is 1.75 1.75.
6.51468e-039 3.76489e-039
It is not the expected result. So we added the code to the function to see if it was a computing problem. The result is as follows:
1.75 1.75
0 0
1.75 1.75
1.96875 1.75
It is found that the calculation result is correct, but the returned result is changed, and the result is different from the previous one. Why?
Because the array M defined in the function has been released by the system after the function is executed, the result obtained by calling the function is of course not the calculated result. One solution is to dynamically allocate memory and add an array in the function so that it will not be released.
So we should
7 float M [4];
Changed:
7 float * M = new float [4];
After the modification is run, the result is displayed:
1.75 1.75
0 0
1.75 1.75
0 0
Correct. However, we didn't release the space we applied for in this way. If we release the space in the function, the result will be the same as that at the beginning.
Let's look at our call code:
20 float * M = MultMatrix (A, B );
In this way, the M pointer is actually directed to the first address of the M array in the function. We can release the M pointer, and the effect is the same as the M array applied for release, because they point to the same piece of memory space. Then the code is changed:
1 # include <iostream>
2
3 using namespace std;
4
5 float * MultMatrix (float A [4], float B [4])
6 {
7 float * M = new float [4];
8 M [0] = A [0] * B [0] + A [1] * B [2];
9 M [1] = A [0] * B [1] + A [1] * B [3];
10 M [2] = A [2] * B [0] + A [3] * B [2];
11 M [3] = A [2] * B [1] + A [3] * B [3];
12 cout <M [0] <"" <M [1] <endl;
13 cout <M [2] <"" <M [3] <endl;
14
15 return M;
16}
17
18 int main ()
19 {
20 float A [4] = {1.75, 0.66, 0, 1.75 };
21 float B [4] = {1, 1, 0, 0 };
22 float * M = MultMatrix (A, B );
23 cout <M [0] <"" <M [1] <endl;
24 cout <M [2] <"" <M [3] <endl;
25 delete [] M;
26
27 return 0;
28}
Running result:
1.75 1.75
0 0
1.75 1.75
0 0
No problem. The new space is deleted.
In view of the suggestions of the following experts, I will modify the program as follows:
1 # include <iostream>
2
3 using namespace std;
4
5 void MultMatrix (float M [4], float A [4], float B [4])
6 {
7 M [0] = A [0] * B [0] + A [1] * B [2];
8 M [1] = A [0] * B [1] + A [1] * B [3];
9 M [2] = A [2] * B [0] + A [3] * B [2];
10 M [3] = A [2] * B [1] + A [3] * B [3];
11
12 cout <M [0] <"" <M [1] <endl;
13 cout <M [2] <"" <M [3] <endl;
14}
15
16 int main ()
17 {
18 float A [4] = {1.75, 0.66, 0, 1.75 };
19 float B [4] = {1, 1, 0, 0 };
20
21 float * M = new float [4];
22 MultMatrix (M, A, B );
23
24 cout <M [0] <"" <M [1] <endl;
25 cout <M [2] <"" <M [3] <endl;
26 delete [] M;
27
28 return 0;
29}
As for Array and smart intelligence, I still need to continue learning. Thank you for your attention!

Author: Yang XI"