Re: Add 1 more variable to print

On Apr 20, 8:21 am, Juha Nieminen <nos...@thanks.invalid> wrote:


Well, if that's the only argument against them, I guess he has
to use it:-). (I can actually think of a few better ones. I
rather like iostream, but it's not perfect.)

With regards to the size issue, of course, it depends on the
implementation. There are two reasons why I would expect the
executable size to be larger using iostream:

 -- It's templated, and it is more difficult to use dynamic
    linking where templates are involved. Of course, a good
    implementation will have explicit specializations for char
    and wchar_t, so this problem won't affect them. But Sun CC
    doesn't, and the size of the executable *is* ten times
    larger. (Sun CC's implementation of iostream is
    particularly bad. Almost a model of how not to implement
    it.)

 -- It's part of the C++ standard library, not the C standard
    library. On a lot (most?, all?) systems, the C stnadard
    library is a bundled dynamic object---it's present on all
    systems, regardless of whether a C compiler is installed or
    not. And it usually contains the system API as well, so you
    definitely want to link it dynamically. The C++ standard
    library, on the other hand, is rarely present unless you
    have a C++ compiler installed, and any version specific
    behavior will depend on the version of the compiler. So in
    no case do you want to link it dynamically---you want your
    code to run even on systems where it isn't installed, and
    you want to be sure you get the version which corresponds to
    your compiler, and not some other version.

 -- At least where I work, most programs are a little bit bigger
    than hello, world. (Say, about a million times bigger, in
    terms of number of lines.) The difference in size is
    actually an arithmetic constant. So even if I take Sun CC
    (where hello, world is 61412 with printf, 501320 with
    cout---the worst example I could find), what it really means
    isn't that iostream makes the program close to 10 times
    larger; what it means is that iostream adds about 450KB to
    your program. If I take the main application I'm working
    on, it's over 78 MB---a half a meg more or less isn't
    important. And of course, this is an extreme case. For
    most implementations, the differences are a lot less.

FWIW: I find a similar ratio in size difference between
std::vector and malloc/free, probably for the same reasons
(templates, C++ library vs. C library). Arguing against
iostream on these grounds is the same as arguing against vector,
rather than malloc/free. (Note that the argument is iostream
vs. printf. I'm sure that it's possible to design a solution
which is better than either of them, but printf is about the
worst IO system ever invented, and using it instead of iostream
is about the same as using malloc/free instead of vector.)

--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
                   Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34