C++Talk.NET

Dumaiu · Guest

Hello all,

Please forgive the newbie-ish tone of this, my first thread. I'd like
to float an idea I had and see what you guys think.
I first stumbled across the Pimpl (which goes by many names, including
the most charming 'Cheshire Cat' Smile

in GotW. As I understand it, it
eliminates header recompilation but introduces memory management and
complicates inheritance.
So, a thought. It's possible, by making a C-Cat with a template
specialization technique, to bypass some of the disadvantages but
retain the Pimpl's benefit of reducing compilation time. What follows
seems pretty strange to me, so I'll err on the side of overexplaining.
Is it useful, dangerous, or am I just covering old ground?:

//> classcat.hpp
// The implementation base class, needed by the primary header
(class.hpp) and the implementation file (class.cpp).
#ifndef CLASSCAT_HPP // Inclusion guards are very important here.
#define CLASSCAT_HPP

template <class tInheritor>
class ClassCat
{
// ctor, dtor, &c should be declared here:
protected:
ClassCat(int initval);// ctor
};// ClassCat
#endif

---------------------------------------

//> class.hpp
// The header file we want to avoid recompiling.
#include "classcat.hpp"

// Public interface for inclusion by client.
class Class : protected ClassCat<Class> // Use 'private' if you don't
want subclass access to the implementation.
{
public:
Class(int initval);// ctor will chain up.

void DoSomethingUseful(); // whatever you like
... // whatever else
};// Class

---------------------------------------

//> class.cpp
// Implementation file, with all changes.
#include "classcat.hpp" // Import template declaration

class Class; // Fwd dec
// Implementation data as template specialization:
template <>
class ClassCat<Class>
{
protected:
// Inherited ctor:
ClassCat(int initval): datum(initval) {}// ctor

int datum;
};// ClassCat<>

// Method definitions:
#include "class.hpp"
#include <cstdio>

Class::Class(int initval): ClassCat<Class>(initval) {}// ctor

void Class::DoSomethingUseful()
{ printf("Print private datum: %i\n", datum); }//

---------------------------------------

//> main.cpp
// Client program.
#include "class.hpp"

int main()
{
Class c(100);
c.DoSomethingUseful(); // -> 'Print private datum: 100', peachy.
}// main()

Looks pretty nice to me--no allocation/deallocation, dereferencing, or
casts. It works by compiling class.hpp with the memberless base class,
in classcat.hpp, but links in, in "bait and switch" fashion, the full
version in class.cpp. Thus the client never needs to be recompiled.
The executable produced for this example by gcc was actually about a KB
smaller than that of one I wrote using a standard Pimpl. Unfortunately
I don't know how to benchmark speeds.
It does introduce a second header file, the classcat.hpp. I haven't
examined every detail, but I did noticed a couple of (not too alarming)
curiosities:
1) If any of the four automatically-generated methods (ctor, dtor,
.... ) is defined in class.cpp:ClassCat<Class> but not declared in
classcat.hpp:ClassCat<>, it will be silently ignored. E.g., any of
these methods not told to chain up explicitly will call an
autogenerated empty version in ClassCat<>. So class.hpp:Class must
match classcat.hpp:ClassCat<> and class.cpp:ClassCat<Class> and its
class.cpp method definitions. A bit of a pain.
2) In my version of gcc, at least, trying to inline ClassCat<Class>'s
destructor in class.cpp produces a linker error:
"undefined reference to `ClassCat<Class>::~ClassCat
[not-in-charge]()'"
Normal definition is fine.

Just a thought.

Thanks in advance,

J. J.-S.

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Valentin.Samko · Guest

Igor A. Goussarov · Guest

Hi Dumaiu,

Dumaiu wrote:
[...]

Maxim Yegorushkin · Guest

Dumaiu wrote:

[]

Dumaiu · Guest

Thank you, gentlemen. As Mr. Goussarov points out, my technique will
result in a instances of a class having different sizes between
translation units, and, as Mr. Samko points out, this is bad. Standard
3.2p5 is, indeed, the most basic of several paragraphs that I treaded
on (*How* did you know which one off the top of your head?), although
14.7.3p7 gets more expressive:

When writing a specialization, be careful about its location; or to
make it compile will be such a trial as to kindle its self-immolation.

Wow! Although I do feel disappointment, of course, I am a bit
perversely pleased that I produced such a violently ill-formed program,
and got it to run, without reinterpret_cast(). As Mr. Goussarov put
it,