以模板化类作为返回值的 C++ 模板化函数-解网

问：

我有这个Java代码：

public interface Adapter<FROM,TO> {
    /**
     * Adapts something from one type to a type. 
     * @param f
     * @return
     */
    public TO adapt(FROM f);
    
    /**
     * Chains adapters. 
     * 
     * @param <NEXT>
     * @param next 
     * @return a new adapter that takes the output of this adapter and 
     * adapts to something of type NEXT.
     */
    public default <NEXT> Adapter<FROM,NEXT> chain(Adapter<TO,NEXT> next){
        Adapter<FROM,TO> x=this; 
        return new Adapter<FROM,NEXT>(){
            @Override
            public NEXT adapt(FROM f) {
                return next.adapt(x.adapt(f));
            }
        };
    }

我真的很想在 C++ 中使用类似的东西。到目前为止，我做的最好的是：

#ifndef ADAPTER_H
#define ADAPTER_H
 
template <typename FROM, typename TO>
class Adapter
{
  public:
  TO adapt(FROM f);
 
  template <typename NEXT> Adapter<FROM, NEXT> chain(Adapter<TO, NEXT> arg)
  {
    class UnNamed: public Adapter<FROM, NEXT>
    {
      public: 
      Adapter<TO, NEXT> outer;
      UnNamed(Adapter<TO, NEXT> arg)
      {
        outer = arg;
      }
      NEXT adapt(FROM from)
      {
         outer.adapt(Adapter::adapt(from));
      }
     };
     return UnNamed(arg);
   }
};
 
#endif

但它失败了，并出现了未定义的引用错误。我真的很想让 api 尽可能接近 Java，但我无法弄清楚如何让嵌套类以可引用的方式存在。

C++ 模板 undefined-reference

在 C++ 中，你可以做类似的事情，只是没有等价于 Java 的关键字（C++ 有一个关键字，但它的含义非常不同），因此您需要显式定义自己的类类型来实现您的虚拟接口。您尝试过这样做，但是除非您通过对对象的指针/引用调用虚拟方法，否则多态性不起作用，否则您可能会遭受对象切片。在某种程度上，Java 也强制执行此规则，因为 Java 中的所有对象都是引用类型，只有基本类型是值类型（而在 C++ 中，类也可以用作值类型）。defaultdefault

请尝试更像这样的东西：

#include <memory>

template<typename FROM, typename TO>
class Adapter
{
public:
    /**
     * Adapts something from one type to a type. 
     * @param f
     * @return
     */
    virtual TO adapt(FROM f) = 0;
    
    /**
     * Chains adapters. 
     * 
     * @param <NEXT>
     * @param next 
     * @return a new adapter that takes the output of this adapter and 
     * adapts to something of type NEXT.
     */
    template<typename NEXT>
    std::unique_ptr<Adapter<FROM, NEXT>> chain(Adapter<TO, NEXT> *next)
    {
        class ChainedAdapter : public Adapter<FROM, NEXT>
        {
        private:
            Adapter<FROM, TO> *x; 
            Adapter<TO, NEXT> *next;
        public:
            ChainedAdapter(Adapter<FROM, TO> *x, Adapter<TO, NEXT> *next)
                : x(x), next(next) {}

            NEXT adapt(FROM f) override {
                return next->adapt(x->adapt(f));
            }
        };

        return std::make_unique<ChainedAdapter>(this, next);
    }
};

在线演示

虽然，我想你也可以在不动态创建它的情况下使 return a new 侥幸逃脱，如果你对返回的对象非常小心，并且不要以任何会切片它的方式使用它：chain()ChainedAdapter

#include <memory>
     
template<typename FROM, typename TO>
class Adapter
{
public:
    /**
     * Adapts something from one type to a type. 
     * @param f
     * @return
     */
    virtual TO adapt(FROM f) = 0;
     
    /**
     * Chains adapters. 
     * 
     * @param <NEXT>
     * @param next 
     * @return a new adapter that takes the output of this adapter and 
     * adapts to something of type NEXT.
     */
    template<typename NEXT>
    auto chain(Adapter<TO, NEXT> *next)
    {
        class ChainedAdapter : public Adapter<FROM, NEXT>
        {
        private:
            Adapter<FROM, TO> *x; 
            Adapter<TO, NEXT> *next;
        public:
            ChainedAdapter(Adapter<FROM, TO> *x, Adapter<TO, NEXT> *next)
                : x(x), next(next) {}
     
            NEXT adapt(FROM f) override {
                return next->adapt(x->adapt(f));
            }
        };
     
        return ChainedAdapter(this, next);
    }
};

在线演示

3赞 Yakk - Adam Nevraumont 8/5/2021 #2

我会避免直接的 Java 代码翻译。

一种 C++ 方法是拥抱价值观。

template<class Sig>
struct adapter;
template<class Out, class In>
struct adapter<Out(In)>:std::function<Out(In)>
{
  using std::function<Out(In)>::function;
  template<class Next, class Result=std::invoke_result_t<Next const&, Out>>
  adapter<Result(In)> chain( Next next ) const& {
    auto tmp=*this;
    return std::move(tmp).chain(std::move(next));
  }
  template<class Next, class Result=std::invoke_result_t<Next, Out>>
  adapter<Result(In)> chain( Next next ) && {
    return [self=std::move(*this), next=std::move(next)](In in)->Result {
      return next(self(std::forward<In>(in)));
    };
  }
};

我们开始了。

adapter<int(double)> rounder=[](double d){return std::floor(d);};
adapter<double(std::istream&)> double_reader=[](auto&is){double d; is>>d; return d;};
adapter<int(std::istream&)> int_reader=double_reader.chain(rounder);
std::cout << int_reader(std::cin);

等。

这些适配器是多态值类型。您可以将它们与函数指针、lambda、std 函数或其他函数对象链接起来

调用在上面的代码中拼写。其主要目的是称为......可以用来使 then callable。x.adapt(foo)x(foo)operator()

活生生的例子。

设计：

我承担了大部分繁重的工作。它是一种多态值类型，支持调用和可为 null 性。std::function

我们只是从它继承，转发构造函数，并添加一个检查兼容性并推断返回类型的方法。.chain

我们可以扩展适配器，轻松支持多对一适应。第一步是通过在正确的位置添加一堆 s 来支持多个输入：...

template<class Sig>
struct adapter;
template<class Out, class... In>
struct adapter<Out(In...)>:std::function<Out(In...)>
{
    using std::function<Out(In...)>::function;
    template<class Next, class Result=std::invoke_result_t<Next const&, Out>>
    adapter<Result(In...)> chain( Next next ) const& {
        auto tmp=*this;
        return std::move(tmp).chain(std::move(next));
    }
    template<class Next, class Result=std::invoke_result_t<Next, Out>>
    adapter<Result(In...)> chain( Next next ) && {
        return [self=std::move(*this), next=std::move(next)](In... in)->Result {
            return next(self(std::forward<In>(in)...));
        };
    }
};

现在，该语法不适用于的多个输入。我们可以添加另一种方法：first.chain(second)second

template<class Sig>
struct adapter;
template<class Out, class... In>
struct adapter<Out(In...)>:std::function<Out(In...)>
{
    using std::function<Out(In...)>::function;
    template<class Next, class Result=std::invoke_result_t<Next const&, Out>>
    adapter<Result(In...)> chain( Next next ) const& {
        auto tmp=*this;
        return std::move(tmp).chain(std::move(next));
    }
    template<class Next, class Result=std::invoke_result_t<Next, Out>>
    adapter<Result(In...)> chain( Next next ) && {
        return [self=std::move(*this), next=std::move(next)](In... in)->Result {
            return next(self(std::forward<In>(in)...));
        };
    }
    template<class...First>
    adapter<Out(First...)> consume( adapter<In(First)>... src)&&
    {
        return [self=std::move(*this), ...src=std::move(src)](First... first)->Out
        {
            return self(src(std::forward<First>(first))...);
        };
    }
    template<class...First>
    adapter<Out(First...)> consume( adapter<In(First)>... src) const&
    {
        auto tmp = *this;
        return std::move(tmp).consume( std::move(src)... );
    }
};

但这有点过分了，不是吗？

活生生的例子。

有些人对以非多态方式从值类型（如）继承持怀疑态度。在这里，我认为几乎没有人在他们的正常头脑中存储指向 s 的指针;那些这样做的人，通常是在做一个把戏（处理多态破坏）。std::functionstd::functionshared_ptr

但是，如果您担心，可以这样做：

template<class Out, class... In>
struct adapter<Out(In...)>
{
  using F = std::function<Out(In...)>;
  F f;
  // forward call operator
  template<class...Args>
  auto operator()(Args&&...args)const
  -> std::invoke_result_t<F const&, Args&&...>
  {
    return f(std::forward<Args>(args)...);
  }
  // default all special member functions:
  adapter()=default;
  adapter(adapter const&)=default;
  adapter(adapter &&)=default;
  adapter& operator=(adapter const&)=default;
  adapter& operator=(adapter &&)=default;
  ~adapter()=default;
  // forward a few useful operations and ctors:
  explicit operator bool() const { return (bool)f; }
  template<class Fin> 
  requires (!std::is_same_v<Fin, adapter> && std::convertible_to<Fin, F>)
  adapter( Fin fin ):f(std::forward<Fin>(fin)) {}

然后添加方法。.chain

正如你所看到的，这增加了相当多的代码。活生生的例子。

@GuillaumeRacicot 从另一个值类型继承一个值类型是一个非常好的主意，尤其是在切片不是问题的情况下;上面适配器的 std 函数切片是正确的。仅当您存储指向 std 函数的哑指针时（...你为什么要这样做）是否存在问题（包括拥有没有销毁函数的唯一 PTR;但同样，STD 函数的唯一 PTR 是严重的代码异味。

上一个：编译器不给出错误未定义引用的行号

下一个：C++ 无法使用模板参数 [duplicate] 创建模板构造函数

以模板化类作为返回值的 C++ 模板化函数

C++ templated function with templated class as return value

评论

评论