Return array of ponters?

[priya]

Hi all,

I am new to this group.I am working in c language.I have dount
in pointer? how to retun array of pointer in function?


example
main()
{
char *var[2];
char *a[2];
a[0]="hi";
a[1]="c language";
var=function(a) ;
}

char* function(char *a[2])
{
char *b[2];
b=a;

return(b);
}
In this program i have to retun b value(array of pointer) to var
variable...
Thanks

regards,
priya

[junky_fellow]

bjrnove wrote:

I was just wondering how compiler evaluates var[0] and var[1].
var was originally declared as a double pointer to char.
How does compiler evaluates var[1] ?
The compiler will translate var[1] into *(var + 1) witch in this case
will give you the address of a (since var is the address of a) +
sizeof(char*) (at least on a x86 system). I also think the standard
make shure this is true on every system, but I wouldn't bet my life

on it.

--
bjrnove

How the sizeof(char *) is evaluated ?

[Mark McIntyre]

On 23 May 2005 07:59:39 -0700, in comp.lang.c ,
ju**********@ya hoo.co.in wrote:

How the sizeof(char *) is evaluated ?

Er? The compiler will determine the size of a pointer to a char.

--
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 =----

[Keith Thompson]

ju**********@ya hoo.co.in writes:

main()
{
char *var[2];
char *a[2];
a[0]="hi";
a[1]="c language";
var=function(a) ;

This is wrong. var is not an "lvalue".

Yes it is; it just isn't a modifiable lvalue.

}

char* function(char *a[2])
{
char *b[2];
b=a;

Again wrong. b is not an "lvalue".

Again, b is an lvalue, but not a modifiable lvalue.

return(b);
}
In this program i have to retun b value(array of pointer) to var
variable...

You cannot return an array of pointers. What you can do is return
the address of the first element of the array of pointers.

Yes, you can return the address of the first element of an array, but
if that array is local to the function, you'll be returning the
address of something that won't exist by the time the caller sees it.
Any attempt by the caller to use the pointer will invoke undefined
behavior. (In many cases, the error won't be detected, and the caller
will happy mess around with the memory where the object used to
exist.)

For example:

char *func(void)
{
char result[10];
strcpy(result, "Oops");
return result; /* Bad idea! */
}

...

This returns a pointer to "result", an object that ceases to exist as
soon as the return is executed. Many compilers will issue a warning
for this error.

--
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.

[Keith Thompson]

ju**********@ya hoo.co.in writes:

bjrnove wrote:

>I was just wondering how compiler evaluates var[0] and var[1].
> var was originally declared as a double pointer to char.
>How does compiler evaluates var[1] ?

The compiler will translate var[1] into *(var + 1) witch in this case
will give you the address of a (since var is the address of a) +
sizeof(char*) (at least on a x86 system). I also think the standard
make shure this is true on every system, but I wouldn't bet my life
on it.

How the sizeof(char *) is evaluated ?

sizeof(char *) yields the size, in bytes, of an object of type char*
(a pointer to char). The compiler has to know how big it is, so the
expression is evaluated at compilation time.

But it's slightly misleading to say that var+1 evaluates to the
address of a + sizeof(char*). Let's assume sizeof(char*) is 4 (which
is a typical value). Given that var points to a, and that var is of
type char**, arithmetic on var inherently works in units of 4, so
var+1 points 4 bytes past the location where var points.

Any decent C textbook (K&R2 is good) should explain all this. Much of
it is also covered in the C FAQ.

--
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.

[Keith Thompson]

"bjrnove" <bj*****@gmail. com> writes:
[...]

This isn't what was asked for. The point here is to create a function
that returns an array of pointers. And I tried to explain that a char**
really is the same as char*[2] except sizeof would't work as expected
on the char**.

No, a char** is *not* really the same as a char*[2]. The former is a
pointer to a pointer; the latter is an array of pointers. The only
link between them is that an expression of array type, in most
contexts, is automatically converted to a pointer to the first element
of the array.

A function cannot return an array value (unless it's wrapped in a
struct). The usual way to do the equivalent of returning an array
value is to return a pointer to the array's first element -- but then
you have to worry about how the array itself is allocated.

See the C FAQ <http://www.eskimo.com/~scs/C-faq/top.html>, particularly
sections 4 (Pointers) and 6 (Arrays and Pointers).

--
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.

[junky_fellow]

Keith Thompson wrote:

ju**********@ya hoo.co.in writes:

main()
{
char *var[2];
char *a[2];
a[0]="hi";
a[1]="c language";
var=function(a) ;

This is wrong. var is not an "lvalue".

Yes it is; it just isn't a modifiable lvalue.

I have a confusion about how "var" could be an lvalue? The
compiler doesn't allocate any storage to "var" , so we can't
store any value in it. So, we shouldn't call it an "lvalue".
Even when I tried to compile, my compiler gave me the error
" "var" is not an lvalue "
Is there something I am missing ?

[Keith Thompson]

ju**********@ya hoo.co.in writes:

Keith Thompson wrote:

ju**********@ya hoo.co.in writes:

>> main()
>> {
>> char *var[2];
>> char *a[2];
>> a[0]="hi";
>> a[1]="c language";
>> var=function(a) ;
>
> This is wrong. var is not an "lvalue".
Yes it is; it just isn't a modifiable lvalue.

I have a confusion about how "var" could be an lvalue? The
compiler doesn't allocate any storage to "var" , so we can't
store any value in it. So, we shouldn't call it an "lvalue".

What makes you think no storage is allocated for "var"? It's an array
of two pointers to char. If sizeof(char*) is 4, for example, then 8
bytes will be allocated for "var".

An lvalue is an expression that designates an object.

On the other hand, an array expression such as the name of an array
variable, is implicitly converted (in most contexts) to a pointer to
its first element. It's an lvalue before the conversion, but not
after the conversion.
Even when I tried to compile, my compiler gave me the error
" "var" is not an lvalue "

That's an odd message, but I suppose you could argue that var is no
longer an lvalue after the implicit conversion.

--
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.