0

我想其他人之前遇到过这个设计问题，所以我希望有人能给我一些建议：我有一个应该持有私有通用对象的类。据我所知，如果不将整个班级设为模板，我就无法逃脱。美好的。但是现在，有没有办法在构造过程中从构造函数参数推断底层对象的类型，而不显式指定它（我想省略模板参数Derived，当我实例化Test类时）：

#include <iostream>

template <typename T>
class Generic
{
};

class Derived : public Generic<int>
{
public:
    Derived ();
    int GetFoo ();
private:
    int m_foo;
};

template <typename T>
class Test
{
public:
    Test (T &underlying);
private:
    T m_underlying;
};

Derived::Derived ()
{
    this->m_foo = 666;
}

int Derived::GetFoo ()
{
    return this->m_foo;
}

template<typename T>
Test<T>::Test (T &underlying) : m_underlying(underlying)
{
    std::cout << this->m_underlying.GetFoo() << std::endl;
}

int main ()
{
    Derived underlying;
    Test<Derived> test(underlying);

    return 0;
}

为了实现我的目标，我还应该了解其他设计策略吗？

4

2 回答 2

4

通常你有一个类模板和一个类型推导函数模板：

template <typename T>
struct Foo
{
    Foo(T const &);
};

template <typename T>
Foo<T> make_foo(T const & t)
{
    return Foo<T>(t);
}

用法：

auto foo = make_foo(1728);   // makes a Foo<int>

这个想法在标准库中被无数次使用（例如make_pair, make_tuple, make_shared）。指导原则是您应该最多说出一次所需的类型名，如果可以推断出来，则根本不说。

于 2012-11-15T19:46:46.080 回答
3

只需创建一个函数来创建Test对象：

template <typename T> 
Test<T> make_test(T& underlying)
{
    return Test<T>(underlying);
}

int main ()
{
    Derived underlying;
    auto test = make_test(underlying);

    return 0;
}
于 2012-11-15T19:47:18.887 回答