Template

Helium

Ich vermute, was er meint ist: Er will ein Template an die Funktion übergeben, dass er dann selbst mit einem beliebigen Typ instanzieren kann.

HumeSikkins

Helium schrieb:

Ich vermute, was er meint ist: Er will ein Template an die Funktion übergeben, dass er dann selbst mit einem beliebigen Typ instanzieren kann.

Ich sehe zwar nirgends einen Hinweis darauf, aber in diesem Fall wären Template-Template-Parameter die einzige, wenn auch nicht portable, Rettung.

Bei eigenen Containern könnte man noch den Rebind-Trick verwenden:

template <class T> 
void foo(T& cont) 
{ 
    typename T::template Rebind<double>::Result TwithDouble;
    typename T::template Rebind<int>::Result TwithInt;
}

template <class T> 
class MyContainer
{
public:
    template <class U> 
    struct Rebind
    {
        typedef MyContainer<U> Result;
    };
    //...
};
int main()
{
    MyContainer<float> c;
    foo(c);
}

b7f7

hm
ich will einer funktion einen
std::vector<double> oder std::list<double> usw. als template geben

template <class Seq>
void fun(Seq& blah)
{
...
return (ValType) Res; 
// dieser ValType soll abhaengigsein vom Templateparameter 
// des Vektors oder der liste, sind sie double soll er double sein
// sind sie float soll er float sein
}

Bashar

wie wärs mit Seq::value_type

b7f7

Yo das waers danke.

HumeSikkins

Bashar schrieb:

wie wärs mit Seq::value_type

b7f7 schrieb:

Yo das waers danke.

Na wenn ich mich verarschen wollt, sagt doch bitte vorher bescheid. Dann spare ich mir das antworten.

Bashar

Hume: Sorry, ich hab den Thread nicht gelesen, nur daraus, dass die Frage immer noch unbeantwortet war, geschlossen, dass die richtige Antwort noch nicht kam.

HumeSikkins

@Bashar
Kein Problem. Meine Antwort bezog sich a) mehr b7f7 und b) fehlte ihr auch ein Smiley zum Auflockern.

b7f7

@HumeSikkins
ich wollt dich sicher nicht veralbern, aber ich must mir selbst erst klar darueber werden wie ich das am ende fuer mich passend hinbiege.

b7f7

hm...

wie mach ich das nun bei

std::vector<std::vector<double> > ?

template <class Seq>
Seq::value_type foo(const Seq &P)
{
  return *(P.begin());
}
std::vector<double> Vec=fill();
double d=foo(Vec);

// so geht das aber
template <class Seq>
Seq::value_type::value_type foo(const Seq &P)
{
  return *(P.begin()->begin());
}
std::vector<std::vector<double> > Vec2=fill();
double d=foo(Vec2);
// das kann er nicht herleiten
// wie hangele ich mich dadurch?
// Seq::value_type ist doch std::vector<double> ?

Helium

erstens stat deiner wirren verschachtelung von begin()s und dereferenzierungen solltest du einfach auf front() zurückgreifen.

zweitens fehlt da IMHO typenname.

zeronull

Für Elementtypen die sich zb via Boost.TypeTraits filtern lassen ist folgendes möglich

#include <boost/mpl/identity.hpp>
#include <boost/mpl/if.hpp>
#include <boost/type_traits/is_fundamental.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/static_assert.hpp>
#include <vector>

namespace mpl = boost::mpl;

template <class Cont>
struct element_type {
    typedef typename Cont::value_type type;
};

template <typename T, template <typename> class Condition = boost::is_fundamental>
struct get_value_type {
    typedef typename mpl::if_<Condition<T>, 
                              mpl::identity<T>, 
                              element_type<T>
                             >::type sub_type;

    typedef typename mpl::if_c<Condition<typename sub_type::type>::value,
                               typename sub_type::type,
                               typename get_value_type<typename sub_type::type, Condition>::sub_type::type
                              >::type type;
};

int main() {
    typedef std::vector<std::vector<int> > vec;
    BOOST_STATIC_ASSERT((boost::is_same<get_value_type<vec>::type, int>::value));
}