标签: variadic-functions

我有一个函数，log_message它需要可变参数。

log_message(int level, char *fmt, ...)

现在在调用 this( log_message) 函数之前，我必须添加新函数 ( _log_message)，新函数将调用log_message.

_log_message(int level, char *fmt, ...)

新功能也一样。何时_log_message调用log_message它会将变量输入转换为va_list. 现在我有va_list，我不想改变原来的，有没有办法改回可变输入，所以我可以调用原来的（log_message）。

我正在学习stdarg.h在ci我试图打印传递给函数的所有参数,而不知道有多少参数,但我还没有提出解决方案,在此过程中发生这种情况,无论我传递给strtest.它总是打印0. 1. 2. 3.

void strtest(char *fmt, ...){
    va_list argp;
    int i = 0;

    va_start(argp, fmt);

    while(va_arg(argp, char*))
        printf("%d\t", i++ );

    va_end(argp);
}

int main(int argc, char *argv[]){
    strtest("s");
    printf("\n");
    return 0;
}

C11标准为6.5.2.2.6美元:

如果表示被调用函数的表达式具有不包含原型的类型,则对每个参数执行整数提升,并将具有float类型的参数提升为double.这些被称为默认参数促销.如果参数数量不等于参数数量,则行为未定义.如果使用包含原型的类型定义函数,并且原型以省略号(,...)结尾,或者促销后的参数类型与参数类型不兼容,则行为未定义.如果使用不包含原型的类型定义函数,并且促销后的参数类型与促销后的参数类型不兼容,则行为未定义,但以下情况除外:...

这意味着什么 - 我真的无法理解它(特别是第一部分).从我可以,但它意味着定义这样的函数:

void func(int a, int b, ...)
{
}

然后调用它是未定义的行为,我认为这是愚蠢的.

我正在尝试在 C 中使用变量参数创建一个递归函数，但在编写递归调用时似乎无法传递参数。

代码：

void f(const char* s, ...) {
        va_list args;
        va_start(args, s);
        f(s,args);
        va_end(args);
    }
}

不要介意无限的调用堆栈。这不是重点，所以我放弃了代码中的所有其他方面。

据我所知，局部变量和参数存储在堆栈内存中，其中包括对象引用，而实际对象存储在堆内存中。那么当你使用 var-args 时到底会发生什么？

public static int[] test(int... x) {
    return x;
}

public static void main(String[] args) {
    int[] a = test(1,2,3,4,5);
    int[] b = test(6,7,8,9,0);
    System.out.println(a);
    System.out.println(b);
    for (int i : a) {
        System.out.println(i);
    }
    for (int i : b) {
        System.out.println(i);
    }

test在这里，我相信作为参数传递给in 的所有值都x存储在堆栈中，因此当我们调用 时test(1,2,3,4,5)，我们正在使用堆栈空间，相应地，当我们调用时，test(6,7,8,9,0)我们应该在堆栈上引起内存冲突......但是当我运行时上面，我得到以下结果。

[I@2db0f6b2
[I@3cd1f1c8
1
2
3
4
5
6
7
8
9
0

a可以看出，由于第二次调用test生成 ，因此没有损坏 中的项目b。两者的存储方式似乎不同。

这是否意味着参数以某种方式存储在堆上？这是否意味着任何形式的调用function(param)都会转换为（原始或内存引用）的值，param而不一定位于堆栈内存中？

我试图回答另一个问题，这导致我问自己的问题。我做了一些研究，但找不到有关上述主题的任何信息。

我有一个抽象类Character，它有 1 个带有 varargs 参数的抽象方法，如下定义

public abstract class Character {
   public abstract void doSomething(int... values);
}

我的印象是任何扩展此类的类都可以使用任意数量的参数覆盖此方法。

// 1st example
public class Player extends Character { 
   @Override
   public void doSomething(int x, int y) { // Two params - do something }
}

// 2nd example 
public class NPC extends Character {
   @Override
   public void doSomething() { // No params - do something }
}

但上面的两个例子都导致了编译时错误。我想知道我在这里错过了什么？上述场景有可能吗？

任何帮助表示赞赏。

有没有办法将可变参数函数强制转换为这样的函数指针,这是合法的吗？我要求C和C++,但由于这个结构存在于两种语言中,我将两个问题都放在一起.

extern int test(int, ...);
auto testptr = (int(*)(int, int, long)) &test;

谢谢,杰克

我想包装内置的：

     (concatenate ‘string <arg1> <arg2> .. <argn>)

成为这样的事情：

     (strcat <arg1> <arg2> ... <argn>)

问题是 - 如何在 common-lisp 中做 var-args？我看到两条可能的路径：

1. 接受一个列表作为参数，然后splat它/apply它 [我都不知道]
2. common-lisp 中的 var-args 特殊语法？ ex: ...

谢谢

我想声明一个方法 - 可变参数 - 它的签名来自作为模板参数的“旧式”函数签名。

您可以std::function使用函数签名声明，例如，

std::function<int(float,float)> f;

现在我想要一个模板，它采用这样的函数签名并以某种方式声明一个方法：

template <typename F>
struct Foo {
   [F's-return-type] Method(F's-Arg-pack]...) { ... }
};

因此，如果您按如下方式实例化它，您将获得如下方法：

   Foo<int(float,float)> foo;
   int x = foo.Method(1.0f, 2.0f);

或者也许有不同的方法来做到这一点？

用 C 编写一个程序来计算从命令行传递的数字的阶乘。阶乘必须在一个名为 computeFact() 的单独函数中计算，该函数具有以下原型： int computeFact(int,…);

#include <stdarg.h>
#include <stdio.h>
#include<stdlib.h>
int computeFact(int, ...);
int main(int argc, char *argv[]) 
{
  if (argc < 2) 
  {
    printf("Invalid!");
  } else {
    for (int i = 1; i < argc; i++)
    {
      int n = atoi(argv[i]);
      printf("Factorial of %d is %d\n", n, computeFact(n));
    }
  }
  printf("\n");./
  return 0;
}
int computeFact(int num, ...) 
{
  va_list valist;
  int fact = 1;

  va_start(valist, num);
  for (int i = 0; i < num; i++) 
  { …