c++ - 如何修复 pimpl 实现中预期的主表达式编译错误？

Question

背景

我有两个 coord_t 的实现

1. simp_t简单地存储 x,y
2. dep_t这需要一个受抚养的 parent coord_t并为其添加一个偏移量

这些是较低级别的实现类。在用户级别，用法应如下所示:

coordinate_t<>  ts( 3, 5 );
coordinate_t<>  ts_derived( ts, 9 );  // ts + { 9, 9 }

问题

如果我使用 std::unique_ptr<> 实现底层，我就有了工作代码.但是，当我尝试将实现转换为 pimpl<> 时, 我在 g++ (Ubuntu/Linaro 4.7.3-1ubuntu1) 4.7.3 上得到以下编译错误:

junk.cpp: In constructor ‘coordinate_t<T>::coordinate_t(T, T)’:
junk.cpp:54:47: error: expected primary-expression before ‘>’ token
junk.cpp: In constructor ‘coordinate_t<T>::coordinate_t(const coordinate_t<T>&, const T&)’:
junk.cpp:58:46: error: expected primary-expression before ‘>’ token

我做错了什么，我该如何解决才能正确构建？

代码

代码按原样无法编译，但如果您注释掉 #define USE_PIMPL使用 std::unique_ptr<>相反，它编译得很好。

#include <memory>

template<typename T>
class pimpl
{
        std::unique_ptr<T> m_up;

public:
        pimpl() { }
        template<typename ...Args> pimpl( Args&& ...args )
                : m_up{ new T{ std::forward<Args>(args)... } } { }

        template<typename D,typename ...Args>
        static pimpl<T> Derived( Args&& ...args )
        {
                pimpl<T> x;
                x.m.reset( new D{ std::forward<Args>(args)... } );
                return x;
        }

        ~pimpl() { }
};

template<typename T>
struct coord_t { };

template<typename T>
struct simp_t : public coord_t<T>
{
        T  m_x, m_y;
        simp_t( T x, T y ) : m_x( x ), m_y( y ) { }
};

template<typename T>
struct dep_t : public coord_t<T>
{
        using parent_t = coord_t<T>;
        parent_t const&  m_parent;
        T                m_offset;
        dep_t( parent_t const& p, T offset ) : m_parent( p ), m_offset( offset )
        { }
};

#define USE_PIMPL    // if we comment this out and USE_UNIQUE_PTR, it works ok

#ifdef USE_PIMPL
template<typename T=int>
class coordinate_t
{
        pimpl<coord_t<T>>  m_impl;

        public:
                coordinate_t( T x, T y ) :
                        m_impl( pimpl<coord_t<T>>::Derived<simp_t<T>>( x, y )) // ERROR HERE
                {
                }
                coordinate_t( coordinate_t<T> const& parent, T const& offset ) :
                        m_impl( pimpl<coord_t<T>>::Derived<dep_t<T>>( parent, offset )) // ERROR HERE
                {
                }
                ~coordinate_t() { }
};
#else
template<typename T=int>
class coordinate_t
{
        std::unique_ptr<coord_t<T>>  m_impl;

        public:
                coordinate_t( T x, T y ) :
                        m_impl{ new simp_t<T>( x, y ) }
                {
                }
                coordinate_t( coordinate_t<T> const& parent, T const& offset ) :
                        m_impl{ new dep_t<T>( *parent.m_impl, offset ) }
                {
                }
                ~coordinate_t() { }
};
#endif

int main()
{
        coordinate_t<>  ts( 3, 5 );
        coordinate_t<>  ts_derived( ts, 9 );  // ts + { 9, 9 }
}

Answer 1

解决方案

juanchopanza 是对的:问题是，在调用函数模板 Derived 之前我需要一个 template 关键字在类模板中。

修复/修改

1. 添加了template关键字来帮助编译器
2. 因为类模板pimpl<>包含 std::unique_ptr<>成员，它需要一个移动构造函数，否则您将无法从函数返回一个实例
3. 我在 pimpl<> 中添加了便利运算符所以它看起来更像是 std::unique_ptr<>从用户的角度来看
4. 修复了 m 中成员错误命名中的愚蠢重构错误至 m_up在pimpl<>
5. 为清晰起见，删除非 pimpl 代码

工作代码

template<typename T>
class pimpl
{
        std::unique_ptr<T> m_up;

public:
        pimpl() { }
        pimpl( pimpl&& rhs ) : m_up( std::move( rhs.m_up )) { }

        template<typename ...Args>
        pimpl( Args&& ...args )
                : m_up{ new T{ std::forward<Args>(args)... } } { }

        template<typename D,typename ...Args>
        static pimpl<T> Derived( Args&& ...args )
        {
                pimpl<T> x;
                x.m_up.reset( new D{ std::forward<Args>(args)... } );
                return x;
        }

        ~pimpl() { }

        T* operator->() { return m_up.get(); }
        T& operator*() { return *m_up.get(); }
        T const* operator->() const { return m_up.get(); }
        T const& operator*() const { return *m_up.get(); }
};

template<typename T>
struct coord_t
{
};

template<typename T>
struct simp_t : public coord_t<T>
{
        T  m_x, m_y;
        simp_t( T x, T y ) : m_x( x ), m_y( y ) { }
};

template<typename T>
struct dep_t : public coord_t<T>
{
        using parent_t = coord_t<T>;
        parent_t const&  m_parent;
        T                m_offset;
        dep_t( parent_t const& p, T offset ) : m_parent( p ), m_offset( offset )
        { }
};

template<typename T=int>
class coordinate_t
{
        pimpl<coord_t<T>>  m_impl;

        using my_simp_t  = simp_t<T>;
        using my_dep_t   = dep_t<T>;
        using my_pimpl_t = pimpl<coord_t<T>>;

        public:
                coordinate_t( T x, T y ) :
                        m_impl( my_pimpl_t::template Derived<my_simp_t>( x, y ))
                {
                }
                coordinate_t( coordinate_t<T> const& parent, T const& offset ) :
                        m_impl( my_pimpl_t::template Derived<my_dep_t>( *parent.m_impl, offset ))
                {
                }
                ~coordinate_t() { }
};

int main()
{
        coordinate_t<>  ts( 3, 5 );
        coordinate_t<>  ts_derived( ts, 9 );  // ts + { 9, 9 }
}