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;
}

---

How about getting a new compiler? Visual Studio Express is free, and so is Code::Blocks with MinGW.

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.

Where in the article did you even find this example? The link you posted does not contain anything resembling it.

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...

metaObject?

Can you post a complete code snippet that exhibits the error? That I can test on a different compiler.

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 :rolleyes:

Code:

---

template<typename T>class metaObject;

---

This is a forward declaration, not a definition. As thus, the class does not exist; you are merely telling the compiler that it does exist, which in reality, it does not.

Code:

---

template<typename T>class metaObject { };

---

This should fix the error, I think, or at least one of them, but begin with that.

not bad! i had to make this slight modification:

Code:

---

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

---

to do what i wanted, but yes, this solved the errors.

i can now do the following:

Code:

---


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

---

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.

Quote:

---

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...

Why do you instantiate metaObject<int>?

Elysia is trying to cure the symptoms, but I really think there's a conceptual problem here.

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?

Oh, so you were looking to set the value of the metaObject<int> subobject of the combined o object?
You were looking for metaObject< types<int, end> >.

yes, but the specialization never resolves to the case where tail is of type end; like it's allegedly supposed to as per dr. dobb's example. it always resolves to this:

Code:

---

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

---

instead of the partial specialization where tail is end.

Quote:

---

yes, but the specialization never resolves to the case where tail is of type end;

---

What do you mean? If you remove the reference to metaObject<int> and remove the definition of the unspecialized metaObject again, what happens?

assuming i'm understanding you correctly - nothing happens. it's exactly the same as before. if i change the name of the unspecialized value to something else, surely enough, that is the variable stored in o.

consider:

Code:

---


template<typename H>class metaObject
{
    public:
    H* shouldNotGetHere;
};

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

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

void test()
{
    metaObject<types<int,double> >o;
    o.shouldNotGetHere;
    o.tailValue;
}

---

am i correct? i appreciate the value of the socratic method (and i hope you're being socratic with me), but i've been thinking about this for a while and i just don't get it.

aah the problem is that it just isn't recursing; adding 3 types yields metaObject<types<t1,t2,t3> >

sweet - i got an implementation basically working :)

Code:

---

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

#ifndef typelistH
#define typelistH



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;
};
#endif

---

Code:

---

#ifndef metaObjectH
#define metaObjectH
#include "typelist.h"


template<typename T>class metaObject
{
    public:
        metaObject()
        {
        }
        T* value;
};

template<typename H,typename T>class metaObject< typelist<H,T> >:
    public metaObject<H>,
    public metaObject<T>
{
    public:
        metaObject():
            metaObject<H>(),
            metaObject<T>()
        {
        }
};
template<typename H>class metaObject< typelist<H,end> > :
    public metaObject<H>
{
    public:
        metaObject():
            metaObject<H>()
        {
        }
};

template<>class metaObject< end >
{
    public:
        metaObject()
        {
        }
};


void test()
{
    metaObject< types<int,double>::type >o1;
    metaObject< types<int,double,char>::type >o2;
}

//---------------------------------------------------------------------------
#endif

---

edit: crap i take it back - it now works with 3 types, but cannot deduce which specialization to use with 2... bleah

edit2: changed the typelist definition back to be non-recursive and now the compiler can deduce properly.

hmm...using multiple inheritance like above provides a nice clean interface to metaobject, in that you don't have to specify the entire child typelist to access it, but you can only have any 1 type appear in the list only once, unless you nest it within another metaobject as part of the typelist.

however, having access to the complete child typelist might make it easier to access members by an index...

hmm indeed. any thoughts?

You could look at the source code of Boost.Tuple.

well, i didn't look at tuple, but i looked at function. i didn't know you could use the elipsis in a template declaration! this is getting very interesting :)

Huh? You can't. Not yet. Variadic templates are a C++0x feature.

http://www.boost.org/doc/libs/1_37_0...t.function_hpp

darn. oh well. definitely sounds like a reason to upgrade my compiler.

Quote:

---

Originally Posted by m37h0d

definitely sounds like a reason to upgrade my compiler.

---

hmm... MSVC10 will not support variadic templates, but maybe some new version of g++ supports that feature (or will soon support it).

Sorry, but the page you linked to is illustrative for humans. It is not the actual source. You'll have to go deeper into the source and find the actual definitions to see how they do it.

Edit: I'm fairly certain that support for variadic templates have been in the repository for GCC for a long time. There is at least some support in the GCC 4.4 build I have installed.

Soma

I think even GCC 4.3 has some support for them.

The ellipsis syntax in the documentation of Boost.Function is just convenience for the reader, by the way. The actual code looks ... a little different. It simulates variadic templates (up to 50 arguments) via the very powerful Boost.Preprocessor library. Powerful, but the syntax is a nightmare.

Quote:

---

Powerful, but the syntax is a nightmare.

---

^_^

I hereby award you the "Understated Certificate of Understatement".

Soma

Quote:

---

Originally Posted by laserlight

hmm... MSVC10 will not support variadic templates, but maybe some new version of g++ supports that feature (or will soon support it).

---

There is no word yet that it supports it, true, but neither is it feature complete yet (and they did say it was probably going to get some more functions before the public release).
So atm, no it doesn't support them, but hold your breath - perhaps the final version does.

Quote:

---

Originally Posted by Elysia

There is no word yet that it supports it, true, but neither is it feature complete yet (and they did say it was probably going to get some more functions before the public release).
So atm, no it doesn't support them, but hold your breath - perhaps the final version does.

---

I will not be holding my breath. Read Jonathan Caves' (joncaves) reply in C++0x language feature checklist.

That is pretty disappointing. So few features implemented. I will still hold my breath that they change their minds.
Multitasking - maybe? It's one of the big things they're touting in this release...

This is not about changing their minds, it's about keeping a schedule.

I know that -_-
What I mean is schedules can change.
Example, features can be dropped, added or changed.

Ah, but that's generally a marketing decision. Especially in a company as big as MS.

Ya, so if enough decides they want other features (especially companies), Microsoft will scramble to comply. So that's why I can hope. Or we can hope ;)

Quote:

---

Originally Posted by Elysia

Ya, so if enough decides they want other features (especially companies), Microsoft will scramble to comply. So that's why I can hope. Or we can hope

---

Yes, we can hope :)

Quote:

---

Originally Posted by joncaves

We will add more C++-0x features in the future - but what and when is currently unknown: it all depends on user feedback.

---

I guess my own pet missing features would be nullptr, template typedefs and explicit conversion functions. Oh, and maybe concepts and the range based for loop, but perhaps introducing concepts is a more far reaching change than the three that I listed.

I wanted to see nullptr, explicit conversion functions, concepts and strongly typed enums... At least. Oh and the new string literals.

i think i am approaching something interesting

this all works quite nicely imo:

Code:

---

//metaObject.h
#ifndef metaObjectH
#define metaObjectH
#include <vector>
#include "tmember.h"

class member;
class metaObject
{
    friend class member;
    private:
        std::vector<member*>members;
    public:
        template<typename H,typename T>metaObject(typelist<H,T> t)
        {
            tmembers<typelist<H,T> >(*this);
        }
        template<typename T> void get(unsigned int index,T& lvalue)
        {
            tmembers<T>* tm =static_cast<tmembers<T> *>(members[index]);
            lvalue = *tm->value;
        }
        template<typename T> void set(unsigned int index,T* rvalue)
        {
            tmembers<T>* tm =static_cast<tmembers<T> *>(members[index]);
            tm->value=rvalue;
        }

};



//---------------------------------------------------------------------------
#endif

---

Code:

---

//tmember.h

#ifndef tmemberH
#define tmemberH
#include "member.h"
#include "typelist.h"

template<typename T>class tmembers : public member
{
    friend class metaObject;
    protected:
        tmembers(metaObject& obj):
            member(obj)
        {
        }
        tmembers(){}
        T* value;
};

template<typename H,typename T>class tmembers< typelist<H,T> >:
    public virtual tmembers<H>,
    public virtual tmembers<T>
{
    friend class metaObject;
    protected:
        tmembers(metaObject &obj):
            member(obj),
            tmembers<H>(obj),
            tmembers<T>(obj)
        {
        }
};
template<typename H>class tmembers< typelist<H,end> > :
    public virtual member,
    public virtual tmembers<H>
{
    friend class metaObject;
    protected:
        tmembers(metaObject &obj):
            tmembers<H>(obj)
        {
        }
        tmembers(){}
};

template<>class tmembers< end >
{
    friend class metaObject;
    protected:
        tmembers()
        {
        }
};

//---------------------------------------------------------------------------
#endif

---

Code:

---

//member.h

#ifndef memberH
#define memberH
//---------------------------------------------------------------------------
class metaObject;
class member
{
    protected:
    member(metaObject &obj);
    member(){};
};

#endif

---

Code:

---

//member.cpp

#include "metaObject.h"
#pragma hdrstop

#include "member.h"

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

member::member(metaObject &obj)
{
    obj.members.push_back(this);
}

---

Code:

---

#include "metaObject.h"
int main(int argc, char* argv[])
{
    metaObject *o = new metaObject(types<int,double,char>::type());
    int *d=new int(1);
    int d2(0);
    o->set(1,d);
    o->get(1,d2);
    *d=0;
    o->get(1,d2);

    return 0;
}

---

if you try to get or set with an incompatible type, you get a compile time error.

however, what i really wanted to do was this:

Code:

---


class member;
class metaObject
{
    friend class member;
    private:
        std::vector<member*>members;
    public:
        template<typename H,typename T>metaObject(typelist<H,T> t,...)
        {
            va_list ap;
            tmembers<typelist<H,T> >(*this,ap);
            va_end(ap);
        }
        template<typename T> void get(unsigned int index,T& lvalue)
        {
            tmembers<T>* tm =static_cast<tmembers<T> *>(members[index]);
            lvalue = *tm->value;
        }
        template<typename T> void set(unsigned int index,T* rvalue)
        {
            tmembers<T>* tm =static_cast<tmembers<T> *>(members[index]);
            tm->value=rvalue;
        }

};

...

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

#ifndef tmemberH
#define tmemberH
#include <stdarg>
#include "member.h"
#include "typelist.h"

template<typename T>class tmembers : public member
{
    friend class metaObject;
    protected:
        tmembers(metaObject& obj,va_list ap):
            member(obj),
            value(va_arg(ap,T))
        {
        }
        tmembers(){}
        T value;
};

template<typename H,typename T>class tmembers< typelist<H,T> >:
    public virtual tmembers<H>,
    public virtual tmembers<T>
{
    friend class metaObject;
    protected:
        tmembers(metaObject& obj,va_list ap):
            member(obj),
            tmembers<H>(obj,ap),
            tmembers<T>(obj,ap)
        {
        }
};

template<typename H>class tmembers< typelist<H,end> > :
    public virtual member,
    public virtual tmembers<H>
{
    friend class metaObject;
    protected:
        tmembers(metaObject& obj,va_list ap):
            member(obj),
            tmembers<H>(obj,ap)
        {
        }
        tmembers(){}
};

template<>class tmembers< end >
{
    friend class metaObject;
    protected:
        tmembers()
        {
        }
};

//---------------------------------------------------------------------------
#endif

---

however, this:

Code:

---

metaObject *o = new metaObject(types<int,double,char>::type(),1,1.234,'a');

---

begets this:

[C++ Error] Unit1.cpp(11): E2285 Could not find a match for 'metaObject::metaObject(typelist<int,typelist<doub le,typelist<char,end> > >,int,double,char)'

is the only other alternative to instantiate the variables inside types?