Question

我想其他一些人之前遇到过这个设计问题所以我希望有人可以给我一些关于该做什么的建议：我有一个应该持有私有通用对象的类。据我所知，如果不把整个班级变成模板，我就无法逃脱。精细。但是现在，有没有办法在构造期间从构造函数参数推断底层对象的类型，而没有显式指定它（我想省略模板参数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;
}

为了实现我的目标，我应该注意其他任何设计策略吗？

Answer 1

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

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）。指导原则是你应该最多说一次所需的类型名称，如果可以推断出它，则根本不说。

Answer 2

只需创建一个函数来创建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;
}

使用通用私有成员设计模板类

2 个答案: