C++ - Vorlagen: erhalten Art des Elements

Gibt es zwei Strukturen:

template <typename T>
struct AB
{
    T a, b;

    AB <T> ( ) : a ( 0.0 ), b ( 0.0 ) {}
};


template <typename T>
struct ABList
{
    typedef std::list < AB <T> > Type;
typedef T Type2;
};

und eine Funktion

template <typename List>
void test ( List l )
{
    List::iterator i_l = l.begin();

    //Here *i_l type is needed instead of double
    double val = (*il).a;

}

Gibt es eine Möglichkeit, wie man *i_l templatized Typ (hier double), ich.e,

std::list::Item type

ohne dabei andere parameter, wenn

int main(int argc, char* argv[])
{
ABList <double> ::Type intervals;

test (intervals);


return 0;
}

Danke für Eure Hilfe, C++ 03 ist bevorzugt.

Aktualisiert, Frage

Wenn ein templatized Typ

std::list::Item type

ist eine formale Parameter von test(), diese Lösung

template <typename List>
void test ( List l, typename List::value_type::value_type val )
{
  ...
}

int main(int argc, char* argv[])
{
ABList <double> ::Type intervals;
double x = 7.0;

test <ABList<double>> (intervals, x);

return 0;
}

funktioniert nicht... folgender Fehler tritt auf:

error C2770: invalid explicit template argument(s)

Version

test (intervals, x);

bewirkt, dass ein weiterer Fehler:

Failed to specialize function template 'void test(List,List::value_type::{ctor})'

Nicht genau sicher, was du meinst. Möchten Sie std::list::value_type.
Eine weitere Möglichkeit: schreiben Sie eigene type_traits für Sie Arten.
lösen Sie die explizite template-Argumente für die test-Funktion, versuchen Sie den Aufruf nur test(Intervalle, x) in main() und lassen Sie "template argument Abzug" finden Sie die richtige Entsprechung für die Funktion. Ich habe versucht, und es kompiliert ohne Probleme
tomislav: das auslassen einer Spezialisierung bewirkt, dass das scheitern Spezialisierung Fehler.

InformationsquelleAutor justik | 2013-05-07

c++data-structures templates types

2

Können Sie typedef dem template-parameter T in der Struktur und verwenden std::list::value_type um den Typ gespeichert, die in der Struktur AB, wenn Sie nicht mit C++11:
```
#include<list>
#include<iostream>

template <typename T>
struct AB
{
    T a, b;

    typedef T value_type;

    AB( ) 
    : 
        a (0), 
        b (0) 
    {}

};


template <typename T>
struct ABList
{
    typedef std::list < AB <T> > Type;
    typedef T Type2;
};

template <typename List>
void test ( List & l )
{
    typename List::iterator i_l = l.begin();

    typename List::value_type::value_type& Listval = i_l->a;

    std::cout << Listval << std::endl;
}

template <typename List>
void test (List l, typename List::value_type::value_type val )
{
    std::cout << "test" << std::endl;
}

int main(int argc, char* argv[])
{
    ABList <double> ::Type intervals;

    double x = 7.0;

    test(intervals, x);

    return 0;
}
```
- tomislav: Danke, aber wenn typename List::value_type::value_type Listval stellt einen formalen parameter der test-Methode, funktioniert es nicht.
- nicht sicher, ob ich bekomme, was du meinst: die formalen parameter der test-Funktion ist die Liste der template-parameter, wie lange die Liste ist STL-kompatibel sein, es wird value_type typedef in seiner öffentlichen Schnittstelle, und wenn Sie erweitern die Struktur gespeichert in der Liste das gleiche tun, ist es kein problem... oder bin ich etwas fehlt?
- tomislav: Danke für deinen Kommentar und die Hilfe, ich aktualisierte die Frage...
- tomislav: das weglassen Spezialisierung bewirkt, dass ein anderer Fehler :-(.
- Hab ich geändert, der code kompiliert auf g++ (Ubuntu 4.4.3-4ubuntu5.1) 4.4.3
- tomislav: ja, du hast Recht. Ich überprüfte g++ (OK), aber VS 2010 compiler funktioniert nicht... ich werde einen neuen thread erstellen mit dem vereinfachten Beispiel... wieder Einmal, vielen Dank für deine Hilfe.
- kein problem! 🙂
InformationsquelleAutor tmaric
3

In C++11, verwenden Sie einfach auto:
```
auto val = (*il).a;
```
Und wenn Sie brauchen, um zu finden, dass Typ später, können Sie decltype(val).

In C++03, können Sie die zugrunde liegende Typ für einen standard-container Typ L als:
```
L::value_type
```
Also in deinem Fall sollte es sein:
```
typename List::value_type
```
In deinem Fall, allerdings würde ihm der Typ AB, und nicht der Typ, der AB::a. Wenn Sie brauchen, um in der Lage abrufen, die zur compile-Zeit den Typ T für eine Instanz der AB Vorlage, die Sie benötigen, um irgendeine Art alias innerhalb AB. Zum Beispiel:
```
template <typename T>
struct AB
{
    typedef T value_type;
// ^^^^^^^^^^^^^^^^^^^^^

    T a, b;

    AB <T> ( ) : a ( 0.0 ), b ( 0.0 ) {}
};
```
Dann könnten Sie tun:
```
typename List::value_type::value_type val = (*il).a;
```
Wenn Sie nicht wollen, zu ändern, die definition von AB nur für diesen Zweck, können Sie eine separate type-Eigenschaft, wie die folgenden:
```
template<typename T>
struct underlying_type_of;

template<typename T>
struct underlying_type_of<AB<T>>
{
    typedef T type;
};
```
Könnte man dann die zugrunde liegenden Typ T von AB<T> wie unten gezeigt:
```
typename underlying_type_of<typename List::value_type>::type val = (*i_l).a;
```
InformationsquelleAutor Andy Prowl

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.