Llamada de subrutinas sobrecargadas y formas de encontrar coincidencias precisas en C++

Al igual que otras subrutinas , también se denominan subrutinas sobrecargadas. Para decidir qué función invocar es importante determinar el número y tipo de argumentos. Por ejemplo, la siguiente parte del código informará sobre la subrutina de sobrecarga de llamadas:

prnsqr('z')                   // calls #2
prnsqr(13)                    // calls #1
prnsqr(134.520000012)         // calls #4
prnsqr(12.5F)                 // calls #3

Se llama a la función adecuada para su ejecución cuando la llamada de función coincide inicialmente con el prototipo disponible junto con el dígito y el tipo de argumentos proporcionados.

Entre los valores float , double o int o long , puede haber una ambigüedad como la función invocada por la siguiente declaración:

void prnsqr(double d);

Con un valor de 1,24, se puede suponer que es flotante o doble. Los sufijos constantes (F, U, L, UL), etc. se utilizan para evitar la ambigüedad. Estos valores ayudan a demostrar a qué subrutina de sobrecarga llamar. La constante flotante ordinaria (312.32) es de tipo doble, el sufijo F (312.32 F) es de tipo flotante, L (312.32 L) forma su doble largo. Para números enteros, una constante sin sufijo es el valor int firmado . El sufijo U es constante sin signo y el sufijo L es largo, LU o UL son largos sin signo. Estos sufijos se pueden escribir en minúsculas o en mayúsculas.

A continuación se muestra la implementación del enfoque anterior:

// C++ program for the above approach
#include <iostream>
using namespace std;
  
class Distance {
private:
    int centimeter;
    int kilometer;
  
public:
    // Default Constructors
    Distance()
    {
        centimeter = 0;
        kilometer = 0;
    }
  
    // Parameterized Constructors
    Distance(int cm, int km)
    {
        centimeter = cm;
        kilometer = km;
    }
  
    // Overload function call
    Distance operator()(int a,
                        int b, int c)
    {
        Distance D;
        D.centimeter = a + c + 10;
        D.kilometer = b + c + 100;
        return D;
    }
  
    // To display distance
    void displayDistance()
    {
        cout << "centimeter: "
             << centimeter
             << "kilometer:"
             << kilometer << '\n';
    }
};
  
// Driver Code
int main()
{
    Distance D1(87, 33), D2;
  
    cout << "First Distance : ";
    D1.displayDistance();
  
    // Invoke operator()
    D2 = D1(10, 10, 10);
    cout << "Second Distance :";
  
    D2.displayDistance();
  
    return 0;
}

First Distance : centimeter: 87kilometer:33
Second Distance :centimeter: 30kilometer:120

Formas de encontrar coincidencias precisas:

La llamada se resuelve para una subrutina sobrecargada por una instancia de función a través de un proceso llamado Coincidencia de argumentos , también denominado proceso de desambiguación. A continuación se muestran los 3 casos que pueden ser posibles, la llamada a la función puede resultar:

1. Coincidencia: encontrado para la llamada de función.
2. Sin coincidencia: para llamada de función.
3. Coincidencia ambigua: más de una coincidencia de instancia descrita.

El compilador intentará encontrar la mejor coincidencia para la llamada de función.

Pasos tomados por el compilador para hacer coincidir

• Búsqueda de una coincidencia exacta: cuando el tipo de argumento real coincide exactamente con el tipo de una instancia definida, el compilador invocará esa instancia. Por ejemplo:

  // For overloaded functions
  void afunc(int);
  void afunc(double);    
  
  // For exact match. Match afunc(int)
  afunc(0);
  

  0 (cero) es de tipo int, coincide con afunc (int) con call.

  A continuación se muestra el programa para el mismo:

  C++

  // C++ program for the above approach    #include <iostream> using namespace std;    // Function for integer parameter void afunc(int h) {     cout << "Integer:" << h; }    // Function for double parameter void afunc(double d) {     cout << "double:" << d; }    // Driver code int main() {     afunc(0);     return 0; }

  Producción:

  Integer:0
  

• Coincidencia mediante promoción: el compilador intentará obtener una coincidencia mediante la promoción del argumento real si no se encuentra una coincidencia exacta. Si no se pueden representar todos los valores mediante int y la conversión de tipos enteros a (char, short, enumerator, int) oa int sin signo se denomina promoción integral. Ahora veremos la siguiente parte del código:
  

  void afunc(int)
  void afunc(float)

  // Para el partido a través de la promoción
  afunc(‘c’)

  donde, ‘c’ es el tipo char y se promociona al tipo INT porque no se encontró una coincidencia exacta.

  A continuación se muestra el programa para el mismo:

  C++

  // C++ program for the above approach #include <iostream> using namespace std;    // Function for integer parameter void value(int s) {     cout << "Integer:" << s; }    // Function for character parameter void value(char* b) {     cout << "Char:" << b; }    // Driver Code int main() {     char st = 'd';     value(st);     return 0; }

  Producción:

  Integer:100
  

• Mediante la aplicación de la regla de conversión estándar de C++ se encontró una coincidencia: se intenta lograr una coincidencia mediante una conversión estándar del argumento real si no se encuentra una coincidencia exacta o una coincidencia a través de una promoción. A continuación se muestra el ejemplo de la misma:
  

  void afunc(char)
  void afunc(doble)

  // Para la coincidencia a través de la conversión
  estándar afunc(471)
  coincide con una función(doble)

  Usando las reglas de conversión estándar de C++ , el argumento int 471 se puede convertir en un valor doble 471 y si el argumento real se puede convertir en múltiples tipos de argumentos formales, el compilador generará un mensaje de error ya que es una coincidencia ambigua. Por ejemplo:

  void afunc(long)
  void afunc(double)
  
  // Error will generate as ambiguous match
  afunc(15)
  

  El argumento int 15 se convirtió en long o double generando una circunstancia ambigua en cuanto a qué afunc() se debe usar.

  A continuación se muestra el programa para el mismo:

  C++

  // C++ program to explain the standard // conversion rule #include <iostream> using namespace std;    // Driver Code int main() {     // integer h     int h = 11;        // character c     char s = 'a';        // s implicitly converted     // to int. ASCII value of     // 'a' is 97     h = h + s;        // h is implicitly converted     // to float     float f = h + 1.0;        cout << "h = " << h << endl          << "s = " << s << endl          << "f = " << f << endl;        return 0; }

  Producción:

  h = 108
  s = a
  f = 109
  

  Nota: si no se ve ninguna promoción, el compilador encuentra una coincidencia a través de la conversión estándar. Cualquier tipo numérico se compara con otro tipo numérico, incluidos los sin signo (por ejemplo, int y float). Enum va a coincidir con el tipo formal de tipo numérico (por ejemplo, enum para flotar). 0 debe coincidir con un tipo de puntero y un tipo numérico (por ejemplo, 0 para char*, 0 para float). Aunque el puntero coincida con un puntero vacío.

• A través de la aplicación de una conversión definida por el usuario, encuentre una coincidencia: ahora el compilador utilizará una conversión definida por el usuario en combinación con una promoción integral y conversiones integradas para encontrar una coincidencia única si todos los pasos anteriores fallan. Cualquier función, ya sea un miembro de clase o simplemente una función normal, puede sobrecargarse en C++ dado que es necesario para trabajar con diferentes tipos de argumentos, números y combinaciones.

  A continuación se muestra el programa para el mismo:

  C++

  // C++ program to illustrate the user // defined type casting #include <iostream> using namespace std;    // Driver Code int main() {     double h = 1.4;        // Explicit conversion     // from double to int     int add = (int)h + 2;        cout << "Add = " << add;     return 0; }

  Producción:

  Add = 3