标签: variadic-functions

变量长度参数如何列出printf() , scanf(), etcC中的函数与C++中的函数重载有何不同？

这是怎么回事

printf("Didnt Work %s",s);

与......不同

printf(s,"Didnt Work %s");

其中s定义为:

const char *s="string";

请解释.

使用可变参数函数有什么好处

void fun(int i, ...);

而不是将指针传递给数组？

void fun(int i*);

什么是可变参数函数？

哇!我刚刚意识到Java中的varargs方法导致在调用它们时分配一个数组.不知道为什么我会期待任何不同的东西,但是否应该为数组提供某种池？至少对于最初的0到8个尺寸？Java中是否有任何解决方法使用varargs而不会为每次调用分配数组？

编辑:请理解泄漏到GC的内存只是一个不必要的开销/延迟.这不是一些暗示的错误.仅仅因为Java有GC并不意味着你可以随意创建大量的垃圾.

我需要在我的方法中接收多个变量Args.但我不知道该怎么做.

例如:

(void)insertInTableOnAttributes:(id)fieldsNames, ... Values:(id)fieldsValues, ...;

遗憾的是,在第(...)一句话后出现编译错误:

Expected ':' after method Prototype".

在实施中说:

Expected Method Body" in the same position (just after the first ...)

PD:我正在使用Xcode 4.2.1.

我正在编写一个接收任意数量参数并返回修改的方法.我尝试过使用varargs但是它不起作用,在这里你可以看到代码的简化版本:

public static void main(String[] args) {
   String hello = "hello";
   String world = "world";

   addPrefix(hello, world);

   System.out.println("hello: " + hello + "  world: " + world);
}

public static void addPrefix(String... elements) {
   for (int i = 0; i < elements.length; i++) {
      elements[i] = "prefix_" + elements[i];
   }

   for (int i = 0; i < elements.length; i++) {
      System.out.println(elements[i]);
   }
}

印刷结果:

prefix_hello    
prefix_world    
hello: hello  world: world

如您所见,在方法内部正确修改了值,但原始变量未更改.

我已经查看了很多页面,比如这里和这里,但似乎Java将vars的值复制到a Object[],因此引用丢失了.

知道我怎么能这样做？

在C++中是否可以将变量参数列表传递给基础构造函数？

我可以将基本构造函数的代码复制到派生类,处理变量参数列表,但这会导致不需要的代码重复.

这是我到目前为止所尝试的:

class A{
public:
  A(const char * fmt,...){
    va_list ap;
    va_start( ap, fmt );
    vprintf(fmt,ap);
    va_end(ap);
  };
};

class B: public A{
public:
  B(const char * fmt,...):A(fmt){;};
};

int main(){
  B("%d\n",42);
}

但构造函数不会将变量参数传递给基类构造函数.

为什么f()下面的代码中的第一个调用最终会打印出-2我传递给它的代码4294967294呢？

#include <stdio.h>
#include <stdint.h>
#include <stdarg.h>
#include <stdlib.h>

void f(int64_t i, ...)
{
    va_list ap;
    int64_t j;

    va_start(ap, i);
    j = va_arg(ap, int64_t);
    printf("%jd %jd\n", (intmax_t) i, (intmax_t) j);
    va_end(ap);
}

int main()
{
    f(-1, -2);           // Prints -1 4294967294 (bug!)
    f(-1, (int64_t) -2); // Prints -1 -2 (fix!)
    return 0;
}

我能理解为什么f()修复的第二次调用有效.但我无法理解为什么第一个f()电话会导致这个问题.你能解释一下这种行为吗？

我正在寻找一种优雅的方法来避免重写函数,其实现几乎相同,但只有签名(输入参数的数量和它们的数据类型)是不同的.我知道在C中不可能进行函数重载.我也知道可变函数的存在.但我认为他们在这种情况下不会有所帮助.

考虑以下问题,我们需要计算三角形的面积.我们有两个函数实现两个不同的公式:S = 1/2bh和S = sqrt(s(sa)(sb)(sc)).除了计算区域外,每个函数还修改参数nb或nthr.最后,有一个顶级例程bisect_area_...,它在给定函数上启动二分程序area_tria1或area_tria2为参数nb或函数优化它nthr.目前我明确地实现了两个二分函数:一个用于签名,area_tria1另一个用于签名area_tria2.我觉得必须有更好,更优雅的方式,才能拥有一个通用的二分函数bisect_area_tria().请注意,在实际情况中,我手边的输入参数数据类型也不同.

下面是函数签名的骨架伪代码:

// Calculate area of triangle, modify and return parameter 'nb'
void area_tria1_nb(..., int *nb, double b, double h, double *S) {

    // change parameter 'nb'
    ...

    S = 0.5*b*h;
}

// Calculate area of triangle, modify and return parameter 'nthr'
void area_tria1_nthr(..., int *nthr, double b, double h, double *S) {

    // change …

我对Java中的泛型和变量进行了一些研究,但我似乎无法找到如何将它们一起实现为创建具有灵活参数类型和数量的方法(和/或构造函数).例如,假设我想创建一个单一的方法可能需要一个整数数组或一个不固定数量的整数参数.我可以这样创建第一个:

public void example0 (int[] args) { }

和后者一样:

public void example1 (int... args) { }

但是我怎么能把它们组合成一个单一的名字呢？并且,展望未来我如何实现对多个数值类型的支持,例如float？一个例子是一个很好的答案.

更新:

谢谢,但显然我用了一个太简单的例子来表示更大的问题.考虑到任何数量的论点和任何类型,我将如何处理这个问题？所以说:

public void example(int[] args) {}
public void example(string arg0, int[] args) {}
public void example(string arg0, string arg1) {}
...

我想在不改变Child1和Child2类的情况下使以下代码工作:

#include <iostream>

int triple(int a) {
    return a * 3;
}

int add(int a, int b) {
    return a + b;
}

template<int (*F)(int)>
class Parent {
    public:
        Parent(int a) {
            std::cout << "constructed: " << F(a) << std::endl;
        }
};

class Child1 : Parent<triple> {
    public:
        Child1(int a) : Parent(a) {}
};

/*class Child2 : Parent<add> {
    public:
        Child2(int a, int b) : Parent(a, b) {}
};*/

int main() {
    Child1 child(4);
    //Child2 child(5, …