c++ - significado - qué es un parametro de una función en programación

comportamiento de los argumentos predeterminados de la función virtual

Question

Tengo una situación extraña con respecto al siguiente código. Por favor, ayúdame a aclararlo.

class B
{
public:
B();
virtual void print(int data=10)
{
cout << endl << "B--data=" << data;
}
};
class D:public B
{
public:
D();
void print(int data=20)
{
cout << endl << "D--data=" << data;
}
};
int main()
{
B *bp = new D();
bp->print();
return 0;
}

En cuanto a la salida que esperaba

[ D--data=20 ]

Pero en la práctica es

[ D--data=10 ]

Por favor ayuda. Puede parecer obvio para ti, pero no conozco el mecanismo interno.

Answer 1

El enlace dinámico usa vpointer y vtable. Sin embargo, el enlace dinámico solo se aplica al puntero de función. No hay ningún mecanismo para el argumento de vinculación dinámica.

Por lo tanto, el argumento predeterminado se determina estáticamente en el momento del compilador. En este caso, está estáticamente determinado por el tipo de bp, que es un puntero a la clase Base. Por lo tanto, data = 10 se pasa como argumento de la función, mientras que el puntero de la función apunta a la función del miembro de la clase derivada: D :: print. Esencialmente, llama a D :: print (10).

El siguiente fragmento de código y las salidas resultantes demuestran claramente el punto: aunque llama a Derived :: resize (int), la función del miembro de la llamada Derivada, pasa el argumento predeterminado de la clase Base: size = 0.

virtual void Derived :: resize (int) tamaño 0

#include <iostream>
#include <stdio.h>
using namespace std;
#define pr_dbgc(fmt,args...) /
printf("%d %s " fmt "/n",__LINE__,__PRETTY_FUNCTION__, ##args);
class Base {
public:
virtual void resize(int size=0){
pr_dbgc("size %d",size);
}
};
class Derived : public Base {
public:
void resize(int size=3){
pr_dbgc("size %d",size);
}
};
int main()
{
Base * base_p = new Base;
Derived * derived_p = new Derived;
base_p->resize(); /* calling base member function
resize with default
argument value --- size 0 */
derived_p->resize(); /* calling derived member
function resize with default
argument default --- size 3 */
base_p = derived_p; /* dynamic binding using vpointer
and vtable */
/* however, this dynamic binding only
applied to function pointer.
There is no mechanism to dynamic
binding argument. */
/* So, the default argument is determined
statically by base_p type,
which is pointer to base class. Thus
size = 0 is passed as function
argument */
base_p->resize(); /* polymorphism: calling derived class
member function
however with base member function
default value 0 --- size 0 */
return 0;
}
#if 0
The following shows the outputs:
17 virtual void Base::resize(int) size 0
24 virtual void Derived::resize(int) size 3
24 virtual void Derived::resize(int) size 0
#endif

Answer 2

El estándar dice (8.3.6.10):

Una llamada de función virtual (10.3) usa los argumentos predeterminados en la declaración de la función virtual determinada por el tipo estático del puntero o referencia que denota el objeto. Una función primordial en una clase derivada no adquiere argumentos predeterminados de la función que anula.

Esto significa que, como llama a print través de un puntero de tipo B , usa el argumento predeterminado de B::print .

Answer 3

El valor de argumento predeterminado se pasa en nombre de la persona que llama. Desde el punto de vista de la persona que llama, funciona con la clase B (no con D), por lo que pasa a 10 (como para la clase B)

Answer 4

En general, se utilizan los argumentos predeterminados que son visibles en un determinado ámbito. Puedes hacer (pero no deberías) cosas funky:

#include <iostream>
void frob (int x) {
std::cout << "frob(" << x << ")/n";
}
void frob (int = 0);
int main () {
frob(); // using 0
{
void frob (int x=5) ;
frob(); // using 5
}
{
void frob (int x=-5) ;
frob(); // using -5
}
}

En su caso, la firma de la clase base es visible. Para usar los argumentos por defecto derivados, debe llamar explícitamente a esa función a través de un puntero a su clase derivada, ya sea al declararlo de esa manera o al lanzarlo correctamente.

Answer 5

Los argumentos predeterminados son completamente en tiempo de compilación. Es decir, la sustitución de los argumentos predeterminados en lugar de los argumentos faltantes se realiza en tiempo de compilación. Por esta razón, obviamente, no hay forma de que la selección del argumento por defecto para las funciones miembro pueda depender del tipo dinámico (es decir, tiempo de ejecución) del objeto. Siempre depende del tipo de objeto estático (es decir, en tiempo de compilación).

El compilador interpretará de inmediato la llamada que escribió en el ejemplo del código como bp->print(10) independientemente de cualquier otra cosa.

Answer 6

su variable es de tipo B, por lo que se llamará a la función de B. Para llamar a D, tienes que declarar tu variable como D o enviarla a D.