Show Lecture.Functions as a slide show.

CS253 Functions

Definition

Remember that a method is just a function associated with a class. Everything said here applies equally well to methods, because methods are functions.

Functions

By & large, C++ functions look like Java functions:

int sum(int a, int b) {
    return a+b;
}

int main() {
    cout << sum(2, 40) << '\n';
}

42

Default Parameters

The trailing arguments can have default values:

int sum(int a, int b = 13) {
    return a+b;
}

int main() {
    cout << sum(2, 40) << '\n'
         << sum(8)     << '\n';
}

42
21

Default Parameters

All default arguments must be piled up at the end:

int sum(int a = 123, int b = 456) {
    return a+b;
}

int main() {
    cout << sum(2, 40) << '\n'
         << sum(8)     << '\n'
         << sum()      << '\n';
}

42
464
579

int bad(int c=8, long d) {  // 🦡
    return c+d;
}

int main() {
    return bad(5);
}

c.cc:1: error: default argument missing for parameter 2 of ‘int bad(int, long 
   int)’

Function Overloading

Like Java, C++ can have multiple versions of the same function that take different arguments:

int sum(int a, int b) { return a+b; }
int sum(int a) { return a+456; }
int sum() { return 123+456; }

int main() {
    cout << sum(2, 40) << '\n'
         << sum(8)     << '\n'
         << sum()      << '\n';
}

42
464
579

Function Overloading

The types don’t have to be the same, either:

int sum(int a, int b) { return a+b; }
double sum(int a) { return a+4.5; }
string sum(double) { return "I can’t deal with double"; }
const char *sum() { return "You are a bonehead"; }

int main() {
    cout << sum(2, 40)   << '\n'
         << sum(8)       << '\n'
         << sum(123.456) << '\n'
         << sum()        << '\n';
}

42
12.5
I can’t deal with double
You are a bonehead

For sum(double), the unused argument isn’t given a name, to avoid warnings about unused variables.

Implementation

• So, how is this accomplished?
• How can there actually be four versions of the function sum in the executable file?
• sum is sum, right?
• No.

Name Mangling

• It’s called name mangling.
• Inside the executable file, the function isn’t really called sum.
• Instead, it’s called sum-with-an-int-argument.
  • Not really—it’s more compact than that.

Return type doesn’t matter

• The function’s return type is not part of the mangled name.
• Therefore, a function can’t be overloaded on return type alone.

int foo() { return 1; }
double foo() { return 2.0; } // 🦡
int main() {
    return 0;
}

c.cc:2: error: ambiguating new declaration of ‘double foo()’

Name Mangling

$ cat ~cs253/Example/overload.cc
int sum(int a, int b) { return a+b; }
double sum(int a) { return a+4.5; }
const char *sum() { return "You are a bonehead"; }
bool sum(double, int, short) { return false; }

$ g++ -Wall -c ~cs253/Example/overload.cc

$ nm --numeric-sort overload.o 2>&-
0000000000000000 T _Z3sumii
0000000000000014 T _Z3sumi
000000000000002e T _Z3sumv
0000000000000039 T _Z3sumdis

$ nm --numeric-sort --demangle overload.o 2>&-
0000000000000000 T sum(int, int)
0000000000000014 T sum(int)
000000000000002e T sum()
0000000000000039 T sum(double, int, short)

More Name Mangling

$ cat ~cs253/Example/mangle.cc
void b(unsigned __int128,
       __int128,
       long double,
       unsigned char,
       long double,
       signed char,
       double) {
}

$ g++ -Wall -c ~cs253/Example/mangle.cc

$ nm mangle.o 2>&-
0000000000000000 T _Z1bonehead

Do not memorize the various encodings for types. It varies between compilers, anyway.

auto

// The “Golden Ratio”:
auto φ() {
    return (1+sqrt(5.0L))/2;
}

auto fact() {
    cout << "φ ≈ " << φ() << '\n';
}

int main() {
    fact();
    return 0;
}

φ ≈ 1.61803

The return type can be declared as auto, which means that the actual type will be deduced by what is returned. auto is not a type. It means “Compiler, you figure out the real type.”

Caution

The auto type deduction tolerates no ambiguity.

auto age_of_earth(bool science) {
    if (science)
        return 4.54e9;       // science: 4.54 billion years ago
    else
        return 4004-1+2024;  // Archbishop Ussher: 4004BC 🦡
}

int main() {
    cout << age_of_earth(true);
}

c.cc:5: error: inconsistent deduction for auto return type: ‘double’ and 
   then ‘int’

Pass by value

By default, arguments are passed by value.

void foo(int n) {
    ++n; ++n;
}

int main() {
    int v = 42;
    foo(v);
    cout << v << '\n';
}

42

The variable n is a copy of v.

Pass by address

A C programmer might pass by address:

void foo(int *n) {
    *n = 99;
}

int main() {
    int v = 42;
    foo(&v);
    cout << v << '\n';
}

99

The actual parameter is &v, the address of v. This is fine C, but C++ can do better. Use a reference, instead.

Pass by reference

C++ can pass a variable by reference:

void foo(int &n) {
    ++n; ++n;
}

int main() {
    int v = 42;
    foo(v);
    cout << v << '\n';
}

44

The variable n is an alias of v. This is often implemented as a pointer that gets * applied automatically.

Pass by constant address

You can use a read-only pointer:

void foo(const int *n) {
    *n = 99;  // 🦡
}

int main() {
    int v = 42;
    foo(&v);
    cout << v << '\n';
}

c.cc:2: error: assignment of read-only location ‘* n’

As before, avoid pointer arguments in favor of reference arguments.

Pass by reference

You can use a read-only reference:

void foo(const int &n) {
    ++n; ++n;  // 🦡
}

int main() {
    int v = 42;
    foo(v);
    cout << v << '\n';
}

c.cc:2: error: increment of read-only reference ‘n’

Efficiency

• Let’s talk about how arguments get passed to a function, on today’s computers.
• When passing an integer, a floating-point value, or a boolean, pass by value if you can, because that will go into a lightning-fast register. Copying a small scalar into a register is cheap. It you’re lucky, it already lives in a register, not the stack.
• An object, however, is generally bigger, and might even contain pointers to dynamic data (vector, string).
• Therefore, passing an object by value tends to be expensive, whereas passing an object by address or reference is cheap.
• It’s all about making a copy. Is that fast, for your datatype?

Efficiency of pass by value

bool foo(vector<int> v) {    // 🦡 pass by value
    return v.empty();
}

int main() {
    vector<int> w(2500);
    for (int i=0; i<10'000'000; i++)
        foo(w);
    cout << "Done.\n";
}

Done.

Real time: 1.94 seconds

We made ten million copies of a ten-thousand-byte vector, and so copied 100 gigabytes. Slow! 🐌

Efficiency of pass by constant reference

bool foo(const vector<int> &v) {    // pass by constant reference
    return v.empty();
}

int main() {
    vector<int> w(2500);
    for (int i=0; i<10'000'000; i++)
        foo(w);
    cout << "Done.\n";
}

Done.

Real time: 8.64 ms

No copies were made! 😎

Rule of thumb

• When sending data to a function:
  • Pass a scalar (int, double, char, …) by value.
  • Pass an object (string, vector, struct, …), by constant reference.
• When the function is supposed to change the argument:
  • Pass by non-constant reference.
  • I/O streams always get passed this way.

double sqrt(double d);
int count_spaces(const string &s);

void get_physical_info(int &height, int &weight);
void remove_spaces(string &s);
void read_picture(Picture &pic, ostream &os);
void write_picture(const Picture &pic, ostream &os);

Arrays

Arrays are special. They’re automatically passed by reference:

void foo(int a[]) {
    a[0] = 911;
}

int main() {
    int numbers[] = {555-1212, 867-5309};  // dashes⁇
    foo(numbers);
    cout << numbers[0];
}

911

This only applies to old-style C arrays, not std::vector or std::array.