«

If I used this return statement in a c function

return (int)* "hello world";

From what I know the calling function will only retrieve the character
'h', right ?

Is it right to assume that nevertheless, read only memory was
allocated for the entire string "hello world" , And if so can that
memory(Or the rest of the characters) be accessed somehow ?

Thanks in advance.

thedude <> wrote:
> If I used this return statement in a c function

> return (int)* "hello world";

Why would you do that?

> From what I know the calling function will only retrieve the character
> 'h', right ?

The caller will receive the address of the string literal
cast to an int pointer. What that should be good for is
beyond me since the correct type of the address is const
char pointer. This conversion to int pointer invokes un-
defined behaviour. The standard allows to convert an ob-
ject pointer (e.g. an int *) to a void (or, for historical
reasons, char) pointer and then the back-conversion of this
result, but not from every object pointer type to each other
object pointer type (on some architectures different types
of pointers may have e.g. different sizes).

If you dereference the int pointer you got back from the func-
tion you may get a bus error since an int may have more strict
alignment requirements than a char, so the string may start at
an address that's not suitable aligned for accesses via an int
pointer (even if the cast from const char * to int * didn't
mess up the address).

> Is it right to assume that nevertheless, read only memory was
> allocated for the entire string "hello world"

Yes, with and without the "nevertheless"

> And if so can that
> memory(Or the rest of the characters) be accessed somehow ?

Yes and no. If your machine actually doesn't do anything
bad when converting from const char * to int * then you may
be able to convert the returned pointer back to const char *;
so you can get at the string. But why rely on that? If your
function is supposed to return a generic pointer you should
use a void pointer.
Regards, Jens
--
\ Jens Thoms Toerring ___
\__________________________ http://toerring.de

On 22 Jul., 15:47, thedude wrote:
> If I used this return statement in a c function
>
> return (int)* "hello world";
>
> From what I know the calling function will only retrieve the
> character 'h', right ?

Please provide a code snippet that actually compiles or at least is
supposed to compile. I'm guessing you meant something like this:

char* foo() {
return "hello world";
}

In this case the function returns a pointer that points to the
character 'h', yes. But all the characters are placed consecutivly in
memory.

> Is it right to assume that nevertheless, read only memory was
> allocated for the entire string "hello world" ,

Yes. At least you are not allowed to change any of it. Prefer to use
the type "const char*" in such cases. This makes any mutation attemp a
compile-time error.

int main(void) {
const char *p = "hello";
p[0] = 'H'; // compile-time error
return 0;
}

whereas without "const" this program would probably compile on all
compilers but invoke undefined behaviour.

> And if so can that memory(Or the rest of the characters) be
> accessed somehow ?

Sure. A string literal is a character array with static storage. As
such, all the characters are stored linearly in memory.

#include <stdio.h>

int main(void) {
const char *p = "hello";
while (*p) printf("%c",*p++);
puts("\n");
return 0;
}

This program iterates through the whole string by incrementing the
pointer until the null terminator is reached. You see, the string
literal "hello" is an array of 6 characters: 'h', 'e', 'l', 'l', 'o',
'\0'.

Cheers
SG

(Jens Thoms Toerring) writes:

> thedude <> wrote:
>> If I used this return statement in a c function
>
>> return (int)* "hello world";
>
> Why would you do that?
>
>> From what I know the calling function will only retrieve the character
>> 'h', right ?
>
> The caller will receive the address of the string literal
> cast to an int pointer. [snip]

You may want to look again. The cast is to (int),
not to (int*).

Tim Rentsch <> wrote:
> (Jens Thoms Toerring) writes:

> > thedude <> wrote:
> >> If I used this return statement in a c function
> >
> >> return (int)* "hello world";
> >
> > Why would you do that?
> >
> >> From what I know the calling function will only retrieve the character
> >> 'h', right ?
> >
> > The caller will receive the address of the string literal
> > cast to an int pointer. [snip]

> You may want to look again. The cast is to (int),
> not to (int*).

Ooops, where are my glasses when I need them? Thanks...

Regards, Jens
--
\ Jens Thoms Toerring ___
\__________________________ http://toerring.de

thedude <> writes:

> If I used this return statement in a c function
>
> return (int)* "hello world";
>
> From what I know the calling function will only retrieve the character
> 'h', right ?

Only the first character of the string literal will
be accessed, if that's what you mean.

> Is it right to assume that nevertheless, read only memory was
> allocated for the entire string "hello world" ,

It may be but it doesn't have to be. An implementation
may (legally) compile this the same as it would compile

return (int) 'h';

> And if so can that
> memory(Or the rest of the characters) be accessed somehow ?

Memory for the string literal need not exist in the
actual compiled program.

Sebastian <> writes:

> On 22 Jul., 15:47, thedude wrote:
>> If I used this return statement in a c function
>>
>> return (int)* "hello world";
>>
>> From what I know the calling function will only retrieve the
>> character 'h', right ?
>
> Please provide a code snippet that actually compiles or at least is
> supposed to compile. [snip]

I'm guessing you misread the example line. That's '(int)*',
not '(int*)'.

On 22 Jul., 16:14, Sebastian wrote:
> On 22 Jul., 15:47, thedude wrote:
>
> > If I used this return statement in a c function
>
> > * return (int)* "hello world";
>
> > From what I know the calling function will only retrieve the
> > character 'h', right ?
>
> Please provide a code snippet that actually compiles or at least is
> supposed to compile. I'm guessing you meant something like this:
>
> * char* foo() {
> * * return "hello world";
> * }

Oops.

return (int)* "hello world"

is actually legal for a function that returns int. I was assuming you
made a typo and meant (int*). But it also makes little sense. *"hello
world" is pretty much equivalent to 'h'. In that case the function
returns only an integer representing the 'h' character and you won't
be able to retrieve anything else because the address is lost.

You should have posted the whole function's body.

> Cheers
> SG

Thanks for your response Tim R.(and everyone else)

Yes I did mean dereference the string literal and cast it to an int.

Problem is, That function is in an "obnoxious" header file(API) I am
supposed to use(ie not in my control).
And I saw that only the first character was being returned, And why
they did that was beyond me too.

Ravi

On Jul 22, 10:27*am, Tim Rentsch <t...@alumni.caltech.edu> wrote:
> Sebastian <s.gesem...@gmail.com> writes:
> > On 22 Jul., 15:47, thedude wrote:
> >> If I used this return statement in a c function
>
> >> * return (int)* "hello world";
>
> >> From what I know the calling function will only retrieve the
> >> character 'h', right ?
>
> > Please provide a code snippet that actually compiles or at least is
> > supposed to compile. [snip]
>
> I'm guessing you misread the example line. *That's '(int)*',
> not '(int*)'.

On Jul 22, 5:42*pm, thedude <myclcontac...@gmail.com> wrote:
> Thanks for your response Tim R.(and everyone else)
>
> Yes I did mean dereference the string literal and cast it to an int.
>
> Problem is, That function is in an "obnoxious" header file(API) I am
> supposed to use(ie not in my control).
> And I saw that only the first character was being returned, And why
> they did that was beyond me too.
>
It seems odd.
However it's quite common to pass chars around as ints. For some
reason the character 'h' must have been required, and the reason it
was 'h' and not some other value was that 'h' is the initial character
of the string "hello world". That would make sense - if the crucial
string turns to "goodbye cruel world" at some later date the source of
the 'h' is documented for the maintainer.