标签: variadic-functions

在这段代码中，为什么编译器无法从静态上下文引用具有 varargs 参数的方法。

 private static void doSomething(int... nums) {
    System.out.println("1");
}
private void doSomething(int num1, int num2) {
    System.out.println("2");
} 

public static void main(String[] args) {
    doSomething(1,2);
}

JDK 17 正在抱怨Cannot make a static reference to the non-static method doSomething(int, int) 。这是一个错误还是我不知道的其他功能。

JDK 8 和 JDK 11 不要抱怨它！

尝试掌握 Scala 3 类型系统。问题：

• 是否可以编写一个def curry(f: ???) = ...接受f任意数量并返回柯里化 fn 的通用函数？没有编译器插件，没有外部花哨的库，只是用普通 Scala 3 表达的 N 元函数？
• 我看一下这个 Haskell 示例https://riptutorial.com/haskell/example/18470/an-n-arity-curry，它的功能类似于所需的功能。

（这个问题的目的不是使用任何外部库 - 目的是学习使用 Scala 3 作为工具的函数式编程概念。有一种感觉，这可能与将 args 作为元组处理或将 fn 转换为元组 fn 相关？我觉得 fn args 和元组的概念之间存在一些对称性？）

我尝试使用简单的日志记录机制在创建日志时创建错误检查。我观察到，与 printf 相比，可以使用vfprintf()，它在编译时不会打印任何警告，传递给 format 的参数太多（参见下面的示例）。（我不希望他们有相同的行为，但我仍然期望类似的行为）。关于这个问题，即使在编译时已知可变参数的数量。在编译时是否可以通过任何方式进行检查？\n下面，我准备了一个代码示例，在编译时编译器将打印有关 printf 的警告，并且工作vfprintf()正常，没有任何错误。也许第二个可变参数被忽略了？我读过这个人，但找不到任何有用的信息。

#include <stdarg.h>\n#include <stdio.h>\n\nvoid check_printf_usage(char *fmt, ...)\n{\n    va_list ap;\n    \n    va_start(ap, fmt);\n    vfprintf(stdout, fmt, ap);\n    va_end(ap);\n}\n\nint main()\n{\n    int x = 1;\n    int y = 2;\n    printf("test nr.1 %i\\n", x, y); // works as expected, prints warning\n    check_printf_usage("test nr.2 %i\\n", x, y); // does not print any warning\n\n    return 0;\n}\n

这是编译输出+程序输出：

#include <stdarg.h>\n#include <stdio.h>\n\nvoid check_printf_usage(char *fmt, ...)\n{\n    va_list ap;\n    \n    va_start(ap, fmt);\n    vfprintf(stdout, fmt, ap);\n    va_end(ap);\n}\n\nint main()\n{\n    int …

假设我有两个用于调试输出的C++函数:

void Trace( const wchar_t* format, ... )
{
    va_list args;
    va_start( args, format );
    VarArgTrace( format, args );
    va_end( args );
}

void VarArgTrace( const wchar_t* format, va_list args )
{
    WCHAR buffer[1024];
    //use ::_vsnwprintf_s to format the string
    ::OutputDebugStringW( buffer );
}

以上使用Win32 OutputDebugStringW(),但它并不重要.现在我想优化格式化,以便在没有调试器附加格式化时(我测量 - 加速很重要):

void Trace( const wchar_t* format, ... )
{
    if( !IsDebuggerPresent() ) {
        return;
    }
    //proceed as previously
    va_list args;
    .....
 }

将我提前IsDebuggerPresent()返回一次返回null 的事实会影响除格式化之外的所有内容吗？

我的意思是我不再打电话va_start和va_end-这还重要？会跳过va_start …

我想编写一个powershell ps1脚本,它需要2个参数集,( - a -d),每个脚本最多可以有n个属性.如何实现？

example : DoTheTask -a <task name 1> <task name 2> ...  -d <machine name 1> <machine name 2>...

如果我有这个功能:

printAll(const char *message, ...)
{
    va_list argptr = NULL;
    va_start(argptr, message);

    // todo: how to printf all the arguments in the message?   

    va_end(argptr);    
}

假设我像这样调用函数:

printAll("My info: Value1 = %d, Value 2=%d", 1, 2);

在这一行:// todo:如何printf消息中的所有参数？

我怎样才能打印出来以便:

My info: Value1 = 1, Value 2=2

提前致谢.

在C99标准的第7.19.6.1节第8 节中:

c如果不存在l长度修饰符,则将int参数转换为a unsigned char,并写入生成的字符.

在C99标准的第7.19.6.1节第9段中:

如果任何参数不是相应转换规范的正确类型,则行为未定义.

• 该fprintf函数是否需要int参数？

例如,将unsigned int结果传递给未定义的行为:

unsigned int foo = 42;

fprintf(fp, "%c\n", foo); /* undefined behavior? */

这让我很担心,因为实施可能被定义char为具有与unsigned char(第6.2.5段第15段)相同的行为.

对于这些情况,整数提升可能要求在某些实现中char要提升unsigned int.因此,将以下代码留给那些实现的未定义行为风险:

char bar = 'B';

fprintf(fp, "%c\n", bar); /* possible undefined behavior? */

• 是int变量和字面int常量的值传递给唯一安全的方法fprintf与%c符？

我有一个类似下面的java类,我想通过使用类名动态创建这个类的实例.

class Demo {
    public Demo(String... s) {
    //some initialization here.
    }
}

我想使用以下代码创建一个对象

Class<?> klass = Class.forName("Demo");

Constructor<?> con = klass.getConstructor("**what should be here**");

Object obj = con.newInstance(param1, param2, ...);

Python允许您声明一个类似的函数

def print_all(*arguments):
    for a in arguments:
        print(a)
print_all(1,2,3)

这允许人们传递可变数量的数据.对于我而言,这似乎比构建列表或字典更具可读性,并将其作为参数传递给我.

def print_all2(things_to_print):
    for thing in things_to_print:
        print(thing)
things_to_print = [1,2,3]
print_all2(things_to_print)

第二个选项允许您为参数指定正确的名称.什么时候最好使用*arguments技术？是否有时候使用*参数更多Pythonic？

我有一个功能,需要3个强制输入和1个可选:

 f(A, B, C, X)

我想以这种方式使用匿名函数

h = @(X)f(A,B,C,X)

其中A, B, C已经确定,这样我可以只是调用h(1)和代码运行f(A,B,C,1),以及h()运行f(A,B,C).我能够做到的唯一方法(如果我错了,请纠正我)正在使用varargin.我定义

f(A,B,C,varargin)

并使用

h = @(varargin)f(A,B,C,varargin)

问题是当我直接调用时f(A,B,C,1),然后在我的函数内部varargin = {1}.如果我打电话h(1),那么我有varargin = {{1}}.我怎么能避免这种情况？有没有更好的方法来实现我想要的？