标签: variadic-functions

任何人都可以向我展示一个使用带有可变参数的C函数(例如printf)与Haskell的外部函数接口的示例吗？我试着搜索HaskellWiki,但没有找到这样的例子.

谢谢!

我有以下类存储对象数组列表.

public class Test {
    private List<Object[]> list = new ArrayList<Object[]>();

    public void addList(Object... obj) {
        list.add(obj);
    }

    public void addList(List<Object> lst) {
        list.add(lst.toArray());
    }
}

当我调用以下内容时,addList(Object... obj)会调用重载方法,但我希望addList(List<Object> lst)调用它.我怎样才能做到这一点？

public class Main {
    public static void main(String[] args) {
        Test testObj = new Test();
        List<String> myStrings = new ArrayList<String>();
        myStrings.add("string 1");
        myStrings.add("string 2");
        myStrings.add("string 3");

        // The variable argument method is called but this is a list!
        testObj.addList(myStrings);

    }    
}

我正在实现一个API,它有一个方法可以传递程序从中读取资源的路径列表

public void importFrom(String... paths) {

}

我正在使用varargs来尽可能方便地调用方法给用户,就像这样

obj.importFrom("/foo", "/foo/bar);

这是varargs的合适用法吗？或者更好地传递数组？

我想使用C++ 11的可变参数模板来实现通用的"随机选择器"功能.

像这样......

template <typename T>
T randomPicker(T one, T two, T three)
{
    int pick = 3 * (rand() / double(RAND_MAX));
    switch (pick)
    {
        case 0:
            return one;
        case 1:
            return two;
        default:
            return three;
    }
}

...除了通用以接受任何数量的参数(每个参数类型相同,如上所述 - 尽管接受任何类型作为参数并且在返回时将所选类型转换为某个特定类型T也是可接受的).

我理解使用模板递归来实现类型安全printf等的想法.可变参数模板也可以用来创建上面描述的那种函数吗？任何提示赞赏!

是否可以在没有FlexibleInstances的情况下表达以下Haskell程序,即在纯Haskell2010中？

{-# LANGUAGE FlexibleInstances #-}

class    Funk a       where  truth :: a  -> [Bool]
instance Funk [Bool]  where  truth =  \x ->  x
instance Funk Bool    where  truth =  \x -> [x]

instance Funk b => Funk (Bool -> b) where
    truth f = concat [truth (f True), truth (f False)]

这是受如何编写Haskell函数的答案的启发,该函数将可变函数作为参数.

我怀疑问题是,它truth返回的东西不是它作为参数所使用的函数(它返回Bool,而不是[Bool]).

这个片段的目的是给出一个布尔函数的所有可能配置的所有评估的列表,即

Main> truth (\x y -> x && y)
[True,False,False,False]

Main> truth (\x y -> …

通常,在函数中使用C++ 11可变参数模板功能要求基于可变参数的函数参数是函数参数列表中的最后一个.有一个例外; 如果存在C级可变参数,它们是倒数第二个参数,它们必须是最后的.

template < typename ...Args >
int  super_printf( Something x, Args &&...a, ... );

我有时会随机思考C++,我想知道如何实现这样的功能.我首先想到了通常从a递归剥离的论点,然后我记得C级varargs没有级联.我必须马上把它们变成一个明确的va_list.

template < typename ...Args >
int  super_vaprintf( Something x, std::va_list &aa, Args &&...a );
// Note that "aa" is passed by reference.

template < typename ...Args >
int  super_printf( Something x, Args &&...a, ... )
{
    std::va_list  args2;
    int           result;

    va_start( args2, XXX );  // (A)
    try {
        result = super_vaprintf( x, args2, std::forward<Args>(a)... );
    } catch ( ... ) { …

这是我在过去几天一直在研究的语义优化问题,我被困住了.我的真实程序运行在RTOS(特别是FreeRTOS)上,我需要生成任务(这是简单的,非终止版本的线程).C API接受void (*)(void*)任务的入口点和void*参数.非常标准的票价.

我为一个任务编写了一个包装类,而不是做一个老式的实现,比如有一个必须被最终任务类覆盖的虚方法,我宁愿让C++生成必要的参数存储通过可变参数模板和函数实现对象和粘合功能.

我已经用lambdas做了这个,std::function并且std::bind已经,但它们似乎实现了一些膨胀,即通过不解析函数目标直到运行时.基本上与虚拟方法相同的机制将使用.如果可能的话,我正试图减少所有开销.与硬编码实现相比,每个实例的膨胀大约为200字节.(这是在ARM Cortex-M3上,总闪存为128K,我们只剩下大约500个字节.)我在该主题上发现的所有SO问题同样推迟了函数的解析直到运行时.

这个想法是为了代码:

1. 将可变参数的衰减版本存储在堆上分配的对象中(这是一种简化;可以使用分配器),并将其作为void*参数传递,
2. 将生成的调用岛函数作为入口点,使用签名void(void*),使用存储的参数调用目标函数,以及
3. (这是我无法弄清楚的部分)让编译器从目标函数的签名中推导出参数列表的类型,遵循不要重复自己的原则.
4. 请注意,函数指针及其参数类型在编译时是已知的并且已解析,并且传递给函数的实际参数值在运行时才会知道(因为它们包括对象指针和运行时配置选项等).

在下面的例子中,我必须实例化的任务,一个Task<void (*)(int), bar, int> task_bar(100);当我宁愿写Task<bar> task_bar(100);或Task task_bar<bar>(100);并有编译器弄清楚(或者以某种方式告诉它在库)的可变参数必须符合指定函数的参数列表.

"明显的"答案是某种模板签名,template<typename... Args, void (*Function)(Args...)>但不用说,这不会编译.这种情况也不Function是第一个论点.

我不确定这是否可能,所以我在这里要求看看你们想出的是什么.为了简化问题,我省略了以对象方法而不是静态函数为目标的变体代码.

以下是具有代表性的测试用例.我用gcc 4.7.3和-std=gnu++11旗帜构建它.

#include <utility>
#include <iostream>
using namespace std;

void foo() { cout << "foo()\n"; }
void bar(int val) { cout << "bar(" << …

我是否可以在Python中使用任何魔法来通过添加一些额外的参数来有效地使用超级构造函数？

理想情况下,我想使用类似的东西:

class ZipArchive(zipfile.ZipFile):
    def __init__(self, verbose=True, **kwargs):
        """
        Constructor with some extra params.

        For other params see: zipfile.ZipFile
        """
        self.verbose = verbose
        super(ZipArchive, self).__init__(**kwargs)

然后能够使用原始的构造函数参数与我的类中的一些额外的东西混合.像这样:

zip = ZipArchive('test.zip', 'w')
zip = ZipArchive('test.zip', 'w', verbose=False)

我正在使用Python 2.6,但如果魔法只能在更高版本的Python中实现,那么我也很感兴趣.

编辑:我应该提到上面的内容不起作用.错误是:TypeError: __init__() takes at most 2 arguments (3 given)

可变参数模板在c ++ 11中引入.我发现可以使用它替换printf函数.但是,cout用于实现.我想知道是否有可能使用其他东西来实现类型安全但不牺牲太多性能.

void safe_printf(const char *s)
{
    while (*s) {
        if (*s == '%') {
            if (*(s + 1) == '%') {
                ++s;
            }
            else {
                throw "invalid format string: missing arguments";
            }
        }
        std::cout << *s++;
    }
}

template<typename T, typename... Args>
void safe_printf(const char *s, T& value, Args... args)
{
    while (*s) {
        if (*s == '%') {
            if (*(s + 1) == '%') {
                ++s;
            }
            else {
                std::cout << value;
                safe_printf(s + 1, args...); // …

我发现自己检查了这一点,并询问是否有必要.我有这样的代码:

public Object myMethod(Object... many) {
  if (many == null || many.length == 0)
    return this;
  for (Object one : many)
    doSomethingWith(one);
  return that;
}

但后来我想知道......我是否过于谨慎？我需要检查一下many == null吗？在任何当前的Java版本中都有可能吗？如果是这样,怎么样？如果没有,我可能会继续检查,只是为了防止以后Oracle确定它有一天可以为空.