semantic difference between [][] and **

[Paul]

Say I have:
char foo[][];
char** bar;

In my understanding, these two have the same meaning in memory.
Could someone elucidate upon these two types and their meanings?

Thanks,
Paul

[Victor Bazarov]

Paul wrote:

Say I have:
char foo[][];
char** bar;

In my understanding, these two have the same meaning in memory.
What is "meaning in memory"?
Could someone elucidate upon these two types and their meanings?

The former, IIUIC, is an error, since to declare a multidimensiona l array
you have to specify all sizes but the inner-most one.

V

[marikallees]

char foo[][]; is an invalid declaration. Only the first dimension size
can be omitted, and even then you're expected either to be using a
declaration without the definition, or initializing the array such that
the size can be calculated from the initializer.

these two have the same meaning in memory.

Not necessarily. Perhaps if you post some more code, and mention what
system and implementation you're using, a more thorough answer can be
given.

-Ren

[Ren]

char foo[][]; is an invalid declaration. Only the first dimension size
can be omitted, and even then you're expected either to be using a
declaration without the definition, or initializing the array such that
the size can be calculated from the initializer.

these two have the same meaning in memory.

Not necessarily. Perhaps if you post some more code, and mention what
system and implementation you're using, a more thorough answer can be
given.

-Ren

[Default User]

Victor Bazarov wrote:

Paul wrote:

Say I have:
char foo[][];
char** bar;

In my understanding, these two have the same meaning in memory.

What is "meaning in memory"?

Could someone elucidate upon these two types and their meanings?

The former, IIUIC, is an error, since to declare a multidimensiona l
array you have to specify all sizes but the inner-most one.

They way they are written, those are variable declarations, not
function parameters, so the first case would have to be initialized as
well.

char foo[][6] = {"one", "two", "three"};

Then the compiler can count the initializers and compute the missing
dimension.

Now, if used in a function declaration, then you can have:

void bar (char foo[][6]);

It's definitely not equivalent to:

void bar (char **foo);


Brian

[Paul]

ma*********@acm .org wrote:

char foo[][]; is an invalid declaration. Only the first dimension size
can be omitted, and even then you're expected either to be using a
declaration without the definition, or initializing the array such that
the size can be calculated from the initializer.

these two have the same meaning in memory.

Not necessarily. Perhaps if you post some more code, and mention what
system and implementation you're using, a more thorough answer can be
given.

-Ren

Let's say:

char foo[16][16];
char **bar;

bar = new char*[16];
for(int i = 0; i < 16; i++)
{
bar[i] = new char[16];
}
It is my understanding that foo and bar can be accessed and passed
around in similiar manner and maintain the same meaning.
I also think they can be cast from one to the next without error.

I have a suspicion I'm wrong, however. :-)

-Paul

[Victor Bazarov]

Paul wrote:

ma*********@acm .org wrote:

char foo[][]; is an invalid declaration. Only the first dimension size
can be omitted, and even then you're expected either to be using a
declaration without the definition, or initializing the array such that
the size can be calculated from the initializer.

these two have the same meaning in memory.

Not necessarily. Perhaps if you post some more code, and mention what
system and implementation you're using, a more thorough answer can be
given.

-Ren

Let's say:

char foo[16][16];
char **bar;

bar = new char*[16];
for(int i = 0; i < 16; i++)
{
bar[i] = new char[16];
}
It is my understanding that foo and bar can be accessed and passed
around in similiar manner and maintain the same meaning.

Similar, maybe. Same meaning, no. Same purpose, perhaps.
I also think they can be cast from one to the next without error.
That's incorrect.
I have a suspicion I'm wrong, however. :-)

Yes, unfortunately, you are. 'foo' is an array of arrays, while 'bar'
is [a pointer to] an array of pointers. They have different types and
therefore behave differently in certain situations. Also, the derived
objects, *bar and *foo have different types, although now they are more
compatible than before, you may convert decltype(*foo) to decltype(*bar).
[Note: I use 'decltype' to convey the meaning, there is no such construct
in C++ yet].

The important difference (and that's where casting comes into play) is
that the memory layouts of what is designated by 'foo' and by 'bar' are
vastly different.

V

[Default User]

Paul wrote:

ma*********@acm .org wrote:

char foo[][]; is an invalid declaration. Only the first dimension
size can be omitted, and even then you're expected either to be
using a declaration without the definition, or initializing the
array such that the size can be calculated from the initializer.

these two have the same meaning in memory.
Not necessarily. Perhaps if you post some more code, and mention
what system and implementation you're using, a more thorough answer
can be given.

-Ren

Let's say:

char foo[16][16];
char **bar;

bar = new char*[16];
for(int i = 0; i < 16; i++)
{
bar[i] = new char[16];
}
It is my understanding that foo and bar can be accessed and passed
around in similiar manner and maintain the same meaning.

Accessed, pretty much yes. Passed? Absolutely not.

http://www.eskimo.com/~scs/C-faq/q6.18.html
I also
think they can be cast from one to the next without error.

You can cast the array to the pointer and it won't cause an error
(because you did a cast). Doesn't mean it will work. The two constructs
will have different layouts in memory, and the pointer strides are
different. The name of array is converted to type pointer to array 16
of char.

Just disabuse yourself of this notion. Read ALL the FAQs on arrays and
pointers in the C FAQ (it's more useful for these questions).

Brian