Modular classes article sucks

quote:

---

This is a big pain in the ass and its impossible to have private and protected struct members.

---

I think it should be noted that there is _more_ than one way to accomplish OO aspects in a non-OO language, especially C. I also have you know that this is not totally useless. Here is a specific applications: platforms(especially embedded systems) where a C++ compiler is not available.

Something that I do which was not really mentioned in the article is a case of single inheiritance. Example:

typedef struct baseclass {

int x;

int y;

} BASECLASS;


Derived class:

typedef struct newclass {

BASECLASS parent;

int z;

} NEWCLASS;

Now here is where it has power: A pointer to newclass can be typecast to a pointer to baseclass without ANY issues. The compiler formats the beginning of NEWCLASS structure the same way it formatted BASECLASS in memory, therefore any code that uses BASECLASS can work with NEWCLASS(unless you modify the behaviour, but the whole idea is NOT to do so).

About the global table of instances of objects: it was a neat idea, I always make a pointer to the "object" an additional argument to the function thus avoiding all issues his technique creates. Actually I believe C++ implements it closer to my way, it passes an additonal hidden argument in functions which is a pointer to the instance of the class being called.

Someone mentioned COM. Well, technically a COM interface is array of pointers to functions. Needless to say, C function pointers have a great deal of power, and it would be possible to use this as well, here''s an example.

About three years ago, I was working on my 3d engine, when software rendering was still an option, and Glide was still a pretty good choice. I used a set of function pointers to a base triangle drawing function. This pointer was set at the initialization to either the software rasterizer, or glide rasterizer. Anytime a triangle needed drawing, this pointer was used, eliminating the need for a test everytime to determine the triangle drawing routine. Another case: I wrote a parser for HTML, and decided that I would have a general tag processing function, so I made a hash table of pointers to functions, hashed by tag name, and then as I parsed the file, I simply looked up the tag name in the table and called the function I found. When I need to add a new tag, I just add a call to add it to the table in the parser initialization, and then write the functions.

Of course, if I wanted to use a OO language, I could, but there is also another benefit to using a language like C: experimenting with techniques for OO stuff NOT available in your language. Guess what, your OO language is not completely OO, nor is it the only approach to OO, but because it has certain attitudes and decisions in its approach your limited by that. I my procedural language I can write OO code unencumbered by the decisions of the designers of C++ or Java, and can experiment with techniques that you may find in your NEXT OO language.

I didn''t mean that as a rant, but I just wanted to point out something other than what he talked about, and techniques I find useful. Hey, here''s a PRODUCTIVE idea, lets turn this thread into a discussion of techniques rather than flamebait and making fun of the guy who wrote the article.

quote:

---

If you want to do OOP, you''ll sure prefer C over C++, but nobody wants to use OOP nowadays.

---

quote:

---

Something that I do which was not really mentioned in the article is a case of single inheiritance. Example:
typedef struct baseclass {
int x;
int y;
} BASECLASS;
Derived class:
typedef struct newclass {
BASECLASS parent;
int z;
} NEWCLASS;
Now here is where it has power: A pointer to newclass can be typecast to a pointer to baseclass without ANY issues. The compiler formats the beginning of NEWCLASS structure the same way it formatted BASECLASS in memory, therefore any code that uses BASECLASS can work with NEWCLASS(unless you modify the behaviour, but the whole idea is NOT to do so).

---

// cumbersome type checking
struct Object
{
  int type;
  // common members, i.e. position, size, whatever;
};

void display_object (Object* pOb)
{
  switch (pOb->type)
  {
    case TYPE_CIRCLE: // do one thing
    case TYPE_SQUARE: // do another thing
  }
}
 

class ObjBase
{
public:
  virtual void display () = 0;
protected:
  // common members
};

class ObjCircle : public ObjBase
{
  // whatever you need in here
};

class ObjSquare : public ObjBase //etc.