Template

[b7f7]

mal ne frage:
bei der template def hab ich nen kleines problem;

template <class Seq>

soll eigentlich vector/list/...

std::vector<double>

usw. erzeugen

nur wuerd ich gerne in der Funktion dann die Variablen Typen auch auf den zugehoerigen Datentyp setzen zB. float oder double

...ich schlaf noch....
...kann man das mal bitte nach C++ schieben?...

[HumeSikkins]

Hallo,
also ich verstehe deine Frage nicht und kann deshalb nur raten. Meinst du sowas?

template <class T>
void foo(T& cont)
{
typedef typename T::value_type value_type;
value_type d = value_type();
}

[b7f7]

eigentlich so

std::vector<T>

T d=irgendwas;

nur das ich den T parameter nicht habe weil der in nem anderen Template steckt

template <class Seq> in Seq ist der Parameter double dann drin
und so muss dass in der CompileTime bestimmt werden

[HumeSikkins]

b7f7 schrieb:

eigentlich so

std::vector<T>

T d=irgendwas;

nur das ich den T parameter nicht habe weil der in nem anderen Template steckt

template <class Seq> in Seq ist der Parameter double dann drin
und so muss dass in der CompileTime bestimmt werden

Und was bitte ist genau der Unterschied zu meinem Beispiel? Das wird alles zur Compilzeit bestimmt und macht genau das, was du scheinbar haben willst. Nämlich den Elementtyp des Containers bestimmen und einer Variable von diesem Typ anlegen.

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

[;o)]

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