arrays of strings and pointers

[raphfrk]

I have the following code:

char buf[10][10000];

printf("%lp\n", buf);
printf("%lp\n", &buf[0]);
printf("%lp\n", buf[0]);
printf("%lp\n", buf[1]);
printf("%d\n", buf[1]-buf[0]);

The first 3 printfs give the same result and the last 2 show that
buf[1] is 10000 away from buf[0]. Is this the expected result?

I had assumed that the result would have been:

buf:

This should be a pointer to the first of a set of 10 pointers. These
pointers would be accessed by buf[0] ... buf[9]. They would point to
the 10 10000 char strings (which are a single block of memory).

&buf[0]

This should be the same as above. buf[0] is the same as *(buf+0), so
&buf[0] is &(*(buf+0)) which should be just buf.

buf[0]

This should point to the first string. It shouldn't be the same as
&buf[0].

buf[1]

This is as expected 10000 higher than buf[0].

I have a function that takes as its input an array of pointers:

void funct(char **base);

I had assumed that I could just pass buf to it, is it necessary to
create the 10 array of pointers manually ? However, it looks like buf
is of type pointer to a char rather than pointer to a pointer to a char.

[Mark McIntyre]

On 26 Oct 2005 09:10:23 -0700, in comp.lang.c , ra*****@netscap e.net
wrote:

buf[0]

This should point to the first string. It shouldn't be the same as
&buf[0].
It is. Think about it.
void funct(char **base);

I had assumed that I could just pass buf to it, is it necessary to
create the 10 array of pointers manually ?
No, this'll work. What are you /actually/ trying to do? Stop trying to
guess whats happening!
However, it looks like buf
is of type pointer to a char rather than pointer to a pointer to a char.

If its defined as above, its an array of arrays of chars.

Note that this isn't the same as either a pointer or a pointer to a
pointer.

--
Mark McIntyre
CLC FAQ <http://www.eskimo.com/~scs/C-faq/top.html>
CLC readme: <http://www.ungerhu.com/jxh/clc.welcome.txt >

----== Posted via Newsfeeds.Com - Unlimited-Uncensored-Secure Usenet News==----
http://www.newsfeeds.com The #1 Newsgroup Service in the World! 120,000+ Newsgroups
----= East and West-Coast Server Farms - Total Privacy via Encryption =----

[raphfrk]

Mark McIntyre wrote:

However, it looks like buf
is of type pointer to a char rather than pointer to a pointer to a char.

If its defined as above, its an array of arrays of chars.

Note that this isn't the same as either a pointer or a pointer to a
pointer.

Isn't an array and a pointer basically the same once memory has been
allocated etc. ? The difference being that you can't move where the
array base is and also that the array will have memory allocated
automatically. For example, these are basically equivalent (assuming
you ignore run-time and compile time memory allocation differences):

char buf[255];

strcpy(buf,"str ing");

printf("%c", buf[3]);

and

char *buf;

buf = malloc(sizeof(c har)*7);

strcpy(buf,"str ing");

printf("%c", buf[3]);

You can also use *buf in both cases and that will give you the first
character of the sting.

Anyway, perhaps this equivalence breaks down when you start dealing
with arrays of arrays.

So, I guess the question is, if I define buf as:

char buf[10][10000];

and want to pass it to a function, what should the function prototype
be ? I had assumed that a double array was effectively a pointer to a
pointer.

Also, I assume that it still passes by reference and doesn't copy the
entire array to the function's local variables.

[Mike Deskevich]

ra*****@netscap e.net wrote:

Anyway, perhaps this equivalence breaks down when you start dealing
with arrays of arrays.

So, I guess the question is, if I define buf as:

char buf[10][10000];

and want to pass it to a function, what should the function prototype
be ? I had assumed that a double array was effectively a pointer to a
pointer.

Also, I assume that it still passes by reference and doesn't copy the
entire array to the function's local variables.

yes, this is where you're confused. a multiply dimentioned array is
still just a pointer, not a pointer to a pointer.

char buf[10][10000] allocates the same memory as char buf[10*10000]
which is similar to buf=(char*)mall oc(10*10000*siz of(char));

the difference is that if you do char buf[10][10000] the compiler is
smart enough to know how to increment the memory addresses depending on
the two indices.

so you could have

char buf[10][10000];

printf("%c",buf[i][j])

which is equivalent to

char buf[10*10000]
printf("%c",buf[j*10+i]) //i think i got that right - gurus: please
check me on this

so passing a multiply dimensioned array to a function is a pain. here's
how you do it

char buf[10][10000]
dosomething(buf );

void dosomething(cha r buf[10][])
{
buf[i][j]
}

the compiler needs to know the size of all the dimensions except for
the last one. becasue internally the compiler is doing the j*10+i
step, it's just hiding it from you.

there are two ways around this:

1 - if you actually need to have the stuff in memory ordered as a
matrix (doing fast math stuff), then you can take care of the j*10+i
step yourself

char buf[10*10000];
dosomething(buf );

void dosomething(cha r* buf)
{
buf[j*10+i]; //same as buf[i][j]
}

2 - if you don't care about speed, then you can do what you were
thinking of with pointers to pointers

char** buf;

buf=(char**)mal loc(10*sizeof(c har*));
for (i=0;i<10;i++)
{
buf[i]=(char*)malloc( 10000*sizeof(ch ar));
}
dosomething(buf )
for (i=0;i<10;i++)
{
free(buf[i]);
}
free(buf);

void dosomething(cha r** buf)
{
buf[i][j]; //just as you expected
}

gurus: please feel free to correct any misstatements, i think i know
what i'm talking about, but when i read this newsgroup i realize how
much c i don't know.

mike

[Old Wolf]

ra*****@netscap e.net wrote:

I have the following code:

char buf[10][10000];
buf:

This should be a pointer to the first of a set of 10 pointers.
buf is an ARRAY. It is not a pointer, or a set of pointers, etc.
Arrays are not pointers. Arrays are a set of adjacent memory
locations for storing objects. Pointers store the address of
other objects. Pointer declarations are indicated by a '*'
symbol (except when it is a function formal parameter).

Please read this newsgroup FAQ, it has a section on arrays
and pointers.
These pointers would be accessed by buf[0] ... buf[9].
That would be:

char *buf[10];

Note the '*' which indicates that we have pointers.
They would point to the 10 10000 char strings (which are a
single block of memory).
That would be:

char *buf[10];
char bufmem[10][10000];
for (int i = 0; i != 10; ++i)
buf[i] = bufmem[i];
buf[0]

This should point to the first string. It shouldn't be the same as
&buf[0].
buf[0] is an array of 10000 chars. The first element of an array
always starts at the same memory location as the entire array.
So that is why you are seeing the same value displayed.
I have a function that takes as its input an array of pointers:

void funct(char **base);

I had assumed that I could just pass buf to it
Buf is not an array of pointers. So you cannot do this.
However, it looks like buf is of type pointer to a char rather
than pointer to a pointer to a char.

buf is of type "array[10] of array[10000] of char".
It can decay to "pointer to array[10000] of char", but not to
"pointer to pointer to char". Read the FAQ for a more detailed
explanation.

[Keith Thompson]

ra*****@netscap e.net writes:

Mark McIntyre wrote:

>However, it looks like buf
>is of type pointer to a char rather than pointer to a pointer to a char.

If its defined as above, its an array of arrays of chars.

Note that this isn't the same as either a pointer or a pointer to a
pointer.

Isn't an array and a pointer basically the same once memory has been
allocated etc. ? The difference being that you can't move where the
array base is and also that the array will have memory allocated
automatically. For example, these are basically equivalent (assuming
you ignore run-time and compile time memory allocation differences):

No. Arrays are arrays, and pointers are pointers.

The rule is that an expression of array type, in most contexts, is
implicitly converted to a pointer to the array's first element. The
exceptions are when the array expression is the operand of a unary "&"
or "sizeof" operator, or when it's a string literal in an initializer.

Read section 6 of the C FAQ, <http://www.eskimo.com/~scs/C-faq/faq.html>.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Flash Gordon]

ra*****@netscap e.net wrote:

Mark McIntyre wrote:

However, it looks like buf
is of type pointer to a char rather than pointer to a pointer to a char.
If its defined as above, its an array of arrays of chars.

Note that this isn't the same as either a pointer or a pointer to a
pointer.

Isn't an array and a pointer basically the same once memory has been
allocated etc. ?

No. Try using sizeof on it. Taking the address also give you a pointer
of a different type. I suggest you read the comp.lang.c FAQ, I'll point
you at a few of the appropriate sections, but you should read rather
more than I will specifically point you at.

Start with http://www.eskimo.com/~scs/C-faq/q6.3.html

<snip>
Anyway, perhaps this equivalence breaks down when you start dealing
with arrays of arrays.
It breaks down with sizeof and & as well.
So, I guess the question is, if I define buf as:

char buf[10][10000];

and want to pass it to a function, what should the function prototype
be ? I had assumed that a double array was effectively a pointer to a
pointer.
No, see http://www.eskimo.com/~scs/C-faq/q6.18.html
Also, I assume that it still passes by reference and doesn't copy the
entire array to the function's local variables.

The array name decays to a pointer to its first element, see
http://www.eskimo.com/~scs/C-faq/q6.4.html, but since pointers and
arrays are different types a pointer to an array and a pointer to a
pointer are different.

Read the rest of section 6, and also read what your text book says about
arrays and pointers (get K&R2 if you don't have a text book, see the
bibliography of the FAQ for the full name).
--
Flash Gordon
Living in interesting times.
Although my email address says spam, it is real and I read it.

[bitshadow]

char buf[10][10000]
dosomething(buf );

void dosomething(cha r buf[10][])
{
buf[i][j]

}

shouldn't that be:

void dosomething(cha r *[]);
or// void dosomething(cha r **)
or// void dosomething(cha r [][])

and its subsequent definition:

void dosomething(cha r [][COLS])
or// void dosomething(cha r (*ptr_chr)[COLS] )

the point being that a matrix is really a contiguous block of memory
stored in the computer. the abstraction of a deminsion higher than one
is purely a way to simplify it for the programmer. As the computer
obviously cannot do that, it thinks in a linear pattern and the memory
is allocated thus. thus for multidemensiona l arrays all the compiler
really needs to know is how many elements it needs to read and what
data type it is pointing to.

[Simon Biber]

ra*****@netscap e.net wrote:

So, I guess the question is, if I define buf as:

char buf[10][10000];

and want to pass it to a function, what should the function prototype
be ? I had assumed that a double array was effectively a pointer to a
pointer.
That's where you went wrong. It's not a pointer to a pointer. It's
effectively a 'pointer to an array of 10000 char'. Read on for more
explanation of what that means.

The correct prototype is:
void function(char (*buf)[10000]);

An alternative prototype, which means *exactly* the same thing, is:
void function(char buf[][10000]);

Also, I assume that it still passes by reference and doesn't copy the
entire array to the function's local variables.

It doesn't copy the entire array. If you have
char buf[10][10000];
then buf is an array of ten elements. Yes, only ten elements. But what
type does each element have?

Hint: it is NOT a pointer type!

Each element is an array of 10000 chars.

The memory for each of the ten arrays of 10000 chars are packed together
as a single block of 100,000 bytes. There are no pointers stored in memory.

There is a fundamental RULE about arrays, which always applies:

When you use an array, including passing it to a function, what
was an "array" actually becomes a "pointer to the first element
of the array".

What is the first element of your array? It's buf[0].
What type does it have? Array of 10000 char. It is not a pointer.

A pointer to the first element of your array has a special new type:
"pointer to array of 10000 char". You may not have come across the C
syntax for writing such a thing yet. If you wanted to declare 'p' as a
pointer to array of 10000 char, you would write:
char (*p)[10000];

These pointers to arrays are clever beasties. If you add a number to one
of them, it will automatically skip that many blocks of 10000 char, in
effect finding the address of the N'th array of 10000 char. So,
buf + 0 is a pointer to the first block of 10000 char,
buf + 1 is a pointer to the second block of 10000 char,
buf + 2 is a pointer to the third block of 10000 char, etc.

If you dereference it (apply the * operator), it will resolve back into
an array of 10000 char, which will in turn become a pointer to the first
element of that array, ie. a pointer to char.

(buf + 2) is a pointer to the second block of 10000 char

*(buf + 2) is the second block itself, which resolves into
a pointer to the first element of the second block.

However, the pointer *(buf + 2) is never actually stored in the array.
It is *calculated*, probably by adding 2 * 10000 to the base address of
the array.

C has a nice piece of 'syntactical sugar', an unnecessary addition to
the language, which allows you to re-write an expression
*(a + b)
as
a[b]

The two forms are equivalent in *all* situations, no matter whether you
are using arrays, pointers, strings, etc.

So, *(buf + 2) is equivalent to buf[2]

Obviously, the second form is considered more stylish, but you must
understand their equivalence, to understand how C arrays and pointers work.

--
Simon.

[Netocrat]

On Wed, 26 Oct 2005 15:49:42 -0700, Mike Deskevich wrote:
[...]

a multiply dimentioned array is
still just a pointer, not a pointer to a pointer.
It's not a pointer, but it does automatically decay to one in most
contexts.

[...] char buf[10][10000];

printf("%c",buf[i][j])

which is equivalent to

char buf[10*10000]
printf("%c",buf[j*10+i]) //i think i got that right - gurus: please ^^^^^^
i*10000+j

[...] void dosomething(cha r buf[10][])
Won't compile as written.

Try: buf[][10000],
or buf[10][10000]
or (*buf)[10000]

This allows a two-dimensional array with fixed-size second dimension to be
passed without recourse to the two alternatives you later suggested,
although the pointer-to-pointer technique is a common means of dealing
with a variable-size second dimension. C99 provides variable arrays with
further utility when passing array parameters as discussed in detail in a
prior thread.

[For array parameters in function prototypes] the compiler needs to know the size of all the dimensions except for the
last one.

^^^^
first

--
http://members.dodo.com.au/~netocrat