Things I hate about C++

[JKop]

Okay here we go, I feel it's about time people conversed about the bullshit
aspects of C++ (including the bullshit stuff brought forward from C). I'll
begin with a few of my own grievances:
1) The whole "function declaration Vs object definition" fiasco, which
results in the following (temporary creating) syntax:

Blah poo = Blah();
2) How string literals are not const (even though they are!), for instance:

void Blah(char* const p_k)
{
*p_k = '4'; //Opps!
}

int main()
{
Blah("Hello");
}
3) How arrays decay to pointers...
The following is possible:

unsigned &r = *new unsigned;
But the following is not:

unsigned (&r)[10] = *new unsigned[10];

That's all I can think of right now!
-JKop

[Phlip]

JKop wrote:

Okay here we go, I feel it's about time people conversed about the bullshit aspects of C++ (including the bullshit stuff brought forward from C). I'll
begin with a few of my own grievances:
Oh, dear. You have not shown much promise respecting C++, yet you want C++
to respect you.
1) The whole "function declaration Vs object definition" fiasco, which
results in the following (temporary creating) syntax:

Blah poo = Blah();
A> you don't need to do that.

B> the compiler can optimize the temporary away

C> the compiler cannot optimize the = away, so if it's
private that should not compile outside Blah's
internal scope.
2) How string literals are not const (even though they are!), for instance:
void Blah(char* const p_k)
{
*p_k = '4'; //Opps!
}

int main()
{
Blah("Hello");
}
That's to avoid breaking poor quality C code (like I used to write).
3) How arrays decay to pointers...
The following is possible:

unsigned &r = *new unsigned;
But the following is not:

unsigned (&r)[10] = *new unsigned[10];
Acolyte of the Week question:

What's this for?

template<class foo, size_t max>
inline size_t
get_count(foo const (&array)[max])
{
return max;
}

Where can you use it? Where can't you use it? How can you improve it?
That's all I can think of right now!

There are plenty of serious issues beyond these things that one could 'lint'
away.

For example, the 'new' you wrote will leak.

(I know I know - the OS Memory Fairy will clean it up...)

--
Phlip
http://industrialxp.org/community/bi...UserInterfaces

[Alf P. Steinbach]

* JKop:

1) The whole "function declaration Vs object definition" fiasco, which
results in the following (temporary creating) syntax:

Blah poo = Blah();
A good compiler will not create a temporary here, but you're right: the
C syntax is a fiasco, and IIRC acknowledged as such by the creators.

2) How string literals are not const (even though they are!),
Right. That's old C compatibility for you.

for instance:

void Blah(char* const p_k)
{
*p_k = '4'; //Opps!
}

int main()
{
Blah("Hello");
}
Incorrect. The argument of function Blah should be

void Blah( char const* p_k )

for the intended const'ness effect.
3) How arrays decay to pointers...
The following is possible:

unsigned &r = *new unsigned;
But the following is not:

unsigned (&r)[10] = *new unsigned[10];
A better (or worse!) example is perhaps
typedef unsigned UnsignedArray[10];

UnsignedArray &r = *(new UnsignedArray);
Again, that's the C heritage.

That's all I can think of right now!

Uhm, well, there's much more. That's the price for compatibility.
Without the compatibility I doubt that C++ would have been very
successful.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[JKop]

Oh, dear. You have not shown much promise respecting C++, yet you want
C++ to respect you.
I neither give respect to, nor wish to receive respect from, what does not
qualify as an organism.

1) The whole "function declaration Vs object definition" fiasco, which
results in the following (temporary creating) syntax:

Blah poo = Blah();

A> you don't need to do that.

No comment. No, actually, comment: Bullshit.

B> the compiler can optimize the temporary away

The compiler *may* optimize the temporary away.

C> the compiler cannot optimize the = away, so if it's
private that should not compile outside Blah's
internal scope.

If "what" is private? I presume you're on about the copy contructor.

If you're referring to "=", as in the assignment operator, then don't
respond.

2) How string literals are not const (even though they are!), for
instance:

void Blah(char* const p_k)
{
*p_k = '4'; //Opps!
}

int main()
{
Blah("Hello"); }

That's to avoid breaking poor quality C code (like I used to write).

.. . .and this makes it non-bullshit because?

For example, the 'new' you wrote will leak.

Please don't be stupid. I also didn't mention in my last post that I'd drunk
water in the last 3 days. Does that mean I'm on my way out soon?
-JKop

[JKop]

void Blah(char* const p_k)
{
*p_k = '4'; //Opps!
}

int main()
{
Blah("Hello"); }

Incorrect. The argument of function Blah should be

void Blah( char const* p_k )

for the intended const'ness effect.

You misinterpreted my intention. Here's what I'm doing:
void Blah(char* p_k)
{
*p_k = '4';
}

int main()
{
Blah("Hello");
}
The only reason I put:

void Blah(char* const p_k);
in my previous post is that I put in "const" wherever I can.
Regarding:
char* const p_k
The variable itself is "const", (my function may not and does not change
it), but what it points to is "non-const", (my function is free to change it
if it wishes... and it does!). The thing here is that while "Hello" is in
essence const, it still gets passed as a non-const argument.

So, in summation:

"Hello"

It's type is "char[6]". Note the absence of "const".

While contradictorily (...need me a dictionary...)

char* p = "Hello";

*p = '4';
-JKop

[JKop]

Any thoughts on why the following is illegal?:
struct Blah
{
int a;
char b;

double* p_c;
};
int main()
{
double r;

Blah* p_poo =

new Blah = {5, 't', &r};
}
-JKop

[Richard Herring]

In message <uy************ *******@news.in digo.ie>, JKop <NU**@NULL.NULL >
writes

1) The whole "function declaration Vs object definition" fiasco, which
results in the following (temporary creating) syntax:

Blah poo = Blah();

A> you don't need to do that.

No comment. No, actually, comment: Bullshit.

B> the compiler can optimize the temporary away

The compiler *may* optimize the temporary away.

If you're really so concerned about this non-issue, why not just give
your class a constructor that takes a (dummy) argument? Then you can
just write

Blah foo(99);

and all your problems are over.

--
Richard Herring

[JKop]

B> the compiler can optimize the temporary away

The compiler *may* optimize the temporary away.

If you're really so concerned about this non-issue, why not just give
your class a constructor that takes a (dummy) argument? Then you can
just write

Blah foo(99);

and all your problems are over.

I want to be able to define a value-intialized object of *any* type.
AnyTypeUnderThe Moon poo = AnyTypeUnderThe Moon();
achieves this. But there's two problems:
A) A temporary.

B) The copy constructor may be private.
Then comes the argument: If the copy constructor is private, then there's a
constructor defined and so it's not a POD and so it doesn't matter if you
value initialize or not. But I want a universal syntax, such that the
following template will work with ALL types. It's not much to ask...

template<class T>
void GiveMeAnyType()
{
T t = T();
}
int main()
{
GiveMeAnyType<s td::ostringstre am>();
}
Compile error: Copy constructor is private.

-JKop

[JKop]

template<class T>
void GiveMeAnyType()
{
T t = T();
}
int main()
{
GiveMeAnyType<s td::ostringstre am>();
}
Compile error: Copy constructor is private.

So far I have the following work-arounds:
Work-around 1:

template<class T>
void GiveMeAnyType()
{
T const &t = T();
}

Problem: It has to be const.
Work-around 2:

template<class T>
void GiveMeAnyType()
{
T &t = *new T();

delete &t;
}

Problem: I'm not sure if there's an efficiency or performance issue.

-JKop

[Richard Herring]

In message <vm************ *******@news.in digo.ie>, JKop <NU**@NULL.NULL >
writes

B> the compiler can optimize the temporary away

The compiler *may* optimize the temporary away.
If you're really so concerned about this non-issue, why not just give
your class a constructor that takes a (dummy) argument? Then you can
just write

Blah foo(99);

and all your problems are over.

I want to be able to define a value-intialized object of *any* type.

AnyTypeUnderTh eMoon poo = AnyTypeUnderThe Moon();
achieves this.

Ah. Now I see the problem - it isn't "your" class at all.
But there's two problems:

A) A temporary.

B) The copy constructor may be private.
Then comes the argument: If the copy constructor is private, then there's a
constructor defined and so it's not a POD and so it doesn't matter if you
value initialize or not. But I want a universal syntax, such that the
following template will work with ALL types. It's not much to ask...

Take a look at boost::type_tra its. It may not do exactly what you
require, but some work on those lines may yield what you need -
something on the lines of

#if hypothetical::h as_public_copy_ ctor<T>::value
T t = T();
#else
T t;
#endif

maybe?
--
Richard Herring