Commit d67790d

The function-call operator, when overloaded, does not modify how functions are called; rather, it modifies how the operator is to be interpreted when applied to objects of a given class type. For example, the following code would usually be meaningless:

Point pt;

pt( 3, 2 );

```

- Function returning type `T`. An example declaration is

T func( int i )

```

- Pointer to a function returning type `T`. An example declaration is

T (*func)( int i )

```

- Reference to a function returning type `T`. An example declaration is

T (&func)(int i)

```

- Pointer-to-member function dereference returning type `T`. Example function calls are

(pObject->*pmf)();

(Object.*pmf)();

```

## Example

The following example calls the standard library function `strcat_s` with three arguments:

A function call evaluates to an r-value unless the function is declared as a reference type. Functions with reference return type evaluate to l-values, and can be used on the left side of an assignment statement as follows:

#include <iostream>

Functions that return class types, pointers to class types, or references to class types can be used as the left operand to member-selection operators. Therefore, the following code is legal:

class A {

public:

The following example illustrates how overloading can be used.

#include <iostream>

Consider the following statement:

F1 = Add( F2, 23 );

```

The intersection of these two sets is Variant 1. An example of an ambiguous function call is:

F1 = Add( 3, 6 );

```

However, the function overloading mechanism can distinguish between references that are qualified by **const** and `volatile` and references to the base type. This makes code such as the following possible:

User-defined conversions are applied if no built-in promotion or conversion exists. These conversions are selected on the basis of the type of the argument being matched. Consider the following code:

class UDC

{

If any user-defined conversions are required to match an argument, the standard conversions are not used when evaluating the best match. This is true even if more than one candidate function requires a user-defined conversion; in such a case, the functions are considered equal. For example:

class UDC1

- `typedef` declarations do not define new types; they introduce synonyms for existing types. They do not affect the overloading mechanism. Consider the following code:

typedef char * PSTR;

void Print( char *szToPrint );

- The types "array of " and "pointer to" are considered identical for the purposes of distinguishing between overloaded functions. This is true only for singly dimensioned arrays. Therefore, the following overloaded functions conflict and generate an error message:

void Print( char *szToPrint );

void Print( char szToPrint[] );

```

For multiply dimensioned arrays, the second and all succeeding dimensions are considered part of the type. Therefore, they are used in distinguishing between overloaded functions:

void Print( char szToPrint[] );

void Print( char szToPrint[][7] );

void Print( char szToPrint[][9][42] );

Block scope is strictly observed; therefore, a function declared in file scope is not in the same scope as a function declared locally. If a locally declared function has the same name as a function declared in file scope, the locally declared function hides the file-scoped function instead of causing overloading. For example:

#include <iostream>

The following example shows how the macros work together with the type (declared in \<stdarg.h>):

#include <stdio.h>

#include <stdarg.h>

- If a single module in your program contains both **dllimport** and `dllexport` declarations for the same function or object, the `dllexport` attribute takes precedence over the **dllimport** attribute. However, a compiler warning is generated. For example:

__declspec( dllimport ) int i;

__declspec( dllexport ) int i; // Warning; inconsistent;

// dllexport takes precedence.

```

- In C++, you can initialize a globally declared or static local data pointer or with the address of a data object declared with the **dllimport** attribute, which generates an error in C. In addition, you can initialize a static local function pointer with the address of a function declared with the **dllimport** attribute. In C, such an assignment sets the pointer to the address of the DLL import thunk (a code stub that transfers control to the function) rather than the address of the function. In C++, it sets the pointer to the address of the function. For example:

__declspec( dllimport ) void func1( void );

__declspec( dllimport ) int i;

However, because a program that includes the `dllexport` attribute in the declaration of an object must provide the definition for that object somewhere in the program, you can initialize a global or local static function pointer with the address of a `dllexport` function. Similarly, you can initialize a global or local static data pointer with the address of a `dllexport` data object. For example, the following code does not generate errors in C or C++:

__declspec( dllexport ) void func1( void );

__declspec( dllexport ) int i;

The compiler generates the same warning if the base class is a specialization of a class template. To work around this, mark the base-class with `dllexport`. The problem with a specialization of a class template is where to place the **__declspec(dllexport)**; you are not allowed to mark the class template. Instead, explicitly instantiate the class template and mark this explicit instantiation with `dllexport`. For example:

template class __declspec(dllexport) B<int>;

class __declspec(dllexport) D : public B<int> {

// ...

```

This workaround fails if the template argument is the deriving class. For example:

class __declspec(dllexport) D : public B<D> {

// ...

```

Because this is common pattern with templates, the compiler changed the semantics of `dllexport` when it is applied to a class that has one or more base-classes and when one or more of the base classes is a specialization of a class template. In this case, the compiler implicitly applies `dllexport` to the specializations of class templates. You can do the following and not get a warning:

class __declspec(dllexport) D : public B<D> {

// ...

```

Note that the meaning of any of the operators can be changed completely. That includes the meaning of the address-of (**&**), assignment (**=**), and function-call operators. Also, identities that can be relied upon for built-in types can be changed using operator overloading. For example, the following four statements are usually equivalent when completely evaluated:

var = var + 1;

var += 1;

var++;

In this example, a `goto` statement transfers control to the point labeled `stop` when `i` equals 3.

#include <stdio.h>

int main()

```

The order in which **catch** handlers appear is significant, because handlers for a given **try** block are examined in order of their appearance. For example, it is an error to place the handler for a base class before the handler for a derived class. After a matching **catch** handler is found, subsequent handlers are not examined. As a result, an ellipsis **catch** handler must be the last handler for its **try** block. For example:

try

{