structure and malloc

[friend.05]

typedef struct
{
int a;
int b;
int c;
} ABC;

typedef struct
{
int d;
int e;
int f;
ABC *abc;
} DEF;

Create function should use a single call to malloc to allocate
memoryfor structure DEF and its constituting structure ABC. In other
words, after a call to the CreateDEF() function, the following
statements should be valid and should work without segmentation
violations:

DEF* pDEF = CreateDEF();
pDEF-->abc-->a = 100 ;
DEF *CreateDEF ( void )
{
}

void FreeDEF (ABC *pABC)
{
}

[Default User]

friend.05 wrote:

typedef struct
{
int a;
int b;
int c;
} ABC;

typedef struct
{
int d;
int e;
int f;
ABC *abc;
} DEF;

Create function should use a single call to malloc to allocate
memoryfor structure DEF and its constituting structure ABC. In other
words, after a call to the CreateDEF() function, the following
statements should be valid and should work without segmentation
violations:

DEF* pDEF = CreateDEF();
pDEF-->abc-->a = 100 ;
DEF *CreateDEF ( void )
{
}

void FreeDEF (ABC *pABC)
{
}

Take your best stab at it, in a complete program. Then we'll help. We
don't do homework.


Brian

[friend.05]

typedef struct
{
int a;
int b;
int c;
} ABC;

typedef struct
{
int d;
int e;
int f;
ABC *abc;
} DEF;

DEF *CreateDEF (void)
{
DEF strDEF;

strDEF.abc=(ABC *)malloc(sizeof (ABC));
strDEF.abc->a = 10;
printf("%d\n",s trDEF.abc->a);
retDEF=&strDEF;
return retDEF;
}

void FreeDEF (ABC *pABC)
{


}

void main()
{
DEF *pdef = CreateDEF();
pdef->d = 7;
printf("%d\n",p def->d);
pdef->abc->a = 10;
printf("%d\n",p def->abc->a);
}
But it is giving segmentation fault


On May 8, 5:28 pm, "Default User" <defaultuse...@ yahoo.comwrote:

friend.05 wrote:

typedef struct
{
int a;
int b;
int c;
} ABC;

typedef struct
{
int d;
int e;
int f;
ABC *abc;
} DEF;

Create function should use a single call to malloc to allocate
memoryfor structure DEF and its constituting structure ABC. In other
words, after a call to the CreateDEF() function, the following
statements should be valid and should work without segmentation
violations:

DEF* pDEF = CreateDEF();
pDEF-->abc-->a = 100 ;

DEF *CreateDEF ( void )
{
}

void FreeDEF (ABC *pABC)
{
}

Take your best stab at it, in a complete program. Then we'll help. We
don't do homework.

Brian- Hide quoted text -

- Show quoted text -

[Walter Roberson]

In article <11************ **********@y5g2 000hsa.googlegr oups.com>,
friend.05 <hi**********@g mail.comwrote:

>DEF *CreateDEF (void)
{
DEF strDEF;

strDEF.abc=(ABC *)malloc(sizeof (ABC));
strDEF.abc->a = 10;
printf("%d\n",s trDEF.abc->a);
retDEF=&strDEF;
return retDEF;
}

You can't return a pointer to a local variable (DEF). (Or rather,
you can't do anything with such a pointer once it has been
returned.)

Consider allocating a memory area big enough to hold both
structures.
--
"law -- it's a commodity"
-- Andrew Ryan (The Globe and Mail, 2005/11/26)

[Ian Collins]

friend.05 wrote:

Please don't top post!

typedef struct
{
int d;
int e;
int f;
ABC *abc;
} DEF;

DEF *CreateDEF (void)
{
DEF strDEF;

strDEF.abc=(ABC *)malloc(sizeof (ABC));

Avoid casting the return of malloc.

strDEF.abc->a = 10;
printf("%d\n",s trDEF.abc->a);
retDEF=&strDEF;
return retDEF;

Think about what you are returning, a local variable. What happens to
strDEF after the function returns.

>
void main()

Don't write this unless you have good grounds to do so. main returns int.

>
But it is giving segmentation fault

Explained above.

--
Ian Collins.

[Default User]

friend.05 wrote:

typedef struct
{
int a;
int b;
int c;
} ABC;

typedef struct
{
int d;
int e;
int f;
ABC *abc;
} DEF;

DEF *CreateDEF (void)
{
DEF strDEF;

strDEF.abc=(ABC *)malloc(sizeof (ABC));
strDEF.abc->a = 10;
printf("%d\n",s trDEF.abc->a);
retDEF=&strDEF;
return retDEF;
}

void FreeDEF (ABC *pABC)
{


}

void main()
{
DEF *pdef = CreateDEF();
pdef->d = 7;
printf("%d\n",p def->d);
pdef->abc->a = 10;
printf("%d\n",p def->abc->a);
}
But it is giving segmentation fault


On May 8, 5:28 pm, "Default User" <defaultuse...@ yahoo.comwrote:

friend.05 wrote:

typedef struct
{
int a;
int b;
int c;
} ABC;

typedef struct
{
int d;
int e;
int f;
ABC *abc;
} DEF;

Create function should use a single call to malloc to allocate
memoryfor structure DEF and its constituting structure ABC. In
other words, after a call to the CreateDEF() function, the
following statements should be valid and should work without
segmentation violations:

DEF* pDEF = CreateDEF();
pDEF-->abc-->a = 100 ;

DEF *CreateDEF ( void )
{
}

void FreeDEF (ABC *pABC)
{
}

Take your best stab at it, in a complete program. Then we'll help.
We don't do homework.

Brian- Hide quoted text -

- Show quoted text -

--
Please don't top-post. Your replies belong following or interspersed
with properly trimmed quotes. See the majority of other posts in the
newsgroup, or:
<http://www.caliburn.nl/topposting.html >

[Ian Collins]

Default User wrote:

friend.05 wrote:

So he did :)

>typedef struct
{
int a;
int b;
int c;
} ABC;

typedef struct
{
int d;
int e;
int f;
ABC *abc;
} DEF;

DEF *CreateDEF (void)
{
DEF strDEF;

strDEF.abc=(ABC *)malloc(sizeof (ABC));
strDEF.abc->a = 10;
printf("%d\n",s trDEF.abc->a);
retDEF=&strDEF;
return retDEF;
}

void FreeDEF (ABC *pABC)
{


}

void main()
{
DEF *pdef = CreateDEF();
pdef->d = 7;
printf("%d\n", pdef->d);
pdef->abc->a = 10;
printf("%d\n", pdef->abc->a);
}
But it is giving segmentation fault


On May 8, 5:28 pm, "Default User" <defaultuse...@ yahoo.comwrote:

>>friend.05 wrote:
typedef struct
{
int a;
int b;
int c;
} ABC;
typedef struct
{
int d;
int e;
int f;
ABC *abc;
} DEF;
Create function should use a single call to malloc to allocate
memoryfor structure DEF and its constituting structure ABC. In
other words, after a call to the CreateDEF() function, the
following statements should be valid and should work without
segmentati on violations:
DEF* pDEF = CreateDEF();
pDEF-->abc-->a = 100 ;
DEF *CreateDEF ( void )
{
}
void FreeDEF (ABC *pABC)
{
}
Take your best stab at it, in a complete program. Then we'll help.
We don't do homework.

Brian- Hide quoted text -

- Show quoted text -

--
Ian Collins.

[Default User]

friend.05 wrote:

Please don't top-post. Your replies belong following or interspersed
with properly trimmed quotes. See the majority of other posts in the
newsgroup, or:
<http://www.caliburn.nl/topposting.html >

I'll rearrange things.

Create function should use a single call to malloc to allocate
memoryfor structure DEF and its constituting structure ABC. In
other words, after a call to the CreateDEF() function, the
following statements should be valid and should work without
segmentation violations:

DEF* pDEF = CreateDEF();
pDEF-->abc-->a = 100 ;

DEF *CreateDEF ( void )
{
}

void FreeDEF (ABC *pABC)
{
}

Take your best stab at it, in a complete program. Then we'll help.
We don't do homework.

Add (see below for reason):

#include <stdlib.h>

typedef struct
{
int a;
int b;
int c;
} ABC;

typedef struct
{
int d;
int e;
int f;
ABC *abc;
} DEF;

DEF *CreateDEF (void)
{
DEF strDEF;

strDEF.abc=(ABC *)malloc(sizeof (ABC));

We don't recommend casting the results of malloc(). It can hide a
dangerous problem, that of not including the proper header, which you
did not.

strDEF.abc->a = 10;
printf("%d\n",s trDEF.abc->a);
retDEF=&strDEF;
return retDEF;

Returning a pointer to a local variable is not allowed.

Based on the requirements, which are very bad, you'll have to do some
unpleasant stuff. The obvious way is to allocate a chunk of memory
large enough for both structs. Then you set the "ABC" pointer to the
extra memory.

What's troublesome is the alignment issue. The reason you normally use
malloc() and friends is that you get a pointer properly aligned for any
type.

I have a sort of solution that "works" as in doesn't crash on either
VC++ or gcc/Solaris, which both have four-byte ints and struct pointers.

I think it's probably ok. The DEF struct should pad the end to get back
on a good boundary as needed for things like arrays of the structs.

DEF *CreateDEF (void)
{
char *p;
DEF *strDEF;

strDEF = malloc(sizeof(D EF) + sizeof(ABC));
p = (char*)strDEF;
p += sizeof(strDEF);
strDEF->abc = (void*)p;
strDEF->abc->a = 10;
printf("%d\n",s trDEF->abc->a);
return strDEF;
}
The gang will gently point out (ouch!!) if I'm totally whacked out on
that. It's best not to do this sort of thing. Why you had a requirement
for a single allocation, I can't fathom.


Brian

[Default User]

Ian Collins wrote:

Default User wrote:

friend.05 wrote:

So he did :)

Yes, there's some sort of key combination that sends posts. I
accidentally did whatever it is.


Brian

[christian.bau]

On May 8, 10:22 pm, "friend.05" <hirenshah...@g mail.comwrote:

typedef struct
{
int a;
int b;
int c;
} ABC;

typedef struct
{
int d;
int e;
int f;
ABC *abc;
} DEF;

Create function should use a single call to malloc to allocate
memoryfor structure DEF and its constituting structure ABC.

Assuming that this is homework, I would love to see the solution that
your teacher provides. The specification for the FreeDEF function
looks rather bizarre. I think the following should work:

DEF* CreateDEF (void) {
typedef struct { ABC abc; DEF def; } combined;
combined* p = malloc (sizeof (combined));
if (p) { p->def.abc = &p->abc; return &p->def; }
else return NULL;
}

void FreeDEF (ABC* pABC) { free (pABC); }