>Why not the ISO's classes?
Anthony,
I don't know them, so it's a omission due to my uninformed state. But
since C is basically an ANSI standard, it makes sense to use the
accompanying stuff. Except if we can make sure it's available on all other
platforms for most compilers and it's better than the ANSI ones. Of course,
if we use wx, we should just use wxString.
>I think we'd best find out from people who speak the other languages. But
>more importantly, lingual hacks are no basis for a system of sound error
>messages!
Well, for German, English and French it works. Anyone on the list have
info about other languages?
>Hmmm... I think we're looking for "[s]printf".
Whatever.
>Aha! You need better books!
Been saying that for years but you never sent me one :->
>I normally seperate them by use -- e.g, i'd put all the "valid"'s in OTVar
>together. I may not of, though.
re-phrase?
>The lack of one is not a missing constructor call; it is merely an implicit
>call to the default constructor. I should of been more clear. It's the only
>way to call a non-default constructor for a class within a class. BTW: If
>there is no default constructor, one gets an error if one does not use this.
I was talking about constructors of classes we inherit from.
>No. I fail to see any good reason to distinguish between a class and a
>built-in type. Other than the obvoius and necissary differences (one is
>real, on is not), there should nto be a difference between Complex<double>
>and double. And usually, C++ is good at seeing to this -- why else would we
>have overloaded operators, standard I/O functions for every type (<< and
>>>), etc.?
You misunderstood me. Here's an illustration:
class Jeff : public Pete, Samantha
{
bool mIsCool
Jeff(p1, p2)
: Pete(p1), Samantha(p2),
mIsCool(TRUE)
{
// foo.
};
};
See, I'm asking you to separate mIsCool from Pete and Samantha, because
mIsCool is a constructor for a member variable but Pete and Samantha are
constructors for classes we inherit from. Since one can get many errors
from missing constructor calls (which you're not necessarily informed
about), we need to see in one swoop what inherited constructors we're
calling and which are missing, while the member constructors shouldn't be
on the same line so we don't mix up things.
It's one of those safety mechanisms that are there solely to ensure the
stupidest mistakes are the easiest to find.
Cheers,
-- M. Uli Kusterer
------------------------------------------------------------
http://www.weblayout.com/witness
'The Witnesses of TeachText are everywhere...'
--- HELP SAVE HYPERCARD: ---
Details at: http://www.hyperactivesw.com/SaveHC.html
Sign: http://www.giguere.uqam.ca/petition/hcpetition.html
