Thread: Am I doing something wrong or does my compiler not understand this?

trying to follow this:
http://www.ddj.com/cpp/184403813

all seemed to be going fairly well, but i am afraid my compiler (BCB6) might not be so hot at template deduction.

Code:

template<typename H,typename T>struct typelist
{
    typedef H head;
    typedef T tail;
};

struct end{};
template<typename T1,typename T2,typename T3,typename T4> struct types;//i had to add this to make dr dobb's example compile at all

template<typename T> struct types<T,end,end,end>
{
    typedef typelist<T,end> type;
};

template<typename T1,typename T2>struct types<T1,T2,end,end>
{
    typedef
    typelist
    <
        T1,typelist
        <
            T2,end
        >
    >
    type;
};

template<typename T1,typename T2,typename T3>struct types<T1,T2,T3,end>
{
    typedef
    typelist
    <
        T1,typelist
        <
            T2,typelist
            <
                T3,end
            >
        >
    >
    type;
};

template<typename T1,typename T2,typename T3,typename T4>struct types<T1,T2,T3,T4>
{
    typedef
    typelist
    <
        T1,typelist
        <
            T2,typelist
            <
                T3,
                typelist
                <
                    T4,end
                >
            >
        >
    >
    type;
};

typedef types<int,char>::type intchar; // compiles until i add this line; error = 'too few arguments passed to types

typedef types<int,char,end,end>::type intchar; // this compiles but does not exactly work like a typelist :(

any ideas what gives? i don't usually second-guess my compiler, but modifying examples to make them compile makes me suspicious.

You've somewhat garbled the order and attempted to specialize something that isn't.

Soma

Code:

template<typename H,typename T>struct typelist
{
    typedef H head;
    typedef T tail;
};

struct end{};

template<typename T1,typename T2 = end,typename T3 = end,typename T4 = end>struct types
{
    typedef
    typelist
    <
        T1,typelist
        <
            T2,typelist
            <
                T3,
                typelist
                <
                    T4,end
                >
            >
        >
    >
    type;
};

template<typename T> struct types<T,end,end,end>
{
    typedef typelist<T,end> type;
};

template<typename T1,typename T2>struct types<T1,T2,end,end>
{
    typedef
    typelist
    <
        T1,typelist
        <
            T2,end
        >
    >
    type;
};

template<typename T1,typename T2,typename T3>struct types<T1,T2,T3,end>
{
    typedef
    typelist
    <
        T1,typelist
        <
            T2,typelist
            <
                T3,end
            >
        >
    >
    type;
};

typedef types<int,char>::type intchar; // compiles until i add this line; error = 'too few arguments passed to types

typedef types<int,char,end,end>::type intchar; // this compiles but does not exactly work like a typelist :(

thanks. i saw something like that in another page on the subject, but the good doctor didn't include that in his example.

can you help me understand (or point me to a better reference for) how to recursively instantiate an object based on a typelist? his visitor pattern doesn't work as provided either...

failing that, can you point me to a reference to better understand the finer rules of templates in general? there seems to be so much more to them than is in the documentation.

Code:

template<typename T>class metaObject;
template<typename H,typename T>class metaObject<types<H,T> >:
    public metaObject<T>
{
    public:
        metaObject() :
            metaObject<T>()
        {
        }
    H *h;
};

void test()
{
    metaObject< types<int,double> >o;
    o.metaObject<int>::h = 2;
}

i don't think the time required to port the code will be an allowable amount of downtime. i am the only developer at my company :\

anyway, as to the question at hand, am i doing something wrong here? it really looks like it should recurse on the tail properly as i've written it, but i am just starting to try to more fully utilize templates. as i alluded to before, sometimes the more subtle intricacies escape me.

Code:

template <class tlist> class AdHocVisitor;

template <class H, class T>
class AdHocVisitor< typelist<H, T> > 
    : public AdHocVisitor<T>
{
public:
    using AdHocVisitor<T>::Visit;
    virtual void Visit(H*) = 0;
    template <class SomeClass>
    void StartVisit(SomeClass* p)
    {
        if (H* pFound = dynamic_cast<H*>(p))
        {
            Visit(pFound);
        }
        else
        {
            AdHocVisitor<T>::StartVisit(p);
        }
    }
};

template <class H>
class AdHocVisitor< typelist<H, null_typelist> > 
{
public:
    virtual void Visit(H*) = 0;
    template <class SomeClass>
    void StartVisit(SomeClass* p)
    {
        if (H* pFound = dynamic_cast<H*>(p))
        {
            Visit(pFound);
        }
        else
        {
            throw "Unknown type passed";
        }
    }
};

i ran into exactly the same errors when i partially specialized for when tail is null_typelist (or end, as i called it above). - it said that metaObject<type> had to be a previously defined class or struct...

Code:

//---------------------------------------------------------------------------

#ifndef metaObjectH
#define metaObjectH
template<typename H,typename T>struct typelist
{
    typedef H head;
    typedef T tail;
};

struct end{};

template<typename T1,typename T2 = end,typename T3 = end,typename T4 = end>struct types
{
    typedef
    typelist
    <
        T1,typelist
        <
            T2,typelist
            <
                T3,
                typelist
                <
                    T4,end
                >
            >
        >
    >
    type;
};

template<typename T> struct types<T,end,end,end>
{
    typedef typelist<T,end> type;
};

template<typename T1,typename T2>struct types<T1,T2,end,end>
{
    typedef
    typelist
    <
        T1,typelist
        <
            T2,end
        >
    >
    type;
};

template<typename T1,typename T2,typename T3>struct types<T1,T2,T3,end>
{
    typedef
    typelist
    <
        T1,typelist
        <
            T2,typelist
            <
                T3,end
            >
        >
    >
    type;
};




template<typename T>class metaObject;
template<typename H,typename T>class metaObject< types<H,T> >:
    public metaObject<T>
{
    public:
    H *value;
};

template<typename H>class metaObject<types<H,end> >
{
    public:
    H *value;
};


void test()
{
    metaObject< types<double,int> >o;
    *o.metaObject<int>::value=2;
}
//---------------------------------------------------------------------------
#endif

Build
[C++ Error] metaObject.h(71): E2029 'metaObject<int>' must be a previously defined class or struct
[C++ Error] metaObject.h(87): E2450 Undefined structure 'metaObject<double,int>'
[C++ Error] metaObject.h(87): E2449 Size of 'o' is unknown or zero
[C++ Error] metaObject.h(87): E2450 Undefined structure 'metaObject<double,int>'
[C++ Error] metaObject.h(88): E2312 'metaObject<int>' is not an unambiguous base class of 'metaObject<double,int>'



i tried to DL VS Express, but the installer hung on me and now i have to RB to try it again

Originally Posted by m37h0d

now if i can just figure out a more elegant way of specifying where in the tail hierarchy a particular value is, i'll really have something potentially useful.

to that end, i think the implementation suggested here is a good fit. if each tier in the hierarchy can keep track of it's parent typelist, then one ought to be able to construct a template getter and setter functions where you specify the ordinal within the recurion/inheritance tree of the value you want...

there are undoubtedly many conceptual problems. the foremost being the classical problem of "an answer in search of a problem"

i am really trying to explore this area of programming and see what its capabilities are and how it might be useful. i have ideas about how things like typelists and recursive template instantiation might be useful, but i don't have enough familiarity with them to really know. i'm trying to find out!


and to answer your question:

because for the purposes of this exploratory example, i wanted o to contain a place to store an int?