标签: metaprogramming

如何在现有函数之前或之后添加代码？

例如,我有一个班级:

 class A(object):
     def test(self):
         print "here"

我如何编辑类机智元编程,以便我这样做

 class A(object):
     def test(self):
         print "here"

         print "and here"

也许某种方式附加另一个功能来测试？

添加另一个功能,如

 def test2(self):
      print "and here"

并将原始更改为

 class A(object):
     def test(self):
         print "here"
         self.test2()

有没有办法做到这一点？

我一直在尝试设置一个自定义类加载器,它拦截类以打印出正在加载到应用程序中的类.类加载器看起来像这样

public class MyClassLoader extends ClassLoader {
    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        System.out.println("Loading: " + name);
        return super.loadClass(name);
    }
}     

它只是吐出它加载的所有类的名称.但是,当我尝试运行一些代码时,

import org.python.util.PythonInterpreter;
public class Scripts {
    public String main(){

        PythonInterpreter p = new PythonInterpreter();
        p.exec("print 'Python ' + open('.gitignore').read()");

        return "Success! Nothing broke";
    }
}

通过

MyClassLoader bcl = new MyClassLoader();
Class c = bcl.loadClass("Scripts");

Method m = c.getMethod("main");
String result = (String) m.invoke(c.getConstructor().newInstance());

它打印出来

Loading: Scripts
Loading: java.lang.Object
Loading: java.lang.String
Loading: org.python.util.PythonInterpreter
Python build/
.idea/* …

在我的工作场所,我们倾向于使用 iostream,字符串,向量,地图和奇数算法或两个.我们实际上并没有发现很多情况,模板技术是问题的最佳解决方案.

我在这里寻找的是想法,以及可选的示例代码,它们展示了您如何使用模板技术为您在现实生活中遇到的问题创建新的解决方案.

作为贿赂,期待对你的答案进行投票.

这只是过去几天困扰我的事情,我认为不可能解决,但我之前看过模板魔术.

开始:

为了获得标准C++数组中的元素数量,我可以使用宏(1)或类型安全的内联函数(2):

(1)

#define sizeof_array(ARRAY) (sizeof(ARRAY)/sizeof(ARRAY[0]))

(2)

template <typename T>
size_t sizeof_array(const T& ARRAY){
    return (sizeof(ARRAY)/sizeof(ARRAY[0]));
}

正如您所看到的,第一个问题是成为一个宏(目前我认为是一个问题),而另一个问题是在编译时无法获得数组的大小; 即我不能写:

enum ENUM{N=sizeof_array(ARRAY)};

要么

BOOST_STATIC_ASSERT(sizeof_array(ARRAY)==10);// Assuming the size 10..

有谁知道这是否可以解决？

更新:

这个问题是在引入constexpr之前创建的.现在你可以简单地使用:

template <typename T>
constexpr auto sizeof_array(const T& iarray) {
    return (sizeof(iarray) / sizeof(iarray[0]));
}

在Python中,你可以做这样的事情来导入使用字符串文件名的模块,并指定其命名空间的本地命名空间的变量.

x = __import__(str)

我想知道,如果有,将采取采取的,而不是用Python代码文件的路径Python代码串,并返回其命名空间为变量的相关功能.

例如,

str = "a = 5";
x = importstr(str)
print x.a
#output is 5

我意识到我可以将字符串写入文件,然后使用__import__它,但我想跳过中间文件,如果可能的话.

这样做的原因是我在python中尝试元编程,这似乎是我正在做的一个很好的解决方案.

我有一个mixin,我想获得包含它的所有类的列表.在mixin模块中,我做了以下事情:

module MyModule
  def self.included(base)
    @classes ||= []
    @classes << base.name
  end

  def self.classes
    @classes
  end
end

class MyClass
  include MyModule
end

这非常有效:

> MyModule.classes #=> nil
> MyClass.new #=> #<MyClass ...>
> MyModule.classes #=> ["MyClass"]

现在,我想将这部分提取到一个单独的模块中,该模块可以包含在我的其他mixins中.所以,我想出了以下内容:

module ListIncludedClasses
  def self.included(base)
    p "...adding #{base.name} to #{self.name}.classes"

    @classes ||= []
    @classes << base.name

    base.extend(ClassMethods)
  end

  def self.classes
    @classes
  end

  module ClassMethods
    def included(module_base)
      p "...adding #{module_base.name} to #{self.name}.classes"

      @module_classes ||= []
      @module_classes << module_base.name
      super(module_base)
    end
    def classes
      @module_classes
    end
  end …

比如我有

class Foo: INotifyPropertyChanged {
    public event PropertyChangedEventHandler PropertyChanged;
    public int Bar {get;set;}
}

我可以在编译时获取Foo类AST并重写Bar

    public string Bar
    {
        get { return this.bar; }

        set 
        {
            if (value != this.bar)
            {
                this.phoneNumberValue = value;
                PropertyChanged(this, new PropertyChangedEventArgs("Bar"));
            }
        }
    }

.

我class_eval用来编写要在当前类的上下文中执行的代码.在以下代码中,我想为属性值的更改添加计数器.

class Class
  def attr_count(attr_name)
    attr_name = attr_name.to_s
    attr_reader attr_name # create the attribute's getter
    class_eval %Q{
      @count = 0
      def #{attr_name}= (attr_name)
        @attr_name = attr_name
        @count += 1
      end

      def #{attr_name}
        @attr_name
      end
    }
    end
  end
class Foo
  attr_count :bar
end

f = Foo.new
f.bar = 1

我的理解class_eval是它在运行时类的上下文中计算块- 在我的例子中,在class Foo.我希望上面的代码运行类似于:

class Foo
  attr_count :bar
  @count = 0
  def bar= (attr_name)
    @attr_name = attr_name
    @count += 1
  end

  def bar …

是否有类型特征,或者是否可以编写类型特征is_scoped_enum<T>,使得:

• if T是一个范围枚举,is_scoped_enum<T>::value是true和
• 如果T是任何其他类型,is_scoped_enum<T>::value则为false

模板类std::common_type计算可变参数类型列表的公共类型.它是x:y?z递归地使用三元运算符的返回类型定义的.从这个定义来看,对我而言,计算a是否std::common_type<X,Y>是关联的,即是否是,这一点并不明显

using namespace std;
static_assert( is_same<common_type< X, common_type<Y,Z>::type    >::type,
                       common_type<    common_type<X,Y>::type, Z >::type>::value, "" );

不会抛出一个编译时错误,所有类型X,Y并Z为其is_same<...>表达是有效的.

请注意,我不是在问

static_assert( is_same<common_type<X,Y>::type,
                       common_type<Y,X>::type>::value, "" );

永远都会开火.显然不会.以上是一个完全不同的问题.

另请注意,std::common_typeC++ 14 中的规范略有变化,并且可能会在C++中再次发生变化17.因此,对于不同版本的标准,答案可能会有所不同.