标签: metaprogramming

几乎每个 OOP 程序员都接触过控制反转的概念。在 C++ 中，我们可以通过动态回调（即 lambda 和函数指针等函子）来实现该原理。但是，如果我们在编译时知道要向驱动程序注入什么过程，理论上我相信有一种方法可以通过组合回调和驱动程序/信号/诸如此类的函数来消除函数传递和调用的开销进入“展开的程序”。这是一个例子。

对于 GUI 程序，我们有关于窗口 1) 设置、2) 循环和 3) 终止的逻辑。我们可以在 1) 窗口设置之后、2) 在每个渲染循环中、3) 和终止之前注入代码。程序方法是这样写：

// Snippet 1:
init_window();
init_input_handler();
init_canvas();
init_socket();
while (!window_should_close()) {
  update_window();
  handle_input();
  draw_on_canvas();
  send_through_socket();
}
drop_input_handler();
drop_canvas();
drop_socket();
terminate_window();

OOP 程序员以解耦和适当的抽象为荣。相反，我们这样写：

// Snippet 2:
init_window();
on_window_init_signal.send();
while (!window_should_close()) {
  update_window();
  on_render_signal.send();
}
on_exit_signal.send();
terminate_window();

但这会带来如上所述的不必要的开销。我的问题是：我们如何利用C++元编程机制来实现零开销控制反转，以便与代码片段2类似形式的代码可以静态地（即在编译时）转换为代码片段1 ？

编辑：我可以想到优化器中广泛存在的循环优化。也许这是该问题的通用版本。

我想创建一个类专业化，如果它传递任何 std::variant 或任何 boost::variant，则具有相同的实现。我尝试使用 std::enable_if、std::disjunction 和 std::is_same 但无法编译它。这是一个代码示例来展示我想要实现的目标。

#include <variant>
#include <iostream>
#include <boost/variant.hpp>

template <typename T>
struct TypeChecker;

template <typename T>
struct TypeChecker<T>
{
    void operator()()
    {
        std::cout << "I am other type\n";
    }
}

template <typename ... Ts>  // I want to be able to capture Ts... in TypeChecker scope
struct TypeChecker<std::variant<Ts...> or boost::variant<Ts...>> // what to insert here?
{
    void operator()()
    {
        std::cout << "I am either std::variant or boost::variant\n";
    }
}

int main()
{
    TypeChecker<std::variant<int, float>>{}(); …

下面的代码

template <typename T>
struct A 
{ static void f() {std::cout << "A<T>\n";} };

template <typename T>
struct A<const T>
{ static void f() {std::cout << "A<const T>\n";} };

template <typename T>
struct A<const T*>
{ static void f() {std::cout << "A<const T*>\n";} };



template <typename T>
void f()
{
    A<const T>::f();
}

int main()
{
    f<const int*>();
}

没有像我预期的那样工作。

我（错误地）认为对 call 的调用在本例中是f<const int*>()函数并且折叠成. 但这不是程序所做的，因为它打印的意思是（实际上）折叠成.A<const T>::f()A<const const int*>:f()const const int*const int*A<const T>const …

我想覆盖某个类的绘图方法。我希望将表达式字符串用作轴标签。然而，方法调度似乎以某种方式评估表达式，因此我无法按照我预期的方式检索原始表达式（抱歉，如果我在这里使用了错误的词汇）。下面是一个最小的例子：

library(rlang)

make_s = function(x) structure(x, class = "s")


plot2= function(x) print(enexpr(x))
plot.s = function(x) print(enexpr(x))

variable_name = make_s(1)
plot2(variable_name)
#Output:
#variable_name
plot(variable_name)
#Output:
#[1] 1
#attr(,"class")
#[1] "s"

我的期望是plot.s返回“variable_name”，但它没有返回。为什么会这样以及如何补救？

我已将C程序移植到C++ Template Meta程序.现在我想比较运行时.由于C++程序几乎没有运行时,我应该如何比较这两个程序.
我可以将C运行时与C++编译时间进行比较吗？还是只是没有可比性？

我将编写一个groovy脚本来生成一个javascript文件中的常量.;)

也许跨语言元编程？元语言元编程？

要明确的是,我在问这个类别属于什么类别

如果没有eval,这将如何工作

%w{user_id for_whom_id category_id product_status_id}.each do |f|
  code = <<-C
  it "should fail validation with no #{f}" do
    should_fail_on_validation { |p| p.#{f} = nil }
  end
  C
  eval code
end

？

我有一个关于动态构建的函数(或类似的东西)的问题.在Java中,我可以以编程方式将一些Source写入一个String,编译该字符串并像函数一样多次执行它.

想象一下,我有一些遗传算法来创建最佳代码来获取n个输入参数,根据基因组计算它们并返回m个输出参数.所以我想知道是否可能(并且我很确定它是),创建一个列表列表....包含该函数,然后使用不同的输入参数调用此函数几千次以计算错误率.

我现在需要的是一个例子,如何以编程方式创建这样的列表以及如何使用它.目前我完全陷入困境.

任何参考或例子都受到热烈欢迎.

模板元编程的"hello,world"可以被认为是阶乘代码:

template <unsigned int n>
struct factorial {
    enum { value = n * factorial<n - 1>::value };
};

template <>
struct factorial<0> {
    enum { value = 1 };
};

所以我们可以通过这样做得到阶乘

cout << factorial<4>::value << endl; //It will print 24

但如果我这样做:

int N = 4;
cout << factorial<N>::value << endl; //COMPILE ERROR

有没有办法在C++中为模板化函数提供动态值？

如何method_missing在课堂和混合模块中使用？

module Bar
  def method_missing(name, *args)
    p 'Bar' if name =~ /bar/
  end
end

class Foo
  include Bar

  def method_missing(name, *args)
    p 'Foo' if name =~ /foo/
  end
end

a = Foo.new
a.foofoo => "Foo"
a.barbar => nil