In bf(C++) it is possible to define
    i(functions having identical names) but performing different actions. The
functions must differ in their hi(parameter list) parameter lists (and/or in
their hi(const function attribute) tt(const) attribute). An example is given
below:
        verbinclude(-a examples/overload.cc)
    In the above program three functions tt(show) are defined, only differing
in their parameter lists, expecting an tt(int), tt(double) and tt(char *),
respectively. The functions have identical names. Functions having identical
names but different parameter lists are called em(overloaded). The act of
defining such functions is called `i(function overloading)'.

    The bf(C++) compiler implements function overloading in a rather simple
way. Although the functions share their names (in this example tt(show)), the
compiler (and hence the linker) use quite different names. The conversion of a
name in the source file to an internally used name is called
 `i(name mangling)'. E.g., the bf(C++) compiler might convert the prototype
tt(void) tt(show) tt((int)) to the internal name tt(VshowI), while an
analogous function having a tt(char *) argument might be called
tt(VshowCP). The actual names that are used internally depend on the compiler
and are not relevant for the programmer, except where these names show up in
e.g., a listing of the content of a library.

Some additional remarks with respect to  function overloading:
    itemization(
    it() Do not use function overloading for functions doing conceptually
different tasks.  In the example above, the functions tt(show) are still
somewhat related (they print information to the screen).

    However, it is also quite possible to define two functions tt(lookup),
one of which would find a name in a list while the other would determine the
video mode. In this case the behavior of those two functions have nothing in
common. It would therefore be more practical to use names which suggest their
actions; say, tt(findname) and tt(videoMode).
    it() bf(C++) does not allow identically named functions to differ only in
their return values, as it is always the programmer's choice to either use or
ignore a function's  return value. E.g., the fragment
    verb(printf("Hello World!\n");)

provides no information about the return value of the function
tt(printf). Two functions tt(printf) which only differ in their
return types would therefore not be distinguishable to the compiler.
    it() In chapter ref(Classes) the notion of tt(const) member functions is
introduced (cf. section ref(ConstFunctions)). Here it is merely mentioned
that classes normally have so-called member functions associated with them
(see, e.g., chapter ref(String) for an informal introduction to the
concept). Apart from
    hi(member function: overloading)
    overloading member functions using different parameter lists, it
is then also possible to
    hi(overloading: by const attribute)
    overload member functions by their tt(const) attributes. In those cases,
classes may have pairs of identically named member functions, having identical
parameter lists. Then, these functions are overloaded by their tt(const)
attribute. In such cases only one of these functions must have the tt(const)
attribute.
    )
