«

Hi!

I have two struts like that:

struct {
int num;
int num2;
struct b arrayOfB[SIZE];
} a;

struct {
int num3;
int num4
} b;

I put struct a into Shared Memory:
shmid = shmget(IPC_PRIVATE, sizeof(struct b), 0666)

and atach it in two process:
ptr = shmat(shmid, 0, 0);

This works fine, but now i must delete the constant SIZE:

I will obtain the SIZE in runtime, before execute the shmget function.

the new struct a:

struct {
int num;
int num2;
struct b *arrayOfB;
} a;

now:

I put struct a into Shared Memory:
shmid = shmget(IPC_PRIVATE, sizeof(struct a) + sizeof(struct b) *
size, 0666);

and atach it in two process:
ptr = shmat(shmid, 0, 0);

my question is: how can tell arrayOfB to point over the shared memory?

i thought:

struct a *ptr,p2*;
p2 = ptr; //ptr is the shmat return
p2++;
ptr->arrayOfB

but doesn't work. in another way i read about the shmat parametrs, but
don't understand how (if its possible) use to solve my trouble.

Thanks.

On Jul 3, 12:29*pm, "hugo.arre...@gmail.com" <hugo.arre...@gmail.com>
wrote:
> Hi!
>
> I have two struts like that:
>
> struct {
> int num;
> int num2;
> struct b arrayOfB[SIZE];
>
> } a;
>
> struct {
> int num3;
> int num4
>
> } b;
>
> I put struct a into Shared Memory:
> shmid = shmget(IPC_PRIVATE, sizeof(struct b), 0666)
>
> and atach it in two process:
> ptr = shmat(shmid, 0, 0);
>
> This works fine, but now i must delete the constant SIZE:
>
> I will obtain the SIZE in runtime, before execute the shmget function.
>
> the new struct a:
>
> struct {
> int num;
> int num2;
> struct b *arrayOfB;
>
> } a;
>
> now:
>
> I put struct a into Shared Memory:
> shmid = shmget(IPC_PRIVATE, sizeof(struct a) + sizeof(struct b) *
> size, 0666);
>
> and atach it in two process:
> ptr = shmat(shmid, 0, 0);
>
> my question is: how can tell arrayOfB to point over the shared memory?
>
> i thought:
>
> struct a *ptr,p2*;
> p2 = ptr; //ptr is the shmat return
> p2++;
> ptr->arrayOfB
>
> but doesn't work. in another way i read about the shmat parametrs, but
> don't understand how (if its possible) use to solve my trouble.
>
> Thanks.

Forgetting the details of shared memory (which you would get better
advice in comp.unix.programmer, btw, as it is not standard C), you
could consider using the struct hack to solve your problem. See, e.g.
http://c-faq.com/struct/structhack.html

-David

> Forgetting the details of shared memory (which you would get better
> advice in comp.unix.programmer, btw, as it is not standard C), you
> could consider using the struct hack to solve your problem. See, e.g.http://c-faq.com/struct/structhack.html
>
> -David

Thanks you David, but my problem is how to do that in shared memory, i
will try in comp.unix.programmer.

Thanks again.

On Jul 3, 2:52*pm, "hugo.arre...@gmail.com" <hugo.arre...@gmail.com>
wrote:
> > Forgetting the details of shared memory (which you would get better
> > advice in comp.unix.programmer, btw, as it is not standard C), you
> > could consider using the struct hack to solve your problem. *See, e.g..http://c-faq.com/struct/structhack.html
>
> > -David
>
> Thanks you David, but my problem is how to do that in shared memory, i
> will try in comp.unix.programmer.
>
> Thanks again.

The first option in the faq site should work as well with shared
memory as elsewhere as far as I know. i.e. put in your structure
this:

struct b arrayOfB[1];

But allocate enough space for the structure AND the desired number of
"b" elements, then use it. This avoids the problem of having a
pointer to another block of memory in the struct...

-David

On Thu, 3 Jul 2008 09:29:37 -0700 (PDT), ""
<> wrote:

> struct {
> int num;
> int num2;
> struct b arrayOfB[SIZE];
> } a;
>
> struct {
> int num3;
> int num4
> } b;
<snip shared-memory>
Aside: you used sizeof(struct b) where you needed (struct a).

The shared-memory part is offtopic as it is not standard in C; but
issues of laying-out and accessing data in arbitrary memory, whether
it happened to come from shm* or say malloc (a_zillion), is ontopic.
At least if the memory is suitably aligned in the first place, and
both <offtopic> shmat and <ontopic> malloc are (for all types).

> [now] I will obtain the SIZE in runtime, before ... shmget ...
> struct {
> int num;
> int num2;
> struct b *arrayOfB;
> } a;
<snip>
> my question is: how can tell arrayOfB to point over the shared memory?
>

As already answered, you don't need this change; you can use the
'struct hack' in C89, or the equivalent but standard 'flexible array
member' in C99, to get the same 'in-place' layout as above.

But if you WANT to change to a pointer:

> struct a *ptr,p2*;

Syntax error; should be *ptr, *p2;

> p2 = ptr; //ptr is the shmat return
> p2++;
> ptr->arrayOfB
>
You're close. With the corrected declaration above, this gives you p2
pointing just after the struct-a. IF that location is suitably aligned
for a struct-b, you can just do ptr->arrayOfB = (struct b*) p2;
In fact you don't need a separate variable, just
ptr->arrayOfB = (struct b*) (ptr+1);
/* or equivalently */ = (struct b*) &ptr[1];

Unfortunately there is no standard way to determine what alignment is
needed for a struct-b, or provided by a struct-a (the size of any type
in C must be a multiple of its required alignment, to make arrays
work), so this can be unsafe. For the particular structs you showed,
it is extremely likely that any requirement for struct-a will (also)
satisfy struct-b, but it isn't absolutely 100% portably guaranteed.

If you want to use a pointer and handle the possible alignment issue,
simplest to use a union which is guaranteed to align for either:

struct a * aptr = shmat (...);
union x { struct a a; struct b b; } * xptr = (union x *) aptr;
aptr->arrayOfB = (struct b*) (xptr + 1);
/* this is guaranteed located after the struct-a,
AND aligned for a struct-b. It may _possibly_ be
offset more than actually needed and waste some space,
but on most modern systems this isn't worth worrying about,
unless your (individual) structures are truly huge,
in which case post a more specific example
and we can get into the more arcane methods. */

- formerly david.thompson1 || achar(64) || worldnet.att.net