Default Argument

Programming Language & Its Applications — C++ Constructs with Objects and Classes, NEC licence examination syllabus (Nepal Engineering Council).

Default Arguments

Values the compiler supplies when the caller omits them — one function serving several call shapes.

🌍 Where this lives: default arguments are why library APIs stay usable as they grow. std::vector<int> v(10) versus std::vector<int> v(10, -1) — the second argument defaults to a value-initialised element. Every graphics call like drawCircle(x, y, radius, colour = black, filled = false) works this way, so simple uses stay short while advanced uses stay possible. Python's def f(a, b=10) is the same feature, but with one famous difference worth knowing: Python evaluates the default once at definition, which is why def f(x, lst=[]) is a notorious bug, while C++ evaluates it at each call. Search "Python mutable default argument" and you will appreciate C++'s choice.

The rules

void greet(std::string name, std::string title = "Mr.", int times = 1); greet("Ram"); → "Mr. Ram", once greet("Ram", "Dr."); → "Dr. Ram", once greet("Ram", "Dr.", 3); → "Dr. Ram", 3 times greet("Ram", 3); ✗ ERROR — cannot skip title RULE 1: defaults must be TRAILING. Once a parameter has a default, every parameter to its RIGHT must have one too. void f(int a, int b = 1, int c); ✗ error void f(int a, int b = 1, int c = 2); ✔ Why? Arguments are matched left to right by position. With f(1, 2) the compiler cannot know whether 2 is b or c. RULE 2: you cannot SKIP a middle argument. There is no C++ syntax for "use the default for arg 2 but supply arg 3". (Python allows it with keyword arguments; C++ does not.) RULE 3: the default appears in the DECLARATION, once. Put it in the header, NOT in the definition: // widget.h void resize(int w, int h = 100); // widget.cpp void resize(int w, int h) { ... } /* no default here */ Repeating it in both is an error: "default argument given more than once". RULE 4: defaults are evaluated at the CALL SITE, each call. int n = 5; void f(int x = n); /* not allowed: n is not constant in this context — but a global or constexpr is fine */

defaults.cpp

#include <iostream>
#include <string>

/* one function, four usable call shapes */
double interest(double principal,
                double rate = 10.0,
                int    years = 1,
                int    compounds_per_year = 1);

double interest(double p, double r, int y, int n) {
    double amount = p;
    for (int i = 0; i < y * n; i++)
        amount *= (1 + r / (100.0 * n));
    return amount - p;
}

void banner(const std::string& text,
            char fill = '-', int width = 40) {
    std::cout << std::string(width, fill) << "\n"
              << text << "\n"
              << std::string(width, fill) << "\n";
}

int main() {
    std::cout << interest(10000)               << "\n";
    std::cout << interest(10000, 12.0)         << "\n";
    std::cout << interest(10000, 12.0, 2)      << "\n";
    std::cout << interest(10000, 12.0, 2, 4)   << "\n";

    banner("Defaults");
    banner("Custom fill", '=');
    banner("Narrow", '*', 20);
    return 0;
}
Output:
1000
1200
2544
2668.24
----------------------------------------
Defaults
----------------------------------------
========================================
Custom fill
========================================
********************
Narrow
********************

Verifying the compound interest by hand. Formula: A = P(1 + r/(100n))^(n·y), interest = A − P Call 1: interest(10000) → r=10, y=1, n=1 A = 10000 × (1 + 0.10)¹ = 11000 interest = 1000 ✔ Call 2: interest(10000, 12.0) A = 10000 × 1.12¹ = 11200 interest = 1200 ✔ Call 3: interest(10000, 12.0, 2) → n=1, y=2 A = 10000 × 1.12² = 10000 × 1.2544 = 12544 interest = 2544 ✔ Call 4: interest(10000, 12.0, 2, 4) compounded QUARTERLY → rate per period = 12/(100×4) = 0.03 → periods = y × n = 2 × 4 = 8 A = 10000 × 1.03⁸ 1.03⁸ = 1.2668241795 A = 12668.24, interest = 2668.24 ✔ Notice call 4 earns MORE than call 3 (2668.24 vs 2544) at the same 12% for the same 2 years. That is the whole point of compounding frequency: interest starts earning interest sooner. Annually 12% gives 25.44% over two years; quarterly gives 26.68%. Push it to daily and you approach the continuous limit Pe^(rt) = 10000 × e^0.24 = 12712.49.

Default arguments are checked at the call site, not stored in the function. That is why interest(10000) compiles to a call passing all four values — 10000, 10.0, 1, 1 — with the compiler filling in the last three. The function body never knows an argument was omitted, which is exactly why there is no way to ask "did the caller supply this?" the way you can in Python with a None sentinel.

Worked example — defaults versus overloading

vs_overload.cpp

#include <iostream>

/* APPROACH A: three overloads - three function bodies */
int volumeA(int l)               { return l * l * l; }
int volumeA(int l, int w)        { return l * w * w; }
int volumeA(int l, int w, int h) { return l * w * h; }

/* APPROACH B: one function, defaults - ONE body */
int volumeB(int l, int w = 1, int h = 1) { return l*w*h; }

int main() {
    std::cout << volumeA(3) << " " << volumeA(3,4)
              << " " << volumeA(3,4,5) << "\n";
    std::cout << volumeB(3) << " " << volumeB(3,4)
              << " " << volumeB(3,4,5) << "\n";
    return 0;
}
Output:
27 48 60
3 12 60

The outputs DIFFER, and that is the whole point. volumeA(3) = 3×3×3 = 27 (cube — different LOGIC) volumeB(3) = 3×1×1 = 3 (defaults fill in 1) volumeA(3,4) = 3×4×4 = 48 (square prism) volumeB(3,4) = 3×4×1 = 12 So the choice is not stylistic: USE DEFAULT ARGUMENTS when the omitted arguments have a sensible FIXED value and the logic is identical. print(text, width = 80) connect(host, port = 8080, timeout = 30) USE OVERLOADING when different argument counts mean different BEHAVIOUR, or the TYPES differ. area(side) → square formula area(radius) → circle formula area(base, height) → triangle formula Overloading also handles type variation, which defaults cannot: you cannot default an int parameter to a string.

The ambiguity trap

ambiguity.cpp

#include <iostream>

void f(int a, int b = 10) { std::cout << "two-param " << a+b << "\n"; }
void f(int a)             { std::cout << "one-param " << a   << "\n"; }

int main() {
    f(5, 20);   /* only one candidate: the 2-param version */

    /* f(5) matches BOTH:
         f(int)          exactly
         f(int, int=10)  using the default
       -> error: call to 'f' is ambiguous            */
    /* f(5);  COMPILE ERROR */
    return 0;
}
Output:
two-param 25

Mixing defaults and overloading on the same parameter count creates an ambiguity the compiler cannot resolve — and it is a compile error, which is the good outcome. Pick one mechanism per function name.

Defaults in constructors

ctor_defaults.cpp

#include <iostream>
#include <string>

class Account {
    std::string owner;
    double      balance;
    double      rate;
public:
    /* ONE constructor covering three usage patterns.
       Without defaults this needs three constructors. */
    Account(std::string o, double b = 0.0, double r = 5.0)
        : owner(o), balance(b), rate(r) {}

    void show() const {
        std::cout << owner << ": Rs " << balance
                  << " at " << rate << "%  -> after 1 yr Rs "
                  << balance * (1 + rate/100) << "\n";
    }
};

int main() {
    Account a("Ram");                    /* 0.0, 5.0  */
    Account b("Sita", 50000);            /* rate 5.0  */
    Account c("Hari", 100000, 8.5);      /* all given */
    a.show(); b.show(); c.show();
    return 0;
}
Output:
Ram: Rs 0 at 5% -> after 1 yr Rs 0
Sita: Rs 50000 at 5% -> after 1 yr Rs 52500
Hari: Rs 100000 at 8.5% -> after 1 yr Rs 108500

Checking: 50000 × 1.05 = 52500 ✔ 100000 × 1.085 = 108500 ✔ Note the side effect: this single constructor makes Account("Ram") valid, so Account is now implicitly convertible from a std::string. If you do not want that, mark it explicit: explicit Account(std::string o, double b = 0.0, ...) This matters more than it looks — implicit conversions from a one-argument constructor cause surprising overload resolution. The habit: mark every constructor that can be called with ONE argument as explicit unless you deliberately want the conversion.

🌍 Go further: C++ deliberately has no keyword arguments, so a call like createWindow(800, 600, true, false, true, 2) is unreadable — you cannot tell which boolean is which. The modern answer is a parameter struct: createWindow({.width=800, .height=600, .fullscreen=true}) using C++20 designated initialisers. Search "named parameter idiom C++" to see the three competing solutions and why the language still has not settled this — it is a good window into how real language design trade-offs work.

💡 Exam angle: state the trailing rule (all parameters right of a defaulted one must also be defaulted) and why — positional left-to-right matching. Know that the default goes in the declaration only, never repeated in the definition, and that middle arguments cannot be skipped. The defaults versus overloading comparison, with the volume example showing they are not interchangeable, is the discriminating answer. Mention the ambiguity error when both are used on the same name.

Syllabus points

Default parameter values

Create a free account to tick topics off, take notes as you read, watch the video lessons and get a day-by-day study plan built around your exam date.