Thread: 2D-array pointer

Hello guys,

I'm now studying the pointers. There's a code I found in a book that worked on Netbeans ( using GCC compiler ) and didn't work on Microsoft VS 2010 express.

Code:

Code:

#include <stdio.h>

int main(void)
{
	int s[5][2] = {
		{ 1234, 56 },
		{ 1212, 33 },
		{ 1434, 80 },
		{ 1312, 78 }
	} ;
	int ( *p )[2] ;
	int i, j, *pint ;
	for ( i = 0 ; i <= 3 ; i++ )
	{
		p = &s[i] ;
		pint = p ;
		printf ( "\n" ) ;
		for ( j = 0 ; j <= 1 ; j++ )
			printf ( "%d ", *( pint + j ) ) ;
	}
	return 0;
}

Why?

The error message ( MS VS ):

Code:

1>some_destination\main.cpp(16): error C2440: '=' : cannot convert from 'int (*)[2]' to 'int *'

Thanks in advance.

C++ or C? C will let you convert pointers around, C++ will not.

Originally Posted by CommonTater

Code:

int ( *p )[2] ;

Should be

Code:

int *p[2];

These aren't the same thing, and the rest of the code assumes the first form, not the second.

Originally Posted by tabstop

These aren't the same thing, and the rest of the code assumes the first form, not the second.

Ok, not having seen the first form before, except as pointer-to-function... what's the difference?

Code:

int ( *p )[2] ;

means that p is a pointer to int[2] (i.e. two consecutive ints). Only one pointer's worth of memory is allocated. (That is, a pointer is declared, no array is created.)

Code:

int *p[2];

means that p is an array of two int*. Two pointers' worth of memory is allocated. (That is, an array is created.)

Originally Posted by tabstop

Code:

int ( *p )[2] ;

means that p is a pointer to int[2] (i.e. two consecutive ints). Only one pointer's worth of memory is allocated. (That is, a pointer is declared, no array is created.)

Code:

int *p[2];

means that p is an array of two int*. Two pointers' worth of memory is allocated. (That is, an array is created.)

so in the first one, no space is reserved except for the pointer and in the second the space is reversed. Did I get it right?

Originally Posted by tabstop

Code:

int ( *p )[2] ;

means that p is a pointer to int[2] (i.e. two consecutive ints). Only one pointer's worth of memory is allocated. (That is, a pointer is declared, no array is created.)

Code:

int *p[2];

means that p is an array of two int*. Two pointers' worth of memory is allocated. (That is, an array is created.)

How about that... you learn something new every day!

IIRC, some confusion can be avoided by instead of

Code:

int *p;

you get in the habit of writing:

Code:

int* p;

so that when you're presented with

Code:

int *p[2];

you realize it's really

Code:

int* p[2];

One must wrap the *p with parens to get something different

Code:

int ( *p )[2];

Have I got that right?

How about that... you learn something new every day!

Is that two days in a row?

Originally Posted by mike65535

Is that two days in a row?

Way more than that...

I was pretty confident in C when I came here... but have easily doubled my insight since.

Originally Posted by mike65535

IIRC, some confusion can be avoided by instead of

Code:

int *p;

you get in the habit of writing:

Code:

int* p;

so that when you're presented with

The latter (int* p) is often advocated against for one big reason. It gives the impression that the pointerness is part of the type of all variables on that line, when it only applies to the one variable. E.g.

Code:

int* p1, p2, p3;  // this seems to imply that p1, p2 and p3 are all pointers to ints, but really, only p1 is a pointer, p2 and p3 are regular ints
int *p1, p2, p3;  // this associates the pointerness with p1 instead of the whole line

Sure, it cuts both ways, as you have suggested, but most literature I've read prefers putting the * near the variable name instead of the type. I guess because a pointer to a single item is more common than a pointer to an array.

Originally Posted by anduril462

The latter (int* p) is often advocated against for one big reason. It gives the impression that the pointerness is part of the type of all variables on that line, when it only applies to the one variable.

At this point, someone is legally obligated to mention that if you put each variable declaration on its own line, then no problem.

(No I don't put one variable on each line either.)

Code:

int* p1, p2, p3;  // this seems to imply that p1, p2 and p3 are all pointers to ints, but really, only p1 is a pointer, p2 and p3 are regular ints

This is the kind of "trick" (or rather, gotcha) worthy as a "puzzler" or test question. Thanks!

I, too, avoid putting multiple declarations on a single line unless they are simple. No pointers, arrays, structs... I even avoid initialized variables on one line.