Variadic function: Difference between revisions

Revision as of 23:41, 7 June 2025

Latest revision as of 17:32, 28 August 2025

(One intermediate revision by one other user not shown)

Line 20:

===In C===

To portably implement variadic functions in the [[C (programming language)|C language]], the standard [[stdarg.h|{{code|stdarg.h}}]] header file is used. The older [[varargs.h|{{code|varargs.h}}]] header has been [[Deprecation|deprecated]] in favor of {{code|stdarg.h}}. In C++, the header file {{code|cstdarg}} is used.<ref>{{cite web|url=http://www.cplusplus.com/reference/clibrary/cstdarg/|title=<cstdarg> (stdarg.h) - C++ Reference|website=www.cplusplus.com|access-date=2007-10-02|archive-date=2012-10-31|archive-url=https://web.archive.org/web/20121031160547/http://www.cplusplus.com/reference/clibrary/cstdarg/|url-status=dead}}</ref>

<syntaxhighlight lang="C">

Line 28:

double average(int count, ...) {

va_list ap;

int j;

double sum = 0;

va_start(ap, count); /*/ Before C23: Requires the last fixed parameter (to get the address) */

for (int j = 0; j < count; j++j) {

sum += va_arg(ap, int); /* Increments ap to the next argument. */

}

Line 40 ⟶ 39:

}

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

printf("%f\n", average(3, 1, 2, 3));

return 0;

Line 86 ⟶ 85:

<syntaxhighlight lang="c++">

import std;

#include <iostream>

#include <cstdarg>

void simple_printf(const char* fmt...) // C-style "const char* fmt, ..." is also valid

void simple_printf(const char* fmt...) {

{

va_list args;

va_start(args, fmt);

Line 97 ⟶ 95:

if (*fmt == 'd') {

int i = va_arg(args, int);

std::cout <<println("{}", i << '\n');

} else if (*fmt == 'c') {

// note automatic conversion to integral type

int c = va_arg(args, int);

std::cout <<println("{}", static_cast<char>(c) << '\n');

} else if (*fmt == 'f') {

double d = va_arg(args, double);

std::cout <<println("{}", d << '\n');

}

++fmt;

Line 112 ⟶ 110:

}

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

{

simple_printf("dcff", 3, 'a', 1.999, 42.5);

}

Line 121 ⟶ 118:

<syntaxhighlight lang="c++">

import std;

#include <iostream>

template <typename... Ts>

void foo_printfooPrint(Ts... args) {

((std::coutprint("{} <<", args << ' ')), ...);

{

((std::cout << args << ' '), ...);

}

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

foo_printfooPrint(1, 3.14f); // 1 3.14

{

foo_printfooPrint("Foo", 'b', true, nullptr); // Foo b true nullptr

std::cout << std::boolalpha;

foo_print(1, 3.14f); // 1 3.14

foo_print("Foo", 'b', true, nullptr); // Foo b true nullptr

}

</syntaxhighlight>

Line 243 ⟶ 237:

// variable-length array of `String`s.

private static void printArgs(String... strings) {

for (String strings : strings) {

System.out.println(strings);

}

}

Line 353 ⟶ 347:

<syntaxhighlight lang="python">

from typing import Any

def foo(a, b, *args):

def foo(a: Any, b: Any, *args: Any) -> None:

print(args) # args is a tuple (immutable sequence).

if __name__ == "__main__":

foo(1, 2) # ()

foo(1, 2, 3) # (3,)

foo(1, 2, 3, "hello") # (3, "hello")

foo(1, 2, 3, "hello") # (3, "hello")

</syntaxhighlight>

Keyword arguments can be stored in a dictionary, e.g. {{code|def bar(*args: Any, **kwargs: Any) -> Any}}.

===In Raku===

Line 426 ⟶ 423:

=== In Rust ===

[[Rust (programming language)|Rust]] does not support variadic arguments in functions. Instead, it uses [[Macro (computer science)|macros]], which support variadic arguments.<ref>{{cite web |title=Variadics |url=https://doc.rust-lang.org/rust-by-example/macros/variadics.html |website=Rust By Example}}</ref> This is essentially why <code>println!</code> is a macro and not a function, as it takes variadic arguments to format.

<syntaxhighlight lang="rust">

Line 446 ⟶ 443:

fn main() {

calculate! { // Look ma! Variadic `calculate!`!\

eval 1 + 2,

eval 3 + 4,