Re: type traits and element specific functions: design problem

From:

"Greg Herlihy" <greghe@pacbell.net>

Newsgroups:

comp.lang.c++.moderated

Date:

17 Oct 2006 14:36:13 -0400

Message-ID:

<1161108015.811307.70330@f16g2000cwb.googlegroups.com>

Andy wrote:

I am posting below some dummy code which defines a traits template
class and adds a singe typedef. The typedef refers to some defined
class in the progam - I have defined a few dummy classes for that
purpose. Sorry for using the macro to generate code for the dummy
classes.

I compile this code using:
// --- code start --- file: trait_exesize.cpp --- //

#include <iostream>

#define dummy_class(class_name) struct class_name \ {\
        class_name::class_name(){\
                std::cout << #class_name" constructed"
<< std::endl;\
        }\
\
        class_name::~class_name(){\
                std::cout << #class_name" destructed"
<< std::endl;\
        }\
}

dummy_class(A);
dummy_class(B);
dummy_class(C);
dummy_class(D);
dummy_class(E);
dummy_class(F);

template <int DLG_ID> struct dialog_traits {
        typedef int val_t;
};

template <>
struct dialog_traits<1>
{
        typedef A val_t;
};

...

int main()
{
        /**/dialog_traits<1>::val_t a;
        dialog_traits<2>::val_t b;
        dialog_traits<3>::val_t c;
        dialog_traits<4>::val_t d;
        dialog_traits<5>::val_t e;
        dialog_traits<6>::val_t f;
        dialog_traits<7>::val_t g;
        dialog_traits<8>::val_t h;
        dialog_traits<9>::val_t i;
        dialog_traits<10>::val_t j;
        dialog_traits<11>::val_t k;
        dialog_traits<12>::val_t l;/**/

        return 0;
}

It's the object allocations of variables a-l that require both storage
and code. So eliminating dialog_traits does not make the program any
smaller. In other words, a program with this main() routine:

    int main()
    {
        A a;
        B b;
        C c;
        D d;
        E e;
        F f;
        A g;
        B h;
        C i;
        D j;
        E k;
        F l;
    }

produces an identical program. So the dialog_traits class template
(being effectively a typedef) adds no overhead to this sample program.

The more pertinent issue is why allocate two objects of each class A-F?
These classes really should be implemented singletons (or as some kind
of namespace-scope function) if redundant overhead is to be eliminated.

Greg

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