blocks|key|575517|text|我只能想到这样的事情：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|575518|#include+<stddef.h>
#include+<stdio.h>
#include+<stdlib.h>

typedef+struct+tArg
{
++const+char*+Str;
++struct+tArg*+Next;
}+tArg;

tArg*+Arg(const+char*+str,+tArg*+nextArg)
{
++tArg*+p+=+malloc(sizeof(tArg));
++if+(p+!=+NULL)
++{
++++p->Str+=+str;
++++p->Next+=+nextArg;
++}
++else
++{
++++while+(nextArg+!=+NULL)
++++{
++++++p+=+nextArg->Next;
++++++free(nextArg);
++++++nextArg+=+p;
++++}
++}
++return+p;
}

void+PrintR(tArg*+arg)
{
++while+(arg+!=+NULL)
++{
++++tArg*+p;
++++printf("%25s",+arg->Str);
++++p+=+arg->Next;
++++free(arg);
++++arg+=+p;
++}
}

void+(*(*(*(*(*(*(*Print8
++(const+char*+Str))
++(const+char*))
++(const+char*))
++(const+char*))
++(const+char*))
++(const+char*))
++(const+char*))
++(const+char*)
{
++printf("%25s",+Str);
++//+There's+probably+a+UB+here:
++return+(void(*(*(*(*(*(*(*)
++++(const+char*))
++++(const+char*))
++++(const+char*))
++++(const+char*))
++++(const+char*))
++++(const+char*))
++++(const+char*))&Print8;
}

int+main(void)
{
++PrintR(Arg("HELLO",+Arg("+",+Arg("WORLD",+Arg("!",+Arg("\n",+NULL))))));
//++PrintR(Arg(1,+NULL));++++++++//+warning/error
//++PrintR(Arg(&main,+NULL));++++//+warning/error
//++PrintR(Arg(0,+NULL));++++++++//+no+warning/error
//++PrintR(Arg((void*)1,+NULL));+//+no+warning/error

++Print8("hello")("+")("world")("!")("\n");
//+Same+warning/error+compilation+behavior+as+with+PrintR()
++return+0;
}|code-block|syntax|javascript|575519|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I can only think of something like this:

<pre><code>#include &lt;stddef.h&gt;
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

typedef struct tArg
{
 const char* Str;
 struct tArg* Next;
} tArg;

tArg* Arg(const char* str, tArg* nextArg)
{
 tArg* p = malloc(sizeof(tArg));
 if (p != NULL)
 {
 p-&gt;Str = str;
 p-&gt;Next = nextArg;
 }
 else
 {
 while (nextArg != NULL)
 {
 p = nextArg-&gt;Next;
 free(nextArg);
 nextArg = p;
 }
 }
 return p;
}

void PrintR(tArg* arg)
{
 while (arg != NULL)
 {
 tArg* p;
 printf("%s", arg-&gt;Str);
 p = arg-&gt;Next;
 free(arg);
 arg = p;
 }
}

void (*(*(*(*(*(*(*Print8
 (const char* Str))
 (const char*))
 (const char*))
 (const char*))
 (const char*))
 (const char*))
 (const char*))
 (const char*)
{
 printf("%s", Str);
 // There's probably a UB here:
 return (void(*(*(*(*(*(*(*)
 (const char*))
 (const char*))
 (const char*))
 (const char*))
 (const char*))
 (const char*))
 (const char*))&amp;Print8;
}

int main(void)
{
 PrintR(Arg("HELLO", Arg(" ", Arg("WORLD", Arg("!", Arg("\n", NULL))))));
// PrintR(Arg(1, NULL)); // warning/error
// PrintR(Arg(&amp;main, NULL)); // warning/error
// PrintR(Arg(0, NULL)); // no warning/error
// PrintR(Arg((void*)1, NULL)); // no warning/error

 Print8("hello")(" ")("world")("!")("\n");
// Same warning/error compilation behavior as with PrintR()
 return 0;
}
</code></pre>

blocks|key|359831|text|C+variadics的问题在于，它们确实是后来才被固定住的，而不是真正设计到语言中的。主要的问题是可变参数是匿名的，它们没有句柄，没有标识符。这导致使用笨重的VA宏来生成对没有名称的参数的引用。这也导致需要告诉这些宏，可变列表从哪里开始，以及参数应该是什么类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|359832|所有这些信息都应该在语言本身中以适当的语法进行编码。|359833|例如，可以在省略号后面添加形式参数来扩展现有的C语法，如下所示|359834|void+foo+(+...+int+counter,+float+arglist+);|code-block|syntax|javascript|359835|按照惯例，第一个参数可以用于参数计数，第二个参数可以用于参数列表。在函数体中，列表可以在语法上视为一个数组。|359836|有了这样的约定，可变参数将不再是匿名的。在函数体中，可以像引用任何其他参数一样引用计数器，并且可以像引用数组参数的数组元素一样引用列表元素，如下所示|359837|void+foo+(+...+int+counter,+float+arglist+)+{
++unsigned+i;
++for+(i=0;+i<counter;+i%2B%2B)+{
++++printf("list[%25i]+=+%25f\n",+i,+arglist[i]);
++}
}|359838|有了这样一个内置到语言本身的功能，每个对arglist[i]的引用都将被转换为堆栈帧上的相应地址。不需要通过宏来做到这一点。|offset|length|style|CODE|359839|此外，参数计数将由编译器自动插入，从而进一步减少出错的机会。|359840|调用|359841|foo(1.23,+4.56,+7.89);|359842|将被编译，就像它已经被编写一样。|359843|foo(3,+1.23,+4.56,+7.89);|359844|在函数体中，对超过实际传递的参数数量的元素的任何访问都可以在运行时进行检查，并导致编译时错误，从而大大增强安全性。|359845|最后但并非最不重要的是，所有变量参数都是类型化的，并且可以在编译时进行类型检查，就像检查非变量参数一样。|359846|在一些用例中，当然希望有交替的类型，例如当编写一个函数来存储集合中的键和值时。这也可以通过在省略号后允许更多的形式参数来实现，如下所示|359847|void+store+(+collection+dict,+...+int+counter,+key_t+key,+val_t+value+);|359848|然后，该函数可以被调用为|359849|store(dict,+key1,+val1,+key2,+val2,+key3,+val3);|359850|，但会被编译，就好像它是被编写的。|359851|store(dict,+3,+key1,+val1,+key2,+val2,+key3,+val3);|359852|实际参数的类型将在编译时对照相应的可变形式参数进行检查。|359853|在函数的主体内，计数器将再次被其标识符引用，键和值将被引用，就好像它们是数组一样，|359854|key[i]指的是第i个键/值对的键value[i]指的是第i个值对的值|359855|并且这些引用将被编译成它们在堆栈帧上的相应地址。|359856|所有这些都不是真的很难做到，从来都不是。然而，C语言的设计哲学根本不利于这些特性。|359857|如果没有一个大胆的C编译器实现者(或C预处理器实现者)带头实现这个或类似的方案，我们就不太可能在C中看到这样的东西。|359858|问题是，那些对类型安全感兴趣并愿意投入工作构建自己的编译器的人通常会得出结论，C语言已经无可救药了，人们不妨从一种设计得更好的语言开始。|359859|我自己也经历过，最终决定放弃这种尝试，然后实现Wirth的一种语言，并添加了类型安全变量。从那以后，我遇到了其他人，他们告诉我他们自己的尝试失败了。正确的类型安全变种在C中似乎仍然难以捉摸。|359860|entityMap^0|0|0|0|0|0|0|0|K|A|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|6|I|8|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|24|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|25|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|26|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|27|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|28|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|29|8|@]|9|@]|A|$]]|$1|O|3|P|5|H|7|2A|8|@]|9|@]|A|$I|J]]|$1|Q|3|R|5|6|7|2B|8|@$S|2C|T|2D|U|V]]|9|@]|A|$]]|$1|W|3|X|5|6|7|2E|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|2F|8|@]|9|@]|A|$]]|$1|10|3|11|5|H|7|2G|8|@]|9|@]|A|$I|J]]|$1|12|3|13|5|6|7|2H|8|@]|9|@]|A|$]]|$1|14|3|15|5|H|7|2I|8|@]|9|@]|A|$I|J]]|$1|16|3|17|5|6|7|2J|8|@]|9|@]|A|$]]|$1|18|3|19|5|6|7|2K|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|6|7|2L|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|H|7|2M|8|@]|9|@]|A|$I|J]]|$1|1E|3|1F|5|6|7|2N|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|H|7|2O|8|@]|9|@]|A|$I|J]]|$1|1I|3|1J|5|6|7|2P|8|@]|9|@]|A|$]]|$1|1K|3|1L|5|H|7|2Q|8|@]|9|@]|A|$I|J]]|$1|1M|3|1N|5|6|7|2R|8|@]|9|@]|A|$]]|$1|1O|3|1P|5|6|7|2S|8|@]|9|@]|A|$]]|$1|1Q|3|1R|5|6|7|2T|8|@$S|2U|T|2V|U|V]|$S|2W|T|2X|U|V]]|9|@]|A|$]]|$1|1S|3|1T|5|6|7|2Y|8|@]|9|@]|A|$]]|$1|1U|3|1V|5|6|7|2Z|8|@]|9|@]|A|$]]|$1|1W|3|1X|5|6|7|30|8|@]|9|@]|A|$]]|$1|1Y|3|1Z|5|6|7|31|8|@]|9|@]|A|$]]|$1|20|3|21|5|6|7|32|8|@]|9|@]|A|$]]|$1|22|3|-4|5|6|7|33|8|@]|9|@]|A|$]]]|23|$]]

The problem with C variadics is that they are really bolted on afterwards, not really designed into the language. The main problem is that the variadic parameters are anonymous, they have no handles, no identifiers. This leads to the unwieldy VA macros to generate references to parameters without names. It also leads to the need to tell those macros where the variadic list starts and what type the parameters are expected to be of.

All this information really ought to be encoded in proper syntax in the language itself.

For example, one could extend existing C syntax with formal parameters after the ellipsis, like so

<pre><code>void foo ( ... int counter, float arglist );
</code></pre>

By convention, the first parameter could be for the argument count and the second for the argument list. Within the function body, the list could be treated syntactically as an array.

With such a convention, the variadic parameters would no longer be anonymous. Within the function body, the counter can be referenced like any other parameter and the list elements can be referenced as if they were array elements of an array parameter, like so

<pre><code>void foo ( ... int counter, float arglist ) {
 unsigned i;
 for (i=0; i&lt;counter; i++) {
 printf("list[%i] = %f\n", i, arglist[i]);
 }
}
</code></pre>

With such a feature built into the language itself, every reference to <code>arglist[i]</code> would then be translated to the respective addresses on the stack frame. There would be no need to do this via macros.

Furthermore, the argument count would automatically be inserted by the compiler, further reducing opportunity for error.

A call to

<pre><code>foo(1.23, 4.56, 7.89);
</code></pre>

would be compiled as if it had been written

<pre><code>foo(3, 1.23, 4.56, 7.89);
</code></pre>

Within the function body, any access to an element beyond the actual number of arguments actually passed could be checked at runtime and cause a compile time fault, thereby greatly enhancing safety.

Last but not least, all the variadic parameters are typed and can be type checked at compile time just like non-variadic parameters are checked.

In some use cases it would of course be desirable to have alternating types, such as when writing a function to store keys and values in a collection. This could also be accommodated simply by allowing more formal parameters after the ellipsis, like so

<pre><code>void store ( collection dict, ... int counter, key_t key, val_t value );
</code></pre>

This function could then be called as

<pre><code>store(dict, key1, val1, key2, val2, key3, val3);
</code></pre>

but would be compiled as if it had been written

<pre><code>store(dict, 3, key1, val1, key2, val2, key3, val3);
</code></pre>

The types of actual parameters would be compile time checked against the corresponding variadic formal parameters.

Within the body of the function the counter would again be referenced by its identifier, keys and values would be referenced as if they were arrays,

<code>key[i]</code> refers to the key of the i-th key/value pair
<code>value[i]</code> refers to the value of the i-th value pair

and these references would be compiled to their respective addresses on the stack frame.

None of this is really difficult to do, nor has it ever been. However, C's design philosophy simply isn't conducive to such features.

Without a venturing C compiler implementor (or C preprocessor implementor) taking the lead to implement this or a similar scheme it is unlikely we will ever see anything of this kind in C.

The trouble is that folks who are interested in type safety and willing to put in the work to build their own compilers usually come to the conclusion that the C language is beyond salvage and one may as well start over with a better designed language to begin with.

I have been there myself, eventually decided to abandon the attempt, then implement one of Wirth's languages and added type safe variadics to that instead. I have since run into other people who told me about their own aborted attempts. Proper type safe variadics in C seem poised to remain elusive.

Many times I want a function to receive a variable number of arguments, terminated by NULL, for instance

<pre><code>#define push(stack_t stack, ...) _push(__VARARG__, NULL);
func _push(stack_t stack, char *s, ...) {
 va_list args;
 va_start(args, s);
 while (s = va_arg(args, char*)) push_single(stack, s);
}
</code></pre>

Can I instruct gcc or clang to warn if foo receives non <code>char*</code> variables? Something similar to <code>__attribute__(format)</code>, but for multiple arguments of the same pointer type.

Typesafe varargs in C with gcc

编译器

很多时候，我希望一个函数接收可变数量的参数，例如，以NULL结尾#define push(stack_t stack, ...) _push(__VARARG__, NULL);func _push(stack_t stack, char *s, ...) {    va_list args;    va_start(...

问用C语言编写的Typesafe varargs与gcc
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问用C语言编写的Typesafe varargs与gccEN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问用C语言编写的Typesafe varargs与gcc
EN