c语言含参数字符串,在C语言中模拟含有默认参数的函数

【好久没写了，来篇技术科普文】

写C++代码的时候总想当然以为C中也有含默认参数的函数这种玩意儿(值得注意的是Java也不支持而C#支持，Scala这种奇葩支持是不足为奇的)，然后在编译下面这段代码之后颜面扫尽TwT

#include "default_args.h"

void printString(const char* msg,int size,int style){

printf("%s %d %d\n",msg,size,style);

}

int main(){

printString("hello");

printString("hello",12);

printString("hello",12,bold);

}

#include

enum{

plain=0,italic=1,bold=2

};

void printString(const char* msg,int size=18,int style=italic);

nonoob@nonoobPC$ clang default_args.c -o default_args

In file included from default_args.c:1:

./default_args.h:12:42: error: C does not support default arguments

...

clang果然是人性化的编译器，还会告诉我们真实的原因；不像gcc只会报出一堆慕名奇妙的error信息，读者不妨自己尝试一下，这里就不吐槽了。至于如果我们的目的在于只要编译通过的话，那完全可以无节操地把这段代码当成C++代码，然后用clang++或g++来搞定这一切；最多只是会报出一个warning(而如果把default_args.c换成default_args.cpp的话连clang++都不报任何警告)：

clang: warning: treating 'c' input as 'c++' when in C++ mode, this behavior is deprecated

传说中程序员只关心error而不管warning，那大可就此打住并到stackoverflow的这个thread上灌水一番。不过如果是那种闲着无聊且非常执着的话(或者是那种没法用C++而只能选择C的情况，抑或是那种考虑到在其他C的源文件中用到printString()函数的情况)，那不妨往下看。一个很容易想到的解决方案自然是重载函数了(先不管效率)。在default_args.c删掉函数中的默认值并添加下面这段：

void printString(const char *msg,int size){

printString(msg,size,italic);

}

但却是：

nonoob@nonoobPC$ clang override_args.c -o override_args

override_args.c:14:6: error: conflicting types for 'printString'

又一次颜面扫尽，C原来连重载函数都不支持>_

#include

enum{

plain=0,italic=1,bold=2

};

void printString(const char* message, int size, int style) {

printf("%s %d %d\n",message,size,style);

}

#define PRINT_STRING_1_ARGS(message) printString(message, 18, italic)

#define PRINT_STRING_2_ARGS(message, size) printString(message, size, italic)

#define PRINT_STRING_3_ARGS(message, size, style) printString(message, size, style)

#define GET_4TH_ARG(arg1, arg2, arg3, arg4, ...) arg4

#define PRINT_STRING_MACRO_CHOOSER(...) \

GET_4TH_ARG(__VA_ARGS__, PRINT_STRING_3_ARGS, \

PRINT_STRING_2_ARGS, PRINT_STRING_1_ARGS, )

#define PRINT_STRING(...) PRINT_STRING_MACRO_CHOOSER(__VA_ARGS__)(__VA_ARGS__)

int main(int argc, char * const argv[]) {

PRINT_STRING("Hello, World!");

PRINT_STRING("Hello, World!", 12);

PRINT_STRING("Hello, World!", 12, bold);

return 0;

}

看到这么一坨代码，估计没几个人喜欢——宏这种对把源代码看成白盒的程序员实在不友好的东西，然而却让所有的C程序员大受其益。不妨看一下NULL的定义：

#define NULL ((void *)0)

闲话不扯了，看看前段代码是怎么回事；毕竟子曾曰过：举一隅不以三隅反，则不复也。

macro本身也不是什么见不得人的东西，说到底就是方便程序员偷懒的，在实现的最终目的上和函数没有本质区别。这里需要注意的是__VA_ARGS__这个东东。其洋名叫Variadic Macros，就是可变参数宏，在这里是配合“...”一起用的。可变参函数想必C程序员都不陌生，就是没吃过猪肉也见过猪跑是吧，比如printf；这里也有个tutorial。我们在这里需要知道的是宏定义(define)处的“...”是可以和宏使用(use)处的多个参数一起匹配的。下面以PRINT_STRING("Hello, World!", 18);为例说明是怎么展开的。

首先"Hello,World!", 12匹配PRINT_STRING_MACRO_CHOOSER(...)中的"..."，于是被扩展成：

PRINT_STRING_MACRO_CHOOSER("Hello, World!", 12)("Hello, World!", 12)；

而PRINT_STRING_MACRO_CHOOSER("Hello, World!",12)又被扩展成

GET_4TH_ARG("Hello, World!", 12, PRINT_STRING_3_ARGS, PRINT_STRING_2_ARGS, PRINT_STRING_1_ARGS, )

所以整条语句被扩展成了

GET_4TH_ARG("Hello, World!", 12, PRINT_STRING_3_ARGS, PRINT_STRING_2_ARGS, PRINT_STRING_1_ARGS, )("Hello, World!", 12);

接下来看到的是匹配#define GET_4TH_ARG(arg1,arg2,arg3,arg4, ...)arg4的情况，"Hello,World!"匹配args1,12匹配arg2，PRINT_STRING_3_ARGS匹配arg3，PRINT_STRING_2_ARGS匹配arg4，而其余, PRINT_STRING_1_ARGS, 的部分匹配了“...”，所以经过这一番扩展变成了

PRINT_STRING_2_ARGS("Hello, World!", 12);

即为

printString("Hello, World!", 12，1);

这样一番折腾终于见到庐山真面目了。当然我们可以用gnu cpp查看一下预处理的结果是不是这样的(一般来讲C和C++用preprocessor是一样的)。

...

int main(int argc, char * const argv[]) {

printString("Hello, World!", 18, italic);

printString("Hello, World!", 12, italic);

printString("Hello, World!", 12, bold);

return 0;

}

这也解释了为什么说用macro的解决方案是优雅的。不妨再看看生成的llvm的ir形式：

nonoob@nonoobPC$ clang macro.c -S -o - -emit-llvm

; ModuleID = 'macro.c'

target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32-S128"

target triple = "i386-pc-linux-gnu"

@.str = private unnamed_addr constant [10 x i8] c"%s %d %d\0A\00", align 1

@.str1 = private unnamed_addr constant [14 x i8] c"Hello, World!\00", align 1

define void @printString(i8* %message, i32 %size, i32 %style) nounwind {

%1 = alloca i8*, align 4

%2 = alloca i32, align 4

%3 = alloca i32, align 4

store i8* %message, i8** %1, align 4

store i32 %size, i32* %2, align 4

store i32 %style, i32* %3, align 4

%4 = load i8** %1, align 4

%5 = load i32* %2, align 4

%6 = load i32* %3, align 4

%7 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([10 x i8]* @.str, i32 0, i32 0), i8* %4, i32 %5, i32 %6)

ret void

}

declare i32 @printf(i8*, ...)

define i32 @main(i32 %argc, i8** %argv) nounwind {

%1 = alloca i32, align 4

%2 = alloca i32, align 4

%3 = alloca i8**, align 4

store i32 0, i32* %1

store i32 %argc, i32* %2, align 4

store i8** %argv, i8*** %3, align 4

call void @printString(i8* getelementptr inbounds ([14 x i8]* @.str1, i32 0, i32 0), i32 18, i32 1)

call void @printString(i8* getelementptr inbounds ([14 x i8]* @.str1, i32 0, i32 0), i32 12, i32 1)

call void @printString(i8* getelementptr inbounds ([14 x i8]* @.str1, i32 0, i32 0), i32 12, i32 2)

ret i32 0

}

很清爽的代码，令人心旷神怡吧。

废了这么大的力气才做了这么点事，还不如不用“默认参数”呢是吧？但是当把这个写成库的时候，或者以后要经常使用的话这就方便多了，且不容易出错！

为了无聊起见，再看看default_org.h+default_org.c用clang++/g++编译得到的llvm的ir：

nonoob@nonoobPC$ clang++ default_args.c -S -o - -emit-llvm

clang: warning: treating 'c' input as 'c++' when in C++ mode, this behavior is deprecated

; ModuleID = 'default_args.c'

target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32-S128"

target triple = "i386-pc-linux-gnu"

@.str = private unnamed_addr constant [10 x i8] c"%s %d %d\0A\00", align 1

@.str1 = private unnamed_addr constant [6 x i8] c"hello\00", align 1

define void @_Z11printStringPKcii(i8* %msg, i32 %size, i32 %style) {

%1 = alloca i8*, align 4

%2 = alloca i32, align 4

%3 = alloca i32, align 4

store i8* %msg, i8** %1, align 4

store i32 %size, i32* %2, align 4

store i32 %style, i32* %3, align 4

%4 = load i8** %1, align 4

%5 = load i32* %2, align 4

%6 = load i32* %3, align 4

%7 = call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([10 x i8]* @.str, i32 0, i32 0), i8* %4, i32 %5, i32 %6)

ret void

}

declare i32 @printf(i8*, ...)

define i32 @main() {

%1 = alloca i32, align 4

store i32 0, i32* %1

call void @_Z11printStringPKcii(i8* getelementptr inbounds ([6 x i8]* @.str1, i32 0, i32 0), i32 18, i32 1)

call void @_Z11printStringPKcii(i8* getelementptr inbounds ([6 x i8]* @.str1, i32 0, i32 0), i32 12, i32 1)

call void @_Z11printStringPKcii(i8* getelementptr inbounds ([6 x i8]* @.str1, i32 0, i32 0), i32 12, i32 2)

%2 = load i32* %1

ret i32 %2

}

从这里的IR中我们至少可以得到两点信息：

C++编译得到的函数名和C编译得到的不一样(事实上是很不一样，可以参见name mangling)，使用c++filt之后我们可以看到C++中的printString的签名实际上是void @printString(char const*, int, int)(i8* %msg, i32 %size, i32 %style)而不再是void @printString(i8* %message, i32 %size, i32 %style)。同时这也解释了为何在C中不会有函数的(静态)重载(没有OO自然动态重载更无从说起)——假设C有函数重载的话，会生成三个同名的函数，而C中调用函数时仅仅根据符号表中的函数名，这样就会造成混乱。【TODO:动态重载实现机理】

编译得到的代码中是看不到任何默认构造函数的信息的(同样连enum的信息也没有了)，3条call指令中我们得到的只不过是对应下面源代码的指令(也没有生成三个签名不同但名字相同的函数printString())。

​printString("hello"，18，1);

printString("hello",12，1);

printString("hello",12,2);

到此为止，正文结束。下面贴捣鼓的一段含宏的代码~~

#include

#include

#define LOGSTRING(fm,...) printf(fm,__VA_ARGS__)

#define MY_DEBUG(format,...) fprintf(stderr,NEWLINE(format),##__VA_ARGS__);

#define NEWLINE(str) str "\n"

#define GCC_DBG(format,args...) fprintf(stderr,format,##args)

#define DEBUG(args) (printf("DEBUG: "), printf args)

#define STRING(str) #str

#define NULL 3

int main(int argc,char**argv){

LOGSTRING("Hello %s %s\n","Hong""xu","Chen");

MY_DEBUG("my debug")

GCC_DBG("gcc dbg\n");

int n = 0;

if (n != NULL) DEBUG(("n is %d\n", n));

puts(STRING(It really Compiles!));

return 0;

}

参考资料：

http://stackoverflow.com/questions/3046889/optional-parameters-with-c-macros

http://www.cnblogs.com/alexshi/archive/2012/03/09/2388453.html