2

有两种结构：

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

和一个函数

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;

}

有没有办法获得 *i_l 模板化类型（这里是双精度），即

std::list::Item type

如果不传递任何其他参数

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

test (intervals);


return 0;
}

感谢您的帮助，首选 C++ 03。

更新的问题

如果是模板化类型

std::list::Item type

表示test()的一个形参，这个解决方案

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

不起作用...出现以下错误：

error C2770: invalid explicit template argument(s)

版本

test (intervals, x);

导致另一个错误：

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

2 回答 2

4

在 C++11 中，只需使用auto：

auto val = (*il).a;

如果以后需要引用该类型，可以使用decltype(val).

在 C++03 中，您可以获得标准容器类型的基础类型L：

L::value_type

所以在你的情况下应该是：

typename List::value_type

但是，在您的情况下，这会给您 type AB，而不是AB::a. 如果您需要能够在编译时检索模板T实例的类型，则AB需要在AB. 例如：

template <typename T>
struct AB
{
    typedef T value_type;
//  ^^^^^^^^^^^^^^^^^^^^^

    T a, b;

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

然后你可以这样做：

typename List::value_type::value_type val = (*il).a;

如果你不想AB仅仅为了这个目的而改变定义，你可以定义一个单独的类型特征，例如：

template<typename T>
struct underlying_type_of;

template<typename T>
struct underlying_type_of<AB<T>>
{
    typedef T type;
};

然后，您可以获得如下所示T的基础类型：AB<T>

typename underlying_type_of<typename List::value_type>::type val = (*i_l).a;
于 2013-05-07T14:41:54.157 回答
2

如果您不使用 C++11，您可以typedef在结构中使用模板参数 T 并用于获取存储在结构 AB 中的类型：std::list::value_type

#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;
}
于 2013-05-07T14:45:17.337 回答