单指针和双指针数组之间的区别

Question

Code below prints addresses of dynamically allocated array. Printed addresses become slightly different, when new line starts. If I use static array, addresses are exactly the same, and array elements are going one after another. What's the reason?

void func(int* a, int** b)
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            cout << &a[i * n + j]<< " " << &b[i][j]<< endl;
        }
        cout << endl;
    }
}

int main()
{
    int** a;
    a = new int*[n];
    for (int i = 0; i < n; i++)
    {
        a[i] = new int[n];
    }
    func(a[0], a);

Answer 1

It's how you created your matrix. There is no reason to assume that a[0] + 1 * n + j equals a[1] + j . a[0] and a[1] were independently allocated.

Here is a way to get the entire matrix at once.

int** a = new int*[n]; // allocate the row indexes
a[0] = new int[n * n]; // allocate the entire matrix
for (int i = 1; i < n; i++)
{
    a[i] = a[0] + i * n; // assign the row indexes. NOTE: a[0] is already assigned.
}

Using this allocation, a[0] + 1 * n + j equals a[1] + j .

---

Static arrays allocate the entire matrix allocation implicitly, which is why your code works for them.

Answer 2

Difference between single-pointer and double-pointer arrays

You can see the difference in the code:

int** a;         // a is a pointer of type int**
a = new int*[n]; // a points to an array of pointers of type int*

And:

for (int i = 0; i < n; i++)
{
    a[i] = new int[n]; // a[i] points to an array of ints

There you have it.

Printed addresses become slightly different, when new line starts. If I use static array, addresses are exactly the same, and array elements are going one after another.

Presumably, you're talking about a static array of arrays and compare it to the array of pointers that you have.

Elements of an array are allocated continuously in memory. In the case of array of static arrays, the elements of the outer array are static arrays and they are stored continuously in memory. In the case of array of pointers, the elements of the outer array are the pointers and they are also stored continuously in memory. The arrays of int that you allocate dynamically on the other hand are not stored in the outer array. Where they're stored is implementation defined and typically not related to the location of the array which holds the pointers.

Also:

cout << &a[i * n + j]<< " " << &b[i][j]<< endl;

Here you're accessing beyond the borders of the array pointed by the argument a which is pointed by a[0] in main and has a length of n which is less than i * n + j when i is non-zero. The result is technically undefined behaviour and the printed addresses are most definitely not of the elements of arrays that you've allocated.

Answer 3

Code below prints addresses of dynamically allocated array. 
Printed addresses become slightly different, when new line starts. If
I use static array, addresses are exactly the same, and array elements
are going one after another. What's the reason?

The reason being that The following call will generate a new address every-time it is called and there is no guarantee of that address being contiguous. a[i] = new int[n];

While,

int a[10][20]

which is a static array will have contiguous memory allocation.

Answer 4

You're using two conflicting implementations in your modeling of a matrix: in main , you use arrays of arrays, with each row in separate memory; and in func , you assume a single flat array of rows * columns elements, mapping the two indices to one. You have to choose one or the other.

In C++, of course, you'd write a Matrix class, to encapsulate this choice. For example, if you wanted the single flat array (usually preferable), you'd write something like:

class Matrix
{
    int myRowCount;
    int myColumnCount;
    std::vector<int> myData;
public:
    Matrix( int rows, int columns )
        : myRowCount( rows )
        , myColumnCount( columns )
        , myData( rows * columns )
    {
    }

    int& operator()( int row, int column )
    {
        assert( row >= 0 && row < myRowCount
                && column >= 0 && column < myColumnCount );
        return myData[row * myColumnCount + column];
    }

    int const& operator()( int row, int column ) const
    {
        assert( row >= 0 && row < myRowCount
                && column >= 0 && column < myColumnCount );
        return myData[row * myColumnCount + column];
    }
};

You'll note that I used std::vector rather than doing any dynamic allocation myself. In this case, the difference isn't enormous, but in practice, no experienced C++ programmer would use an array new except in very exceptional cases; one sometimes wonders why it is even in the language.

You'll also note that I have overloaded the () operator for indexing. You cannot provide two indices for [] , and this is one of the solutions to that problem. Alternatively, operator[] would take a single index, and return a proxy object which would also take a single index. While this is the solution I prefer, it is more complicated.