C默认参数

时间：2009-09-24 14:38:20

标签： c arguments default-parameters

有没有办法在C中为函数指定默认参数？

19 个答案:

答案 0 :(得分：253)

哇，每个人都是这样的悲观主义者。答案是肯定的。

这不是微不足道的：到最后，我们将拥有核心功能，支持结构，包装函数和宏 包装函数周围。在我的工作中，我有一组宏来自动化所有这些;一旦 你了解流程，你也很容易做到这一点。

我已经在其他地方写了这篇文章，所以这里有一个详细的外部链接来补充摘要：http://modelingwithdata.org/arch/00000022.htm

我们想转

double f(int i, double x)

进入一个默认值的函数（i = 8，x = 3.14）。定义一个伴随结构：

typedef struct {
    int i;
    double x;
} f_args;

重命名函数f_base，并定义一个设置默认值和调用的包装函数 基地：

double var_f(f_args in){
    int i_out = in.i ? in.i : 8;
    double x_out = in.x ? in.x : 3.14;
    return f_base(i_out, x_out);
}

现在使用C的可变参数宏添加一个宏。这样用户就不必知道它们了 实际上填充f_args结构并认为它们正常做：

#define f(...) var_f((f_args){__VA_ARGS__});

好的，现在以下所有方法都有效：

f(3, 8);      //i=3, x=8
f(.i=1, 2.3); //i=1, x=2.3
f(2);         //i=2, x=3.14
f(.x=9.2);    //i=8, x=9.2

检查复合初始化程序如何为确切规则设置默认值的规则。

有一件事不起作用：f(0)，因为我们无法区分缺失值和 零。根据我的经验，这是需要注意的事项，但可以照顾 需要出现---你的默认值为零的一半时间。

我经历了写这篇文章的麻烦，因为我认为命名参数和默认值  真的让C中的编码变得更容易，更有趣。和 C非常棒，因为它非常简单，而且还有足够的能力使这一切成为可能。

答案 1 :(得分：151)

是。 :-)但不是你期望的方式。

int f1(int arg1, double arg2, char* name, char *opt);

int f2(int arg1, double arg2, char* name)
{
  return f1(arg1, arg2, name, "Some option");
}

不幸的是，C不允许你重载方法，所以你最终会得到两个不同的功能。仍然，通过调用f2，你实际上是用默认值调用f1。这是一个“不要重复自己”的解决方案，它可以帮助您避免复制/粘贴现有​​代码。

答案 2 :(得分：127)

不是真的。唯一的方法是write a varargs function并手动填写调用者未传递的参数的默认值。

答案 3 :(得分：39)

我们可以创建使用命名参数（仅）作为默认值的函数。这是bk。答案的延续。

#include <stdio.h>                                                               

struct range { int from; int to; int step; };
#define range(...) range((struct range){.from=1,.to=10,.step=1, __VA_ARGS__})   

/* use parentheses to avoid macro subst */             
void (range)(struct range r) {                                                     
    for (int i = r.from; i <= r.to; i += r.step)                                 
        printf("%d ", i);                                                        
    puts("");                                                                    
}                                                                                

int main() {                                                                     
    range();                                                                    
    range(.from=2, .to=4);                                                      
    range(.step=2);                                                             
}

C99标准定义了初始化中的后续名称会覆盖以前的项目。我们也可以有一些标准的位置参数，只需相应地改变宏和函数签名。默认值参数只能在命名参数样式中使用。

节目输出：

1 2 3 4 5 6 7 8 9 10 
2 3 4 
1 3 5 7 9

答案 4 :(得分：20)

OpenCV使用类似的内容：

/* in the header file */

#ifdef __cplusplus
    /* in case the compiler is a C++ compiler */
    #define DEFAULT_VALUE(value) = value
#else
    /* otherwise, C compiler, do nothing */
    #define DEFAULT_VALUE(value)
#endif

void window_set_size(unsigned int width  DEFAULT_VALUE(640),
                     unsigned int height DEFAULT_VALUE(400));

如果用户不知道他应该写什么，这个技巧可能会有所帮助：

usage example

答案 5 :(得分：18)

没有

即使是最新的C99标准也不支持此功能。

答案 6 :(得分：17)

不，这是一种C ++语言功能。

答案 7 :(得分：13)

简答：否。

答案稍长：有一个旧的旧解决方法，您可以在其中传递一个解析的字符串作为可选参数：

int f(int arg1, double arg2, char* name, char *opt);

其中opt可能包含“name = value”对或其他内容，您可以将其称为

n = f(2,3.0,"foo","plot=yes save=no");

显然，这只是偶尔有用。通常，当您需要单个接口来实现一系列功能时。

你仍然可以在粒子物理代码中找到这种方法，这些代码是由c ++中的专业程序编写的（例如ROOT）。它的主要优点是它几乎可以无限延长，同时保持背部兼容性。

答案 8 :(得分：13)

另一个选项使用struct s：

struct func_opts {
  int    arg1;
  char * arg2;
  int    arg3;
};

void func(int arg, struct func_opts *opts)
{
    int arg1 = 0, arg3 = 0;
    char *arg2 = "Default";
    if(opts)
      {
        if(opts->arg1)
            arg1 = opts->arg1;
        if(opts->arg2)
            arg2 = opts->arg2;
        if(opts->arg3)
            arg3 = opts->arg3;
      }
    // do stuff
}

// call with defaults
func(3, NULL);

// also call with defaults
struct func_opts opts = {0};
func(3, &opts);

// set some arguments
opts.arg3 = 3;
opts.arg2 = "Yes";
func(3, &opts);

答案 9 :(得分：13)

执行此操作的最佳方法（根据您的具体情况，可能会或可能不是这种情况）可能是转向C ++并将其用作“更好的C”。您可以在不使用类，模板，运算符重载或其他高级功能的情况下使用C ++。

这将为您提供具有函数重载和默认参数（以及您选择使用的任何其他功能）的C变体。如果你真的认真地只使用C ++的有限子集，你就必须要有点自律。

很多人会说以这种方式使用C ++是一个糟糕的主意，他们可能会有一个观点。但这只是一种观点;我认为使用你熟悉的C ++功能是有效的，而不必购买整个东西。我认为C ++成功的一个重要原因在于它早期就被很多程序员用于这种方式。

答案 10 :(得分：8)

没有。

答案 11 :(得分：4)

是的，有了C99的功能，你可以这样做。这可以在不定义新数据结构的情况下工作，并且没有函数必须在运行时决定它是如何被调用的，并且 没有任何计算开销。

有关详细说明，请参阅我的帖子

http://gustedt.wordpress.com/2010/06/03/default-arguments-for-c99/

延

答案 12 :(得分：3)

一般情况下没有，但是在gcc中你可以用宏来使funcA（）的最后一个参数可选。

在funcB（）中，我使用特殊值（-1）表示我需要'b'参数的默认值。

#include <stdio.h> 

int funcA( int a, int b, ... ){ return a+b; }
#define funcA( a, ... ) funcA( a, ##__VA_ARGS__, 8 ) 


int funcB( int a, int b ){
  if( b == -1 ) b = 8;
  return a+b;
}

int main(void){
  printf("funcA(1,2): %i\n", funcA(1,2) );
  printf("funcA(1):   %i\n", funcA(1)   );

  printf("funcB(1, 2): %i\n", funcB(1, 2) );
  printf("funcB(1,-1): %i\n", funcB(1,-1) );
}

答案 13 :(得分：3)

不，但您可以考虑使用函数（或宏）的 set 来近似使用默认参数：

// No default args
int foo3(int a, int b, int c)
{
    return ...;
}

// Default 3rd arg
int foo2(int a, int b)
{
    return foo3(a, b, 0);  // default c
}

// Default 2nd and 3rd args
int foo1(int a)
{
    return foo3(a, 1, 0);  // default b and c
}

答案 14 :(得分：1)

我改进了Jens Gustedt的answer，以便：

  1. 不使用内联函数
  2. 在预处理期间计算默认值
  3. 模块化可重用宏
  4. 可能设置编译器错误，该错误与允许的默认值
    5. 的参数不足的情况有意义地匹配
  5. 如果参数类型保持明确，则不需要默认值来形成参数列表的尾部
  6. 与C11 _Generic
    7. 互操作
  7. 根据参数数量改变函数名称！

    8. variadic.h：

    #ifndef VARIADIC

#define _NARG2(_0, _1, _2, ...) _2
#define NUMARG2(...) _NARG2(__VA_ARGS__, 2, 1, 0)
#define _NARG3(_0, _1, _2, _3, ...) _3
#define NUMARG3(...) _NARG3(__VA_ARGS__, 3, 2, 1, 0)
#define _NARG4(_0, _1, _2, _3, _4, ...) _4
#define NUMARG4(...) _NARG4(__VA_ARGS__, 4, 3, 2, 1, 0)
#define _NARG5(_0, _1, _2, _3, _4, _5, ...) _5
#define NUMARG5(...) _NARG5(__VA_ARGS__, 5, 4, 3, 2, 1, 0)
#define _NARG6(_0, _1, _2, _3, _4, _5, _6, ...) _6
#define NUMARG6(...) _NARG6(__VA_ARGS__, 6, 5, 4, 3, 2, 1, 0)
#define _NARG7(_0, _1, _2, _3, _4, _5, _6, _7, ...) _7
#define NUMARG7(...) _NARG7(__VA_ARGS__, 7, 6, 5, 4, 3, 2, 1, 0)
#define _NARG8(_0, _1, _2, _3, _4, _5, _6, _7, _8, ...) _8
#define NUMARG8(...) _NARG8(__VA_ARGS__, 8, 7, 6, 5, 4, 3, 2, 1, 0)
#define _NARG9(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, ...) _9
#define NUMARG9(...) _NARG9(__VA_ARGS__, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
#define __VARIADIC(name, num_args, ...) name ## _ ## num_args (__VA_ARGS__)
#define _VARIADIC(name, num_args, ...) name (__VARIADIC(name, num_args, __VA_ARGS__))
#define VARIADIC(name, num_args, ...) _VARIADIC(name, num_args, __VA_ARGS__)
#define VARIADIC2(name, num_args, ...) __VARIADIC(name, num_args, __VA_ARGS__)

// Vary function name by number of arguments supplied
#define VARIADIC_NAME(name, num_args) name ## _ ## num_args ## _name ()
#define NVARIADIC(name, num_args, ...) _VARIADIC(VARIADIC_NAME(name, num_args), num_args, __VA_ARGS__)

#endif

    简化使用方案：

    const uint32*
uint32_frombytes(uint32* out, const uint8* in, size_t bytes);

/*
The output buffer defaults to NULL if not provided.
*/

#include "variadic.h"

#define uint32_frombytes_2(   b, c) NULL, b, c
#define uint32_frombytes_3(a, b, c)    a, b, c
#define uint32_frombytes(...) VARIADIC(uint32_frombytes, NUMARG3(__VA_ARGS__), __VA_ARGS__)

    使用_Generic：

    const uint8*
uint16_tobytes(const uint16* in, uint8* out, size_t bytes);

const uint16*
uint16_frombytes(uint16* out, const uint8* in, size_t bytes);

const uint8*
uint32_tobytes(const uint32* in, uint8* out, size_t bytes);

const uint32*
uint32_frombytes(uint32* out, const uint8* in, size_t bytes);

/*
The output buffer defaults to NULL if not provided.
Generic function name supported on the non-uint8 type, except where said type
is unavailable because the argument for output buffer was not provided.
*/

#include "variadic.h"

#define   uint16_tobytes_2(a,    c) a, NULL, c
#define   uint16_tobytes_3(a, b, c) a,    b, c
#define   uint16_tobytes(...) VARIADIC(  uint16_tobytes, NUMARG3(__VA_ARGS__), __VA_ARGS__)

#define uint16_frombytes_2(   b, c) NULL, b, c
#define uint16_frombytes_3(a, b, c)    a, b, c
#define uint16_frombytes(...) VARIADIC(uint16_frombytes, NUMARG3(__VA_ARGS__), __VA_ARGS__)

#define   uint32_tobytes_2(a,    c) a, NULL, c
#define   uint32_tobytes_3(a, b, c) a,    b, c
#define   uint32_tobytes(...) VARIADIC(  uint32_tobytes, NUMARG3(__VA_ARGS__), __VA_ARGS__)

#define uint32_frombytes_2(   b, c) NULL, b, c
#define uint32_frombytes_3(a, b, c)    a, b, c
#define uint32_frombytes(...) VARIADIC(uint32_frombytes, NUMARG3(__VA_ARGS__), __VA_ARGS__)

#define   tobytes(a, ...) _Generic((a),                                                                                                 \
                                   const uint16*: uint16_tobytes,                                                                       \
                                   const uint32*: uint32_tobytes)  (VARIADIC2(  uint32_tobytes, NUMARG3(a, __VA_ARGS__), a, __VA_ARGS__))

#define frombytes(a, ...) _Generic((a),                                                                                                 \
                                         uint16*: uint16_frombytes,                                                                     \
                                         uint32*: uint32_frombytes)(VARIADIC2(uint32_frombytes, NUMARG3(a, __VA_ARGS__), a, __VA_ARGS__))

    使用可变函数名称选择，它不能与_Generic结合使用：

    // winternitz() with 5 arguments is replaced with merkle_lamport() on those 5 arguments.

#define   merkle_lamport_5(a, b, c, d, e) a, b, c, d, e
#define   winternitz_7(a, b, c, d, e, f, g) a, b, c, d, e, f, g
#define   winternitz_5_name() merkle_lamport
#define   winternitz_7_name() winternitz
#define   winternitz(...) NVARIADIC(winternitz, NUMARG7(__VA_ARGS__), __VA_ARGS__)

答案 15 :(得分：1)

使用宏的另一种技巧：

#include <stdio.h>

#define func(...) FUNC(__VA_ARGS__, 15, 0)
#define FUNC(a, b, ...) func(a, b)

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

int main(void)
{
    printf("%d\n", func(1));
    printf("%d\n", func(1, 2));
    return 0;
}

如果仅传递一个参数，则b会收到默认值（在本例中为15）

答案 16 :(得分：0)

是的，你可以做类似的事情，在这里你必须知道你可以得到的不同的参数列表，但你有相同的功能来处理所有。

typedef enum { my_input_set1 = 0, my_input_set2, my_input_set3} INPUT_SET;

typedef struct{
    INPUT_SET type;
    char* text;
} input_set1;

typedef struct{
    INPUT_SET type;
    char* text;
    int var;
} input_set2;

typedef struct{
    INPUT_SET type;
    int text;
} input_set3;

typedef union
{
    INPUT_SET type;
    input_set1 set1;
    input_set2 set2;
    input_set3 set3;
} MY_INPUT;

void my_func(MY_INPUT input)
{
    switch(input.type)
    {
        case my_input_set1:
        break;
        case my_input_set2:
        break;
        case my_input_set3:
        break;
        default:
        // unknown input
        break;
    }
}

答案 17 :(得分：0)

是

通过宏

3个参数： 

#define my_func2(...) my_func3(__VA_ARGS__, 0.5)
#define my_func1(...) my_func2(__VA_ARGS__, 10)
#define VAR_FUNC(_1, _2, _3, NAME, ...) NAME
#define my_func(...) VAR_FUNC(__VA_ARGS__, my_func3, my_func2, my_func1)(__VA_ARGS__)

void my_func3(char a, int b, float c) // b=10, c=0.5
{
    printf("a=%c; b=%d; c=%f\n", a, b, c);
}

如果要使用第4个参数，则需要添加一个额外的my_func3。注意VAR_FUNC，my_func2和my_func

中的更改

4个参数： 

#define my_func3(...) my_func4(__VA_ARGS__, "default") // <== New function added
#define my_func2(...) my_func3(__VA_ARGS__, (float)1/2)
#define my_func1(...) my_func2(__VA_ARGS__, 10)
#define VAR_FUNC(_1, _2, _3, _4, NAME, ...) NAME
#define my_func(...) VAR_FUNC(__VA_ARGS__, my_func4, my_func3, my_func2, my_func1)(__VA_ARGS__)

void my_func4(char a, int b, float c, const char* d) // b=10, c=0.5, d="default"
{
    printf("a=%c; b=%d; c=%f; d=%s\n", a, b, c, d);
}

仅例外地不能为浮点变量赋予默认值（除非它是最后一个参数，如在3个参数的情况下），因为它们需要句点（'。 '），宏参数中不接受。但是可以找出解决方法，如my_func2宏（在4个参数的情况下为 ）

程序

int main(void)
{
    my_func('a');
    my_func('b', 20);
    my_func('c', 200, 10.5);
    my_func('d', 2000, 100.5, "hello");

    return 0;
}

输出：

a=a; b=10; c=0.500000; d=default                                                                                                                                                  
a=b; b=20; c=0.500000; d=default                                                                                                                                                  
a=c; b=200; c=10.500000; d=default                                                                                                                                                
a=d; b=2000; c=100.500000; d=hello

答案 18 :(得分：-5)

为什么我们不能这样做。

为可选参数指定默认值。这样，函数的调用者不一定需要传递参数的值。该参数采用默认值。 很容易，这个论点成为客户的选择。

例如

void foo（int a，int b = 0）;

这里b是一个可选参数。

相关问题
最新问题