Thread: questions about arrays

I've been playing around a bit with arrays and a few question have arisen that I hope someone on here can help answer.

1. Sizeof

Code:

void foo( int array[] )
{
    cout << sizeof(array) << endl;
    cout << sizeof(array[0]) << endl;
}

int main()
{
    int b[4] = {1,2,3,4};

    cout << sizeof(b) << endl;
    cout << sizeof(b[0]) << endl;
    cout<<"---------" << endl;
    foo(b);
}

The above outputs
16
4
-----
4
4
Im just curious why they the output from main is different from the foo() method ?

2. The below code both store the values 1,2,3,4 just the same way in memory.

Code:

int a[2][2] = {{1,2}, {3,4}};
int b[4] = {1,2,3,4};

if I do

Code:

int* ptr = b;
    
for(int x=0; x < 4; x++)
    cout << *ptr++ << endl;

that works great, however if I do

Code:

int* ptr = a;
    
for(int x=0; x < 4; x++)
    cout << *ptr++ << endl;

I get an 'cannot conver int' error on the first line. I though both a and b array where const pointers to the first element of each array and then there shouldnt be an problem copying the address into a pointer and using the pointer to access the values, but this doesnt seem to work so I guess it's not that simple. Would appreciate if anyone could shed some light on this.

3. If I have the following main code..

Code:

int main()
{
    int a[2][2] = {{1,2},{3,4}};

    foo(a);
}

is this the only way foo would work

Code:

void foo( int array[][2] )
{
  // code..
}

4. When a compiler processes the below code

Code:

int a[2][2] = {{1,2}, {3,4}};
int b[4] = {1,2,3,4};

does it store any additonal data for the 2d array ? Like i.e. row length. Atleast in memory they seem to store the data the same in the same order. Im just wondering how they are different.

I'm interested in the difference between i.e. 1d array and a 2d array. So if anyone knows any good tutorials or articles please add the link.

Thanks for any help.

1
Here I´m not 100% sure but maybe someone else can confirm this. When sizeof() is used on an array the size of the whole array is returned (I think they implemented it this way so there is a chance to know how big the array is), and not the size of a pointer like in foo (the int array[] parameter is converted to a pointer).

2

Code:

int* ptr = a;

change it to

Code:

int (*ptr)[2] = a;

More info about the subject here (they do a better job than me).

3
And the other way is the "exact " parameter

Code:

void foo( int array[2][2] )
{
  // code..
}

This is possible because this is possible

Code:

int array1[] = {12, 45, 90};
int array2[3] = {12, 45, 90};

4
This one i´m not sure about but I have 2 theories

• Pointer to pointer arrays
• Simulating nD arrays as 1D array

http://pw2.netcom.com/~tjensen/ptr/pointers.htm

2)

int a[2][3];
int* ptr = a;

The leftmost dimension is not part of the type of an array. So, a's type is int[3]. A pointer to that array must be declared with that type, and this is the syntax:

int (*a_pointer)[3];

The parentheses are necessary, otherwise you would have this:

int* a_pointer [3];

and that creates an array of 3 int pointers, not one pointer to type int[3].


4) Maybe this will help demonstrate some additional traits of pointers to arrays:

Code:

#include<iostream>
using namespace std;

int main()
{
	int a[2][3] = {{1,2,3}, {4,5,6}};
	int b[6] = {1,2,3,4,5,6};

	cout<<**(a+1)<<endl;//jumps to the next row
	cout<<*(b+1)<<endl;//jumps to the next element

	//dynamically creating a 2d array:
	int** parray = new int*[2];
	parray[0]=new int[3];
	parray[1]=new int[3];

	//assigning values to the array:
	*(parray[0] + 0) = 1;
	*(parray[0] + 1) = 2;
	*(parray[0] + 2) = 3;
	
	//display an element using array notation:
	cout<<parray[0][2]<<endl;

	delete [] parray[0];
	delete [] parray[1];
	delete [] parray;

	return 0;
}