Is c++ only better c ?

[Pawel_Iks]

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?

[Chris M. Thomasson]

"SG" <s.********@gma il.comwrote in message
news:f5******** *************** ***********@i76 g2000hsf.google groups.com...

On 24 Okt., 21:44, "Chris M. Thomasson" <[e-mail] lidwrote:

>You can get "fairly clean" abstract interfaces in C; something as simple
as;
quick code scribbling - may have typo:

[... C++ abstract class and virtual function emulation in plain C ...]

There... simple!

Well, that was a really simple case, wasn't it?

Indeed. Although, I personally like to use the minimalist technique I
described for plug-in frameworks.

Try inheriting from more than one abstract class. :-)

Ouch! :^(

My point is: You can code "OO style"
in plain C. But it's gonna be verbose and error-prone.

Fair enough.

I have to admit
I didn't try any of the available frameworks for "OO-emulation in
plain C" (like GObject). Spending time learning these frameworks
instead of learning C++ doesn't seem like a good choice to me since C+
+ has other neat things to offer:
- RAII (one of the biggest selling points IMHO)
- support for generic programming (via templates, also big selling
point)

Agreed.

[Jeff Schwab]

Pawel_Iks 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?

Do you write code in either of those languages?

[Juha Nieminen]

Ian Collins wrote:

They tend to work them selves up into a lather about the added
complexity of C++ while refusing to acknowledge the complexity is optional.

What bothers me the most with their argument about "added complexity"
is that it feels like they have actually never even tried this "added
complexity" they are talking about.

The basic mistake in thinking is that "more features" equals to "more
complexity", which equals to "the language is harder to use and
understand". They emphasize that C is good because it's so simple.

There is no such equality. More features don't automatically make the
language more complex. In fact, it's often the exact opposite: More
features can make using the language *simpler*, not more complicated.

[Juha Nieminen]

Pawel_Iks 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?

I think that this is just an argument about semantics. If you say "C++
is something more than just a better C" that sentence has a positive
exalting tone to it, but if you say "C++ is nothing more than a better
C" that sentence has a belittling and unappreciating tone. In the end,
both sentences are saying the exact same thing. There's just a
difference in attitude.

[s0suk3]

On Oct 24, 2:44*pm, "Chris M. Thomasson" <[e-mail] dwrote:

"James Kanze" <ja*********@gm ail.comwrote in message

news:de******** *************** ***********@34g 2000hsh.googleg roups.com...
On Oct 24, 11:55 am, Maxim Yegorushkin <maxim.yegorush [e-mail]>
wrote:

On Oct 24, 10:27 am, Pawel_Iks <pawel.labed... @gmail.comwrote :

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_Destr oy) (void*);
* void (*IShape_Draw) (void*);
* /* ect... */

};

struct IShape {
* struct IShape_VTable* VTable;

};

#define IObject_Destroy (Self) ( \
* (Self)->VTable->IObject_Destro y((Self)) \
)

#define IShape_Draw(sel f) ( \
* (Self)->VTable->IShape_Draw((S elf)) \
)

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_D raw(void*);

static struct IShape_VTable Circle_VTable = {
* Circle_IObject_ Destroy,
* Circle_IShape_D raw

};

struct Circle {
* struct IShape IShape;
* /* ... */

};

struct IShape*
Circle_Create(
*/* ... */
) {
* struct Circle* Self = malloc(*Self);
* if (Self) {
* * Self->IShape.VTabl e = &Circle_VTab le;
* * return &Self->IShape;
* }
* return NULL;

}

void
Circle_IObject_ Destroy(
*void* IObject
) {
* free(IObject);

}

void
Circle_IShape_D raw(
*void* IShape
) {
* struct Circle* const Self = IShape;
* /* ... */

}

Now, finally we can use the Circle via. the abstract interfaces IShape and
IObject:

main.c
--------------------------------------
#include "Circle.h"

int main(void) {
* struct IShape* Shape = Circle_Create(/* ... */);
* IShape_Draw(Sha pe);
* 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

[blargg]

In article <6m************ @mid.individual .net>, Ian Collins
<ia******@hotma il.comwrote:

Juha Nieminen wrote:

Of if I put that in other terms: If someone considered C++ to be worse
exclusively because you have to declare functions before you use them,
that would be a rather stupid and trivial argument. When C hackers bash
C++, they are not talking about function declarations and void pointers,
they are talking about what C++ *adds* to the language that C doesn't
have (such as templates).

They tend to work them selves up into a lather about the added
complexity of C++ while refusing to acknowledge the complexity is optional.

Won't someone think of the compiler writers???

That's a common argument I hear when it is pointed out that one can use
C++ as (almost) straight C, "extreme" C++, or anything inbetween.

[James Kanze]

On Oct 25, 11:33*am, Ian Collins <[e-mail] mwrote:

Juha Nieminen wrote:

Of if I put that in other terms: If someone considered C++
to be worse exclusively because you have to declare
functions before you use them, that would be a rather stupid
and trivial argument. When C hackers bash C++, they are not
talking about function declarations and void pointers, they
are talking about what C++ *adds* to the language that C
doesn't have (such as templates).

They tend to work them selves up into a lather about the added
complexity of C++ while refusing to acknowledge the complexity
is optional.

I believe it was Robert Martin that first pointed it out, but
the complexity is always there; it's inherit in the application.
In the case of C++, that complexity manifests itself in the
language; in the case of C, in the code we have to write to
solve the problem. Which means that in the case of C++, we have
to master it once, for all applications; in the case of C, we
have to master it for each application.

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[James Kanze]

On Oct 25, 10:37*am, Juha Nieminen <nos...@thanks. invalidwrote:

James Kanze wrote:

1) Anything you can do in C, you can do in C++.

That's not true:

I didn't say "any C program is a valid C++ program". What I
said was "anything you can do in C, you can do in C++".

I'm not sure then what your point is. Both are Turing complete.
So is assembler, and Basic, and just about every other
language. What makes some people prefer C to C++ is that you
can do things in C that you can't do in C++, at the coding
level. Of course, these things are very bad software
engineering (like using a function without having declared it
first), but that's the way it is.

Sure, there are a few cases where the type system of C++ is
slightly stricter than C's (although I'm a bit surprised this
is still the case with C99), but I wouldn't say that's a very
radical difference.

The fact that you don't have to include headers to use a
function is IMHO a radical difference. I *think* this feature
was deprecated in C99; I'm not sure. But the people who prefer
C over C++ generally eschew C99 as well.

Of if I put that in other terms: If someone considered C++ to
be worse exclusively because you have to declare functions
before you use them, that would be a rather stupid and trivial
argument. When C hackers bash C++, they are not talking about
function declarations and void pointers, they are talking
about what C++ *adds* to the language that C doesn't have
(such as templates).

Have you looked at their code? I know what they say, but I also
know what they do.

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Jeff Schwab]

Juha Nieminen wrote:

Pawel_Iks 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?

I think that this is just an argument about semantics. If you say "C++
is something more than just a better C" that sentence has a positive
exalting tone to it, but if you say "C++ is nothing more than a better
C" that sentence has a belittling and unappreciating tone. In the end,
both sentences are saying the exact same thing. There's just a
difference in attitude.

Huh? "Something" != "nothing"; that's not just a different tone, it's
an altogether different meaning.

[Paavo Helde]

Juha Nieminen <no****@thanks. invalidkirjutas :

Maxim Yegorushkin wrote:

>Some actually consider C++ to be worse than C

In my personal opinion those are delusional prejudiced people who
suffer from a huge resistance of change.

The main difference IMO is that in C one has full control over the language
and does know exactly what code is generated. It is possible to gain the
about the same amount of control in C++, but it takes quite a long learning
curve to achieve. The need of control is always justified by performance
needs (either real or perceived), but I am quite sure that many people just
want to have maximum control as a rule and would prefer to code in
assembler if it was even slightly feasible. This is actually a strong point
in favor of C++, as here one can use or build much more powerful toys for
controlling the application, whereas retaining fine-grained control over
the code where needed.

In practical viewpoint, the main issue in switching from C to C++ is the
const correctness. Binding a temporary to a reference needs 'const' by the
language, and as soon as you bring one const in, it can trigger a avalanche
of needed consts all over the code base, the necessity of which is quite
difficult to explain to a seasoned C hacker.

Paavo