For practice, I want to define a Matrix addition of two 2-D Matrces by pulling the pointers of them. Here is the initiation
const double A[2][2]={{1,2},{3,4}};
double B[2][2]={{4,3},{2,1}};
const double* a=*A;
double* b=*B;
However, since the pointer merely points to the first element of the first array within each matrix, a=*(A+0), how can i go through every element of each Matrix? And I only wnat to use pointer as parameter here.
void D2Add(const double*, double*){
...for loop here...
}
I only wnat to use pointer as parameter here
That way you will have undefined behavior. The different sub arrays may be placed in different pages/segments in memory and Accessing an array out of bounds is not guaranteed to work. I removed the sentence trying to explain a possible pitfall when accessing a sub array out of bounds because I can't find a good description of it right now.
One way to avoid undefined behavior is to take the arrays by reference instead:
#include <cstddef>
#include <iostream>
template<std::size_t Y, std::size_t X>
void D2Add(const double(&A)[Y][X], double(&B)[Y][X]) {
for(std::size_t y = 0; y < Y; ++y) {
for(std::size_t x = 0; x < X; ++x) {
B[y][x] += A[y][x];
}
}
}
int main() {
const double A[2][2]={{1,2},{3,4}};
double B[2][2]={{4,3},{2,1}};
D2Add(A, B);
for(auto& inner : B) {
for(auto value : inner) std::cout << value << ' ';
std::cout << '\n';
}
}
Output:
5 5
5 5
This is a very interesting question actually.
Formally, you're indeed only allowed to access the elements of the first sub-array, and trying to access the other one would cause undefined behavior.
But practically, there's a good chance that you might be able to loop from 0 to 4, treating the arrays as 1D arrays of size 4. But I would advise against doing this if possible.
I Hope you have good understanding of how Multi-Dimensional array is laid in memory.
problem- It is not possible by just pointers until your function has a way to know dimensions of array.
As specified, we need to pass dimensions to functions as well. Since you only want to go through every element, I'll be print each element for demonstration.
void D2Add(const double* ptr, int nRow, int nCol) {
for (int i=0; i<nRow; i++) {
for (int j=0; j<nCol; j++) {
std::cout << *(ptr+(i*nCol)+j) << std::endl;
}
}
}
*(ptr+(i*nRow)+j) will still access the first sub array out of bounds.