Object Oriented Programming in C, Avoid Memory Allocation

[Andrew Au]

Dear all,

I am trying to write a piece of software that use Object Oriented design
and implement it with C, I did the following

== In Object.h ==
typedef struct ObjectStructure * Object;

Object object_create() ;
int object_getInteg erAttribute(Obj ect object);
void object_setInteg erAttribute(Obj ect object, int integerAttribut e);
void object_unload(O bject object);

== In Object.c ==

#include <stdlib.h>

struct ObjectStructure {
int integerAttribut e;
};

Object object_create() {return (Object)malloc( sizeof(struct
ObjectStructure ));}
int object_getInteg erAttribute(Obj ect object) {return
object->integerAttribu te;}
void object_setInteg erAttribute(Obj ect object, int integerAttribut e)
{object->integerAttribu te = integerAttribut e;}
object_unload(O bject object) {free object}

// I am afraid if the above code even compile, since I am simply writing the
code in the news client without a compiler.

While it is good to encapsulate the Object's structure, now, I must always
create the object in a dynamic memory allocation way (obviously, coz' the
outside world has no idea of the structure's size).

Now I am in dillema, I would like to have encapsulation for the object, so
that further changes to the Object does not affect the rest of the code, but
at the same time, I would like to avoid dynamic memory allocation as much as
possible, following the rule that ONLY unknown size of memory (p.s. I don't
have very large memory block) should be dynamically allocated, and any
pieces of dynamic memory should be reused as much as possible. (For
performance issue)

What should I do? At the same time, I would like to seek method refactor my
code so as to minimize memory allocation, are there any suggestion?
Memory Pool is great, and I am already using them.

[Malcolm]

"Andrew Au" <cs****@gmail.c om> wrote

Now I am in dillema, I would like to have encapsulation for the object, so
that further changes to the Object does not affect the rest of the code, but at the same time, I would like to avoid dynamic memory allocation as much as possible, following the rule that ONLY unknown size of memory (p.s. I don't have very large memory block) should be dynamically allocated, and any
pieces of dynamic memory should be reused as much as possible. (For
performance issue)

What should I do? At the same time, I would like to seek method refactor my code so as to minimize memory allocation, are there any suggestion?
Memory Pool is great, and I am already using them.

Write a pair of functions, mymalloc() and myfree(), and use them to allocate
your objects from a big global pool.
When memory / performance constraints bite, tweak these functions. For
instance if you know that you always allocate 10 struct foos of 50 bytes,
then you can create a special pool of 50 byte blocks and allocate from this
efficiently and without any fragmentation.

[Andrew Au]

cs****@gmail.co m (Andrew Au) wrote in message news:<4c******* *************** ****@posting.go ogle.com>...

Dear all,

I am trying to write a piece of software that use Object Oriented design
and implement it with C, I did the following

== In Object.h ==
typedef struct ObjectStructure * Object;

Object object_create() ;
int object_getInteg erAttribute(Obj ect object);
void object_setInteg erAttribute(Obj ect object, int integerAttribut e);
void object_unload(O bject object);

== In Object.c ==

#include <stdlib.h>

struct ObjectStructure {
int integerAttribut e;
};

Object object_create() {return (Object)malloc( sizeof(struct
ObjectStructure ));}
int object_getInteg erAttribute(Obj ect object) {return
object->integerAttribu te;}
void object_setInteg erAttribute(Obj ect object, int integerAttribut e)
{object->integerAttribu te = integerAttribut e;}
object_unload(O bject object) {free object}

// I am afraid if the above code even compile, since I am simply writing the
code in the news client without a compiler.

While it is good to encapsulate the Object's structure, now, I must always
create the object in a dynamic memory allocation way (obviously, coz' the
outside world has no idea of the structure's size).

Now I am in dillema, I would like to have encapsulation for the object, so
that further changes to the Object does not affect the rest of the code, but
at the same time, I would like to avoid dynamic memory allocation as much as
possible, following the rule that ONLY unknown size of memory (p.s. I don't
have very large memory block) should be dynamically allocated, and any
pieces of dynamic memory should be reused as much as possible. (For
performance issue)

What should I do? At the same time, I would like to seek method refactor my
code so as to minimize memory allocation, are there any suggestion?
Memory Pool is great, and I am already using them.

I am thinking of a way through macro expansion

== In Object.h ==
#define OBJECT (Object*)char[OBJECT_SIZE];
#define OBJECT_SIZE;

== In Object.c

// Somewhere
{
assert(OBJECT_S IZE == sizeof(struct ObjectStructure ));
}

Then I could have static Object placed on the heap.
One difference from C++ is that the Object created must be freed, even
it is placed on the stack, it won't automatically destruct.

[Christian Bau]

In article <4c************ **************@ posting.google. com>,
cs****@gmail.co m (Andrew Au) wrote:

Now I am in dillema, I would like to have encapsulation for the object, so
that further changes to the Object does not affect the rest of the code, but
at the same time, I would like to avoid dynamic memory allocation as much as
possible, following the rule that ONLY unknown size of memory (p.s. I don't
have very large memory block) should be dynamically allocated, and any
pieces of dynamic memory should be reused as much as possible. (For
performance issue)

Can you prove that memory allocation/deallocation affects performance in
any significant way, or is this just a guess? And "significan t" means: I
will lose sales because of it, or customers will complain, or I will
have to buy faster and more expensive hardware.

Do whatever makes programming easiest.

[Derrick Coetzee]

Andrew Au wrote:

Now I am in dillema, I would like to have encapsulation for the object, so
that further changes to the Object does not affect the rest of the code, but
at the same time, I would like to avoid dynamic memory allocation as much as
possible [ . . . ]

This is a concern, since static allocation is more efficient (especially
the freeing part) and many calls to functions using such objects locally
could start to have an impact. Fragmentation on the other hand is not a
concern, since this could be fixed with pools or by using a better
memory allocator.

Here's a little trick I once came up with that lets you create both
public and private members in a C data structure. First put something
like this in your header file:

struct employeePrivate {
int age;
int salary;
};

typedef struct {
char* name;
char privateData[sizeof(struct employeePrivate )];
} Employee;

Employee objectCreate();

In other source files, they can access the public "name" element
directly, but in order to touch the private data they would have to
explicitly mess with the privateData array, which is unlikely to happen
accidentally (and easy to locate if someone does it). In the object's
implementation source file, you place this macro:

#define pri(obj, field) \
(((struct employeePrivate *)(&((obj).priv ateData)))->field)

Used like this:

Employee emp = ...;
pri(emp, salary) = pri(emp, age) * 1000;

These accesses will be just as efficient as normal accesses of struct
members, once the compiler has worked things out. All this code is
untested though. I hope this helps.
--
Derrick Coetzee
I grant this newsgroup posting into the public domain. I disclaim all
express or implied warranty and all liability. I am not a professional.

[Derrick Coetzee]

Derrick Coetzee wrote:

typedef struct {
char* name;
char privateData[sizeof(struct employeePrivate )];
} Employee;

Employee objectCreate();

Err, I forgot to mention - the allocation policy here is, like in most
non-OOP C programs, the caller allocates space for the Employee wherever
they like, and instead of having the implementation create and destroy
the object, you have it "initialize " and "deinitiali ze" it:

Employee employeeInitial ize(void);
void employeeDeiniti alize(Employee) ;

--
Derrick Coetzee
I grant this newsgroup posting into the public domain. I disclaim all
express or implied warranty and all liability. I am not a professional.

[Derrick Coetzee]

Derrick Coetzee wrote:

Employee employeeInitial ize(void);
void employeeDeiniti alize(Employee) ;

Argh, I meant:

void employeeInitial ize(Employee*);
void employeeDeiniti alize(Employee* );

--
Derrick Coetzee
I grant this newsgroup posting into the public domain. I disclaim all
express or implied warranty and all liability. I am not a professional.

[Derrick Coetzee]

Derrick Coetzee wrote:

typedef struct {
char* name;
char privateData[sizeof(struct employeePrivate )];
} Employee;

To avoid alignment issues this might be better:

typedef struct {
char privateData[sizeof(struct employeePrivate )];
<public members>
} Employee;

I'm not sure if even that is allowed by the standard, though. But in
your case, all data is private, so it doesn't really matter.
--
Derrick Coetzee
I grant this newsgroup posting into the public domain. I disclaim all
express or implied warranty and all liability. I am not a professional.

[Chris Torek]

In article <news:ch******* ***@news-int.gatech.edu>
Derrick Coetzee <dc****@moonfla re.com> wrote:

Derrick Coetzee wrote:

typedef struct {
char* name;
char privateData[sizeof(struct employeePrivate )];
} Employee;

To avoid alignment issues this might be better:

typedef struct {
char privateData[sizeof(struct employeePrivate )];
<public members>
} Employee;

I'm not sure if even that is allowed by the standard, though.

The second one is guaranteed to work (because the offset of any
structure's first member is guaranteed to be zero, and sizeof()
takes into account any required padding). The first one is indeed
not guaranteed.

(My opinion, though, is that if you want to write C++ code, just write
C++ code. :-) )
--
In-Real-Life: Chris Torek, Wind River Systems
Salt Lake City, UT, USA (40°39.22'N, 111°50.29'W) [phone]
email: forget about it http://web.torek.net/torek/index.html
Reading email is like searching for food in the garbage, thanks to spammers.

[E. Robert Tisdale]

Andrew Au wrote:

I am trying to write a piece of software
that uses Object Oriented design and implement it with C.
I did the following:

//== In Object.h ==

typedef struct ObjectStructure * Object;
You are confused.
An object is *not* a type.
It is an instance of some type.
Object object_create() ;
int object_getInteg erAttribute(Obj ect object);
void object_setInteg erAttribute(Obj ect object, int integerAttribut e);
void object_unload(O bject object);

//== In Object.c ==

#include <stdlib.h>

struct ObjectStructure {
int integerAttribut e;
};

Object object_create(v oid) {
return (Object)malloc( sizeof(struct ObjectStructure )); }
int object_getInteg erAttribute(Obj ect object) {
return object->integerAttribu te; }
void object_setInteg erAttribute(Obj ect object, int integerAttribut e) {
object->integerAttribu te = integerAttribut e; }
object_unload(O bject object) { free object }

// I am afraid if the above code even compile,
since I am simply writing the code in the news client without a compiler.

While it is good to encapsulate the Object's structure,
now, I must always create the object in a dynamic memory allocation way
(obviously, coz' the outside world has no idea of the structure's size).

Now I am in dillema, I would like to have encapsulation for the object
so that further changes to the Object does not affect the rest of the code
but, at the same time, I would like to avoid dynamic memory allocation
as much as possible, following the rule that ONLY unknown size of memory
(p.s. I don't have very large memory block) should be dynamically allocated
and any pieces of dynamic memory should be reused as much as possible.
(For performance issue) What should I do?
At the same time, I would like to seek method refactor my code
so as to minimize memory allocation, are there any suggestion?
Memory Pool is great, and I am already using them.
I would do it this way:
cat someType.h #ifndef GUARD_SOMETYPE_ H
#define GUARD_SOMETYPE_ H 1

#include <stdlib.h>

typedef struct someType {
int Attribute;
} someType;

someType someType_create (int);
someType* someType_new(in t);
int someType_attrib ute(const someType*);
void someType_destro y(const someType*);
void someType_delete (const someType*);

#endif//GUARD_SOMETYPE_ H
cat someType.c #include "someType.h "

// private initializer
someType* someType_initia lize(
someType* p, int attribute) {
p->Attribute = attribute;
return p;
}

someType someType_create (int attribute) {
someType value;
someType_initia lize(&value, attribute);
return value;
}

someType* someType_new(in t attribute) {
someType* p = (someType*)mall oc(sizeof(someT ype));
return someType_initia lize(p, attribute);
}

int someType_attrib ute(const someType* p) {
return p->Attribute;
}

void someType_destro y(const someType* p) { }

void someType_delete (const someType* p) {
someType_destro y(p);
free((void*)p);
}

Now you can write:

#include "someType.h "

int main(int argc, char* argv[]) {
someType anObject = someType_create (13);
// do stuff with anObject
someType_destro y(&anObject);
return EXIT_SUCCESS;
}

Memory is allocated from automatic storage for anObject.

Actually, for simple objects like this, I might write:
cat someType.h

#ifndef GUARD_SOMETYPE_ H
#define GUARD_SOMETYPE_ H 1

#include <stdlib.h>

typedef struct someType {
int Attribute;
} someType;

inline static
someType someType_create (int attribute) {
someType value;
value.Attribute = attribute;
return value;
}

inline static
someType* someType_new(in t attribute) {
someType* p = (someType*)mall oc(sizeof(someT ype));
p->Attribute = attribute;
return p;
}

inline static
int someType_attrib ute(const someType* p) {
return p->Attribute;
}

inline static
void someType_destro y(const someType* p) { }

inline static
void someType_delete (const someType* p) {
someType_destro y(p);
free((void*)p);
}

#endif//GUARD_SOMETYPE_ H