Sanal işlevlerin varsayılan parametreleri olabilir mi?

Bir temel sınıf (veya arabirim sınıfı) bildirir ve parametrelerinden biri veya daha fazlası için varsayılan bir değer belirtirseniz, türetilmiş sınıfların aynı varsayılanları belirtmesi gerekir mi, yoksa türetilmiş sınıflarda hangi varsayılanlar gösterilir?

Zeyilname: Bunun farklı derleyiciler arasında nasıl ele alınabileceği ve bu senaryoda "önerilen" uygulamalarla ilgili herhangi bir girdi ile de ilgileniyorum.

Sanalların varsayılan değerleri olabilir. Temel sınıftaki varsayılanlar türetilmiş sınıflar tarafından miras alınmaz.

Hangi varsayılan kullanılır - yani, temel sınıf 'veya türetilmiş bir sınıf' - işleve çağrı yapmak için kullanılan statik tür tarafından belirlenir. Bir temel sınıf nesnesi, işaretçi veya başvuruyu çağırırsanız, temel sınıfta belirtilen varsayılan değer kullanılır. Tersine, türetilmiş bir sınıf nesnesi, işaretçi veya referansı çağırırsanız türetilmiş sınıfta belirtilen varsayılanlar kullanılır. Standart teklifin altında bunu gösteren bir örnek vardır.

Bazı derleyiciler farklı bir şey yapabilir, ancak C ++ 03 ve C ++ 11 Standartlarının söylediği budur:

8.3.6.10:

Sanal işlev çağrısı (10.3), sanal işlevin bildiriminde, işaretçiyi veya nesneyi gösteren başvuruyu statik türüyle belirlenen varsayılan bağımsız değişkenleri kullanır. Türetilmiş bir sınıftaki geçersiz kılma işlevi, geçersiz kıldığı işlevden varsayılan bağımsız değişkenler almaz. Misal:

struct A {
  virtual void f(int a = 7);
};
struct B : public A {
  void f(int a);
};
void m()
{
  B* pb = new B;
  A* pa = pb;
  pa->f(); //OK, calls pa->B::f(7)
  pb->f(); //error: wrong number of arguments for B::f()
}

Hangi varsayılanların alındığını gösteren örnek bir program. structBurada classsadece kısalık için es yerine s kullanıyorum - classve structvarsayılan görünürlük dışında hemen hemen her şekilde aynı.

#include <string>
#include <sstream>
#include <iostream>
#include <iomanip>

using std::stringstream;
using std::string;
using std::cout;
using std::endl;

struct Base { virtual string Speak(int n = 42); };
struct Der : public Base { string Speak(int n = 84); };

string Base::Speak(int n) 
{ 
    stringstream ss;
    ss << "Base " << n;
    return ss.str();
}

string Der::Speak(int n)
{
    stringstream ss;
    ss << "Der " << n;
    return ss.str();
}

int main()
{
    Base b1;
    Der d1;

    Base *pb1 = &b1, *pb2 = &d1;
    Der *pd1 = &d1;
    cout << pb1->Speak() << "\n"    // Base 42
        << pb2->Speak() << "\n"     // Der 42
        << pd1->Speak() << "\n"     // Der 84
        << endl;
}

Bu programın çıktısı (MSVC10 ve GCC 4.4'te):

Base 42
Der 42
Der 84

Bu, Herb Sutter'in Haftanın ilk Guru yazılarından birinin konusuydu .

Konuyla ilgili söylediği ilk şey, YAPMAYIN.

Daha ayrıntılı olarak, evet, farklı varsayılan parametreler belirtebilirsiniz. Sanal işlevlerle aynı şekilde çalışmazlar. Sanal parametre, nesnenin dinamik türünde çağrılırken, varsayılan parametre değerleri statik türe dayanır.

verilmiş

class A {
    virtual void foo(int i = 1) { cout << "A::foo" << i << endl; }
};
class B: public A {
    virtual void foo(int i = 2) { cout << "B::foo" << i << endl; }
};
void test() {
A a;
B b;
A* ap = &b;
a.foo();
b.foo();
ap->foo();
}

A :: foo1 B :: foo2 B :: foo1 almalısınız

Bu kötü bir fikirdir, çünkü aldığınız varsayılan argümanlar nesnenin statik türüne bağlı olacaktır , ancak virtualgönderilen işlev dinamik türe bağlı olacaktır .

Diğer bir deyişle, varsayılan bağımsız değişkenleri olan bir işlevi çağırdığınızda, varsayılan bağımsız değişkenler, işlevin olup olmadığına bakılmaksızın derleme zamanında değiştirilir virtual.

@cppcoder, [kapalı] sorusunda aşağıdaki örneği sundu :

struct A {
    virtual void display(int i = 5) { std::cout << "Base::" << i << "\n"; }
};
struct B : public A {
    virtual void display(int i = 9) override { std::cout << "Derived::" << i << "\n"; }
};

int main()
{
    A * a = new B();
    a->display();

    A* aa = new A();
    aa->display();

    B* bb = new B();
    bb->display();
}

Hangi aşağıdaki çıktıyı üretir:

Derived::5
Base::5
Derived::9

Yukarıdaki açıklamanın yardımıyla, nedenini görmek kolaydır. Derleme zamanında derleyici, statik işaretçi türlerinin üye işlevlerindeki varsayılan bağımsız değişkenlerin yerine geçer ve mainişlevi aşağıdakilere eşdeğer yapar:

    A * a = new B();
    a->display(5);

    A* aa = new A();
    aa->display(5);

    B* bb = new B();
    bb->display(9);

Diğer cevaplardan da görebileceğiniz gibi, bu karmaşık bir konudur. Bunu yapmaya çalışmak ya da ne yaptığını anlamak yerine (eğer şimdi sormak zorunda kalırsanız, bakıcı bundan bir yıl sonra sormak ya da aramak zorunda kalacak).

Bunun yerine, temel sınıfta varsayılan parametrelerle ortak bir sanal olmayan işlev oluşturun. Ardından, varsayılan parametreleri olmayan ve gerektiğinde alt sınıflarda geçersiz kılınan özel veya korumalı bir sanal işlevi çağırır. O zaman nasıl çalışacağının ayrıntıları hakkında endişelenmenize gerek yok ve kod çok açık.

Bu muhtemelen test ederek makul derecede iyi anlayabileceğiniz bir şeydir (yani, çoğu derleyicinin neredeyse kesinlikle doğru bulduğu dilin yeterince ana akım bir parçasıdır ve derleyiciler arasında farklılıklar görmedikçe, çıktıları oldukça iyi bir şekilde kabul edilebilir).

#include <iostream>

struct base { 
    virtual void x(int a=0) { std::cout << a; }
    virtual ~base() {}
};

struct derived1 : base { 
    void x(int a) { std:: cout << a; }
};

struct derived2 : base { 
    void x(int a = 1) { std::cout << a; }
};

int main() { 
    base *b[3];
    b[0] = new base;
    b[1] = new derived1;
    b[2] = new derived2;

    for (int i=0; i<3; i++) {
        b[i]->x();
        delete b[i];
    }

    derived1 d;
    // d.x();       // won't compile.
    derived2 d2;
    d2.x();
    return 0;
}

Diğer cevapların detaylandırdığı gibi, kötü fikir. Ancak hiç kimse basit ve etkili bir çözümden bahsetmediği için, burada: Parametrelerinizi yapıya dönüştürün ve sonra yapı üyelerine varsayılan değerlere sahip olabilirsiniz!

Yani yerine,

//bad idea
virtual method1(int x = 0, int y = 0, int z = 0)

Bunu yap,

//good idea
struct Param1 {
  int x = 0, y = 0, z = 0;
};
virtual method1(const Param1& p)