Re: Is c++ only better c ?
On Oct 24, 2:44 pm, "Chris M. Thomasson" <no@spam.invalid> wrote:
"James Kanze" <james.kanze@gmail.com> wrote in message
news:ded8588f-baa2-4229-a17e-b658a95105fc@34g2000hsh.googlegroups.com...
On Oct 24, 11:55 am, Maxim Yegorushkin <maxim.yegorush...@gmail.com>
wrote:
On Oct 24, 10:27 am, Pawel_Iks <pawel.labed...@gmail.com> wrote:
I've read somewhere that c++ is something more than better c
... then I talk with my friend and he claimed that c++ is
nothing more than better c ... I tried to explain him that
he was wrong but I forgot all arguments about it. Could
someone told something about it?
Some actually consider C++ to be worse than
C:http://esr.ibiblio.org/?p=532
You'll find some idiot to defend just about any position. (Not
that all people who are critical of C++ are idiots. But the
intelligent ones don't like C either; the real problem with C++
is that it inherits too much from C.)
C++ definitely improves C. It also adds a lot of things which
support idioms which aren't supported in C. I suppose that you
could call support for OO,
[...]
You can get "fairly clean" abstract interfaces in C; something as simple =
as;
quick code scribbling - may have typo:
IShape.h
--------------------------------------------
struct IShape_VTable {
void (*IObject_Destroy) (void*);
void (*IShape_Draw) (void*);
/* ect... */
};
struct IShape {
struct IShape_VTable* VTable;
};
#define IObject_Destroy(Self) ( \
(Self)->VTable->IObject_Destroy((Self)) \
)
#define IShape_Draw(self) ( \
(Self)->VTable->IShape_Draw((Self)) \
)
That all the infrastructure. Now to create actual shapes...
Circle.h
--------------------------------------------
extern struct IShape*
Circle_Create(
/* ... */
);
Circle.c
--------------------------------------------
#include "Circle.h"
#include <stdlib.h>
static void Circle_IObject_Destroy(void*);
static void Circle_IShape_Draw(void*);
static struct IShape_VTable Circle_VTable = {
Circle_IObject_Destroy,
Circle_IShape_Draw
};
struct Circle {
struct IShape IShape;
/* ... */
};
struct IShape*
Circle_Create(
/* ... */
) {
struct Circle* Self = malloc(*Self);
if (Self) {
Self->IShape.VTable = &Circle_VTable;
return &Self->IShape;
}
return NULL;
}
void
Circle_IObject_Destroy(
void* IObject
) {
free(IObject);
}
void
Circle_IShape_Draw(
void* IShape
) {
struct Circle* const Self = IShape;
/* ... */
}
Now, finally we can use the Circle via. the abstract interfaces IShape an=
d
IObject:
main.c
--------------------------------------
#include "Circle.h"
int main(void) {
struct IShape* Shape = Circle_Create(/* ... */);
IShape_Draw(Shape);
IObject_Destroy(Shape);
return 0;
}
There... simple!
;^D
I used to code C in ways very similar to that, but it's a total
nightmare. It's not what C was designed for, and it's not the way to
code it (incidentally, it's the only *productive* way to code it!).
It's basically a faking of basic OO concepts such as an abstract type
with operations bundled to it, and it can be a clean way to code basic
applications. At a large scale, however, the lack of language support
for these programming techniques leads to a great deal of verbosity
and boilerplate code, almost to the point where the disadvantages
outweigh the advantages (it even increases the risk of memory leaks!).
C just isn't a good scaling language.
Sebastian