C++ 使用类型别名声明变量函数

我有一个类不直接获取可变模板参数类型。
相反，它获取一种类型的类，该类获取可变模板参数。
下面是一个简化的例子

template<typename Foo> struct bar;
template<typename Derived, typename F> struct fooBase;


template<typename Derived, typename R, typename ...Args>
struct fooBase<Derived, R(Args...)> {
  using function_type = R(Args...);

  void func(Args&&... args) {
    b->func2(std::forward<Args>(args)...);
  }
  
  void set(bar<Derived>* bp) {
      b = bp;
  }

  bar<Derived>* b;
};

struct foo : public fooBase<foo, void(int)> {};

template<typename Foo> 
struct bar {
  using function_type = typename Foo::function_type;

  void func2(/** what here? */) {

  }
};


foo f;
bar<foo> b;
f.set(&b);
f.func(3);

模板结构条；
模板结构fooBase；
模板
结构fooBase{
使用函数_type=R（Args…）；
无效函数（参数&&…参数）{
b->func2（标准：：转发（参数）…）；
}
无效集（bar*bp）{
b=血压；
}
巴*b；
};
struct foo:public fooBase{}；
模板
结构条{
使用function\u type=typename Foo:：function\u type；
void func2（/**这里是什么？*/）{
}
};
福福；
b栏；
f、 设置（&b）；
f、 func（3）；

有没有一种方法可以在

bar

中解决此问题，而无需声明父类或额外的模板参数

我的问题是我可以用

function\u类型

您可以在结构栏外部编写以下内容：

Foo::function_type func;

这是名为

func2

的函数的前向声明，该函数必须在别处定义，因此无法解决问题。由于前面提到的讲故事的人，您也不能在结构栏中写这个。你还可以写的是：

Foo::function_type *func;

现在您已经声明了一个函数指针。你可以让它指向一个实函数。例如：

func = [](int x){ std::cout << x << '\n'; };

由于通用lambda被分配给具有具体类型的函数指针

func2

，

func2（）

现在总是采用与

函数类型

完全相同的参数。但是，正如上面提到的，这只适用于没有任何捕获的lambda函数，否则lambda无法转换为函数指针

但是，在这种情况下，您不需要声明函数指针和分配lambda，您只需定义一个接受参数包的普通函数：

template<typename Foo>
struct bar {
    template<typename ...Params>
    void func2(Params&&... params) {
        std::cout << "Parameters:\n";
        ((std::cout << params << '\n'), ...);
    };

    /* Or with C++20 you can simplify this to:
    void func2(auto&&... params) {
        ...
    } */
};

以上也不是完美的，例如以下代码：

foo f;
bar<foo> b;
f.set(&b);
f.func(3.14);
b.func2(3.14);

foof；
b栏；
f、 设置（&b）；
f、 func（3.14）；
b、 职能2（3.14）；

---

将分别打印

3

和

3.14

。

如果“解决它”是指从foo获得

Args…

包？您可以使用

structbar{…}

@super实际上，它更复杂。我编辑了这篇文章。我的问题是我可以用

function\u类型

声明一个函数吗这可能会有所帮助：

fooBase

有什么意义？如果你删除它，你可以按照我在评论中说的做。在这里，您可以使

void（int）

成为

foo

s签名的一部分，并执行相同的操作。@super这只是一个最小的可复制示例。。。实际的代码有含义和其他复杂的东西。你不能编写

foo:：function\u type func

——而且lambda技巧也不起作用。不能将通用lambda分配给函数指针。它不支持转换。关于

foo:：function\u type func

内部

struct bar

，您是对的，但lambda技巧确实有效：@G.Sliepen仅适用于不捕获的lambda。所以这是一个有限的技巧。嗯。。。的确我自己从来没有见过或做过。直到。有用的小把戏。

template<typename Foo>
struct bar {
    using function_type = typename Foo::function_type;

    template<typename ...Params>
    void func2(Params&&... params)
    requires std::invocable<function_type, Params...>
    {
        std::cout << "Parameters:\n";
        ((std::cout << params << '\n'), ...);
    };
};

foo f;
bar<foo> b;
f.set(&b);
f.func(3.14);
b.func2(3.14);