Variable Number of Parameters - D Programming Language
Description: D Programming Language
Keywords: D programming language

Menu

- Learn
- Documentation
  - Language Reference
  - Library Reference
  - Command-line Reference
  - Feature Overview
  - Articles
- Downloads
- Packages
- Community
  - Blog
  - Orgs using D
  - Twitter
  - Calendar
  - Discord (community-run)
  - Forums
  - IRC
  - Wiki
  - Issues
  - Contributing
  - Contributors
  - Foundation
  - Security Team
  - Donate
  - Sponsors
- Resources
  - Tour
  - Books
  - Tutorials
  - Tools
  - Editors
  - IDEs
  - run.dlang.io
  - Visual D
  - Acknowledgments
  - D Style
  - Glossary
  - Sitemap

Search
Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using a local clone.

# Variable Number of Parameters

This chapter covers two D features that bring flexibility on parameters when calling functions:

- Default arguments
- Variadic functions

##### Default arguments

A convenience with function parameters is the ability to specify default values for them. This is similar to the default initial values of struct members.

Some of the parameters of some functions are called mostly by the same values. To see an example of this, let's consider a function that prints the elements of an associative array of type `string[string]`. Let's assume that the function takes the separator characters as parameters as well:

    import std.algorithm;

    // ...

    void printAA(string title,
                 string[string] aa,
                 string keySeparator,
                 string elementSeparator) {
        writeln("-- ", title, " --");

        auto keys = sort(aa.keys);

        // Don't print element separator before the first element
        if (keys.length != 0) {
            auto key = keys[0];
            write(key, keySeparator, aa[key]);
            keys = keys[1..$];    // Remove the first element
        }

        // Print element separator before the remaining elements
        foreach (key; keys) {
            write(elementSeparator);
            write(key, keySeparator, aa[key]);
        }

        writeln();
    }

That function is being called below with `":"` as the key separator and `", "` as the element separator:

    void main() {
        string[string] dictionary = [
            "blue":"mavi", "red":"kırmızı", "gray":"gri" ];

        printAA("Color Dictionary", dictionary, ":", ", ");
    }

The output:

    -- Color Dictionary --
    blue:mavi, gray:gri, red:kırmızı

If the separators are almost always going to be those two, they can be defined with default values:

    void printAA(string title,
                 string[string] aa,
                 string keySeparator = ": ",
                 string elementSeparator = ", ") {
        // ...
    }

Parameters with default values need not be specified when the function is called:

        printAA("Color Dictionary",
                dictionary);  /* ← No separator specified. Both
                               *   parameters will get their
                               *   default values. */

The parameter values can still be specified when needed, and not necessarily all of them:

        printAA("Color Dictionary", dictionary, "=");

The output:

    -- Color Dictionary --
    blue=mavi, gray=gri, red=kırmızı

The following call specifies both of the parameters:

        printAA("Color Dictionary", dictionary, "=", "\n");

The output:

    -- Color Dictionary --
    blue=mavi
    gray=gri
    red=kırmızı

Default values can only be defined for the parameters that are at the end of the parameter list.

###### Special keywords as default arguments

The following special keywords act like compile-time literals having values corresponding to where they appear in code:

- `__MODULE__`: Name of the module as `string`
- `__FILE__`: Name of the source file as `string`
- `__FILE_FULL_PATH__`: Name of the source file including its full path as `string`
- `__LINE__`: Line number as `int`
- `__FUNCTION__`: Name of the function as `string`
- `__PRETTY_FUNCTION__`: Full signature of the function as `string`

Although they can be useful anywhere in code, they work differently when used as default arguments. When they are used in regular code, their values refer to where they appear in code:

    import std.stdio;

    void func(int parameter) {
        writefln("Inside function %s at file %s, line %s.",
                 __FUNCTION__, __FILE__, __LINE__);    // ← line 5
    }

    void main() {
        func(42);
    }

The reported line 5 is inside the function:

    Inside function deneme.func at file deneme.d, line 5.

However, sometimes it is more interesting to determine the line where a function is called from, not where the definition of the function is. When these special keywords are provided as default arguments, their values refer to where the function is called from:

    import std.stdio;

    void func(int parameter,
              string functionName = __FUNCTION__,
              string file = __FILE__,
              int line = __LINE__) {
        writefln("Called from function %s at file %s, line %s.",
                 functionName, file, line);
    }

    void main() {
        func(42);    // ← line 12
    }

This time the special keywords refer to `main()`, the caller of the function:

    Called from function deneme.main at file deneme.d, line 12.

In addition to the above, there are also the following special tokens that take values depending on the compiler and the time of day:

- `__DATE__`: Date of compilation as `string`
- `__TIME__`: Time of compilation as `string`
- `__TIMESTAMP__`: Date and time of compilation as `string`
- `__VENDOR__`: Compiler vendor as `string` (e.g. `"Digital Mars D"`)
- `__VERSION__`: Compiler version as `long` (e.g. the value `2081L` for version 2.081)

##### Variadic functions

Despite appearances, default parameter values do not change the number of parameters that a function receives. For example, even though some parameters may be assigned their default values, `printAA()` always takes four parameters and uses them according to its implementation.

On the other hand, variadic functions can be called with unspecified number of arguments. We have already been taking advantage of this feature with functions like `writeln()`. `writeln()` can be called with any number of arguments:

        writeln(
            "hello", 7, "world", 9.8 /*, and any number of other
                                      *  arguments as needed */);

There are four ways of defining variadic functions in D:

- The feature that works only for functions that are marked as `extern(C)`. This feature defines the hidden `_argptr` variable that is used for accessing the parameters. This book does not cover this feature partly because it is unsafe.
- The feature that works with regular D functions, which also uses the hidden `_argptr` variable, as well as the `_arguments` variable, the latter being of type `TypeInfo[]`. This book does not cover this feature as well both because it relies on pointers, which have not been covered yet, and because this feature can be used in unsafe ways as well.
- A safe feature with the limitation that the unspecified number of parameters must all be of the same type. This is the feature that is covered in this section.
- Unspecified number of template parameters. This feature will be explained later in the templates chapters.

The parameters of variadic functions are passed to the function as a slice. Variadic functions are defined with a single parameter of a specific type of slice followed immediately by the `...` characters:

    double sum(double[] numbers...) {
        double result = 0.0;

        foreach (number; numbers) {
            result += number;
        }

        return result;
    }

That definition makes `sum()` a variadic function, meaning that it is able to receive any number of arguments as long as they are `double` or any other type that can implicitly be convertible to `double`:

        writeln(sum(1.1, 2.2, 3.3));

The single slice parameter and the `...` characters represent all of the arguments. For example, the slice would have five elements if the function were called with five `double` values.

In fact, the variable number of parameters can also be passed as a single slice:

        writeln(sum([ 1.1, 2.2, 3.3 ]));    // same as above

Variadic functions can also have required parameters, which must be defined first in the parameter list. For example, the following function prints an unspecified number of parameters within parentheses. Although the function leaves the number of the elements flexible, it requires that the parentheses are always specified:

    char[] parenthesize(
        string opening,  // ← The first two parameters must be
        string closing,  //   specified when the function is called
        string[] words...) {  // ← Need not be specified
        char[] result;

        foreach (word; words) {
            result ~= opening;
            result ~= word;
            result ~= closing;
        }

        return result;
    }

The first two parameters are mandatory:

        parenthesize("{");     // ← derleme HATASI

As long as the mandatory parameters are specified, the rest are optional:

        writeln(parenthesize("{", "}", "apple", "pear", "banana"));

The output:

    {apple}{pear}{banana}

###### Variadic function arguments have a short lifetime

The slice argument that is automatically generated for a variadic parameter points at a temporary array that has a short lifetime. This fact does not matter if the function uses the arguments only during its execution. However, it would be a bug if the function kept a slice to those elements for later use:

    int[] numbersForLaterUse;

    void foo(int[] numbers...) {
        numbersForLaterUse = numbers;    // ← BUG
    }

    struct S {
        string[] namesForLaterUse;

        void foo(string[] names...) {
            namesForLaterUse = names;    // ← BUG
        }
    }

    void bar() {
        foo(1, 10, 100);  /* The temporary array [ 1, 10, 100 ] is
                           * not valid beyond this point. */

        auto s = S();
        s.foo("hello", "world");  /* The temporary array
                                   * [ "hello", "world" ] is not
                                   * valid beyond this point. */

        // ...
    }

    void main() {
        bar();
    }

Both the free-standing function `foo()` and the member function `S.foo()` are in error because they store slices to automatically-generated temporary arrays that live on the program stack. Those arrays are valid only during the execution of the variadic functions.

For that reason, if a function needs to store a slice to the elements of a variadic parameter, it must first take a copy of those elements:

    void foo(int[] numbers...) {
        numbersForLaterUse = numbers.dup;    // ← correct
    }

    // ...

        void foo(string[] names...) {
            namesForLaterUse = names.dup;    // ← correct
        }

However, since variadic functions can also be called with slices of proper arrays, copying the elements would be unnecessary in those cases.

A solution that is both correct and efficient is to define two functions having the same name, one taking a variadic parameter and the other taking a proper slice. If the caller passes variable number of arguments, then the variadic version of the function is called; and if the caller passes a proper slice, then the version that takes a proper slice is called:

    int[] numbersForLaterUse;

    void foo(int[] numbers...) {
        /* Since this is the variadic version of foo(), we must
         * first take a copy of the elements before storing a
         * slice to them. */
        numbersForLaterUse = numbers.dup;
    }

    void foo(int[] numbers) {
        /* Since this is the non-variadic version of foo(), we can
         * store the slice as is. */
        numbersForLaterUse = numbers;
    }

    struct S {
        string[] namesForLaterUse;

        void foo(string[] names...) {
            /* Since this is the variadic version of S.foo(), we
             * must first take a copy of the elements before
             * storing a slice to them. */
            namesForLaterUse = names.dup;
        }

        void foo(string[] names) {
            /* Since this is the non-variadic version of S.foo(),
             * we can store the slice as is. */
            namesForLaterUse = names;
        }
    }

    void bar() {
        // This call is dispatched to the variadic function.
        foo(1, 10, 100);

        // This call is dispatched to the proper slice function.
        foo([ 2, 20, 200 ]);

        auto s = S();

        // This call is dispatched to the variadic function.
        s.foo("hello", "world");

        // This call is dispatched to the proper slice function.
        s.foo([ "hi", "moon" ]);

        // ...
    }

    void main() {
        bar();
    }

Defining multiple functions with the same name but with different parameters is called function overloading, which is the subject of the next chapter.

##### Problem

Assume that the following `enum` is already defined:

    enum Operation { add, subtract, multiply, divide }

Also assume that there is a `struct` that represents the calculation of an operation and its two operands:

    struct Calculation {
        Operation op;
        double first;
        double second;
    }

For example, the object `Calculation(Operation.divide, 7.7, 8.8)` would represent the division of 7.7 by 8.8.

Design a function that receives an unspecified number of these `struct` objects, calculates the result of each `Calculation`, and then returns all of the results as a slice of type `double[]`.

For example, it should be possible to call the function as in the following code:

    void main() {
        writeln(
            calculate(Calculation(Operation.add, 1.1, 2.2),
                      Calculation(Operation.subtract, 3.3, 4.4),
                      Calculation(Operation.multiply, 5.5, 6.6),
                      Calculation(Operation.divide, 7.7, 8.8)));
    }

The output of the code should be similar to the following:

    [3.3, -1.1, 36.3, 0.875]

... çözüm

Copyright © 1999-2026 by the D Language Foundation | Page generated by Ddoc on Mon Aug 17 18:57:13 2026