C ++ 'da başvuruya göre geçerken bir parametre için varsayılan değer

Parametreyi referans olarak iletirken bir fonksiyonun parametresine varsayılan bir değer vermek mümkün mü? C ++ ile

Örneğin, şöyle bir işlev bildirmeye çalıştığımda:

virtual const ULONG Write(ULONG &State = 0, bool sequence = true);

Bunu yaptığımda bir hata veriyor:

hata C2440: 'varsayılan bağımsız değişken': 'const int' değerinden 'işaretsiz uzun ve' 'const' olmayan bir başvuru l olmayan bir değere bağlanamaz

Bunu const başvurusu için yapabilirsiniz, ancak const olmayan bir başvuru için yapamazsınız. Bunun nedeni, C ++ 'nın geçici (bu durumda varsayılan değer) const olmayan bir başvuruya bağlanmasına izin vermemesidir.

Bunu aşmanın bir yolu, varsayılan olarak gerçek bir örnek kullanmaktır:

static int AVAL = 1;

void f( int & x = AVAL ) {
   // stuff
} 

int main() {
     f();       // equivalent to f(AVAL);
}

ancak bu çok sınırlı pratik kullanıma sahiptir.

Cevabınıza yapılan doğrudan yorumlardan birinde zaten söylendi, ancak resmi olarak belirtmek için. Kullanmak istediğiniz şey aşırı yüklenmedir:

virtual const ULONG Write(ULONG &State, bool sequence);
inline const ULONG Write()
{
  ULONG state;
  bool sequence = true;
  Write (state, sequence);
}

Fonksiyon aşırı yüklerini kullanmanın ek faydaları da vardır. İlk olarak, istediğiniz herhangi bir argümanı varsayılan olarak belirleyebilirsiniz:

class A {}; 
class B {}; 
class C {};

void foo (A const &, B const &, C const &);
void foo (B const &, C const &); // A defaulted
void foo (A const &, C const &); // B defaulted
void foo (C const &); // A & B defaulted etc...

Türetilmiş sınıftaki sanal işlevlere varsayılan bağımsız değişkenleri yeniden tanımlamak da mümkündür, bu da aşırı yüklemeden kaçınır:

class Base {
public:
  virtual void f1 (int i = 0);  // default '0'

  virtual void f2 (int);
  inline void f2 () {
    f2(0);                      // equivalent to default of '0'
  }
};

class Derived : public Base{
public:
  virtual void f1 (int i = 10);  // default '10'

  using Base::f2;
  virtual void f2 (int);
};

void bar ()
{
  Derived d;
  Base & b (d);
  d.f1 ();   // '10' used
  b.f1 ();   // '0' used

  d.f2 ();   // f1(int) called with '0' 
  b.f2 ();   // f1(int) called with '0
}

Bir varsayılanın gerçekten kullanılması gereken tek bir durum vardır ve bu bir kurucu üzerindedir. Bir kurucuyu diğerinden çağırmak mümkün değildir ve bu nedenle bu teknik bu durumda çalışmaz.

Hala isteğe bağlı argümanlar sağlamanın eski C yolu var: yoksa NULL olabilen bir işaretçi:

void write( int *optional = 0 ) {
    if (optional) *optional = 5;
}

Bu küçük şablon size şu konularda yardımcı olacaktır:

template<typename T> class ByRef {
public:
    ByRef() {
    }

    ByRef(const T value) : mValue(value) {
    }

    operator T&() const {
        return((T&)mValue);
    }

private:
    T mValue;
};

Ardından şunları yapabileceksiniz:

virtual const ULONG Write(ULONG &State = ByRef<ULONG>(0), bool sequence = true);

Hayır, mümkün değil.

Başvuruya göre geçiş, işlevin parametrenin değerini değiştirebileceği anlamına gelir. Parametre arayan tarafından sağlanmadıysa ve varsayılan sabitten geliyorsa, işlevin değişmesi gereken nedir?

Bir bağımsız değişkeni başvuruya göre iletmenin iki nedeni vardır: (1) performans için (bu durumda const başvurusuyla geçmek istersiniz) ve (2) çünkü işlev içindeki bağımsız değişkenin değerini değiştirme yeteneğine ihtiyacınız vardır.

Modern mimarilerde imzasız bir süre geçmenin sizi çok fazla yavaşlattığından şüpheliyim. Dolayısıyla State, yöntemin içindeki değerini değiştirmeyi düşündüğünüzü varsayıyorum . Derleyici şikayet ediyor çünkü sabit 0bir rvalue (hata mesajında ​​"non-lvalue") ve değiştirilemez (const hata mesajında) olduğu için değiştirilemiyor.

Basitçe ifade etmek gerekirse, geçirilen argümanı değiştirebilen bir yöntem istersiniz, ancak varsayılan olarak değiştirilemeyen bir argüman iletmek istersiniz.

Başka bir deyişle, constreferans olmayanların gerçek değişkenlere atıfta bulunması gerekir. İmzadaki ( 0) varsayılan değer gerçek bir değişken değildir. Aynı problemle karşılaşıyorsunuz:

struct Foo {
    virtual ULONG Write(ULONG& State, bool sequence = true);
};

Foo f;
ULONG s = 5;
f.Write(s); // perfectly OK, because s is a real variable
f.Write(0); // compiler error, 0 is not a real variable
            // if the value of 0 were changed in the function,
            // I would have no way to refer to the new value

StateYöntemin içinde gerçekten değişme niyetinde değilseniz, onu basitçe bir const ULONG&. Ancak bundan büyük bir performans avantajı elde etmeyeceksiniz, bu yüzden onu referans olmayan bir şekilde değiştirmenizi tavsiye ederim ULONG. Zaten a döndürdüğünüzü fark ULONGettim ve değerinin Stategerekli herhangi bir değişiklikten sonra değeri olduğuna dair sinsi bir şüphem var . Bu durumda yöntemi basitçe şöyle bildiririm:

// returns value of State
virtual ULONG Write(ULONG State = 0, bool sequence = true);

Elbette, ne yazdığından veya nereye yazdığından pek emin değilim. Ama bu başka bir zaman için başka bir soru.

Varsayılan bir parametre için sabit bir hazır bilgi kullanamazsınız, ancak aynı nedenden birini işlev çağrısı için parametre olarak kullanamazsınız. Referans değerlerinin bir adresi olmalıdır, sabit referans değerlerinin olması gerekmez (yani, r değerleri veya sabit değişmez değerler olabilirler).

int* foo (int& i )
{
   return &i;
}

foo(0); // compiler error.

const int* bar ( const int& i )
{
   return &i;
}

bar(0); // ok.

Varsayılan değerinizin bir adresi olduğundan ve iyi olduğunuzdan emin olun.

int null_object = 0;

int Write(int &state = null_object, bool sequence = true)
{
   if( &state == &null_object )
   {
      // called with default paramter
      return sequence? 1: rand();
   }
   else
   {
      // called with user parameter
      state += sequence? 1: rand();
      return state;
   }
}

Bu kalıbı, değişken veya boş olabilecek bir parametremde birkaç kez kullandım. Normal yaklaşım, bu durumda kullanıcının bir işaretçiyi geçmesini sağlamaktır. Değeri doldurmanızı istemiyorlarsa bir NULL işaretçisi geçirirler. Nesne yaklaşımını boşa çıkarmayı seviyorum. Aranan ucun kodunu aşırı derecede karmaşıklaştırmadan arayanların hayatını kolaylaştırır.

Sanmıyorum ve bunun nedeni, varsayılan değerlerin sabitler olarak değerlendirilmesidir ve referansla iletilen değerler, siz de sabit bir referans olarak beyan etmedikçe, değişebilmelidir.

Başka bir yol da şunlar olabilir:

virtual const ULONG Write(ULONG &State, bool sequence = true);

// wrapper
const ULONG Write(bool sequence = true)
{
   ULONG dummy;
   return Write(dummy, sequence);
}

daha sonra aşağıdaki çağrılar mümkündür:

ULONG State;
object->Write(State, false); // sequence is false, "returns" State
object->Write(State); // assumes sequence = true, "returns" State
object->Write(false); // sequence is false, no "return"
object->Write(); // assumes sequence = true, no "return"

void f(const double& v = *(double*) NULL)
{
  if (&v == NULL)
    cout << "default" << endl;
  else
    cout << "other " << v << endl;
}

OO durumunda ... Verilen bir Sınıfın sahip olduğunu ve "Varsayılan" olduğunu söylemek, bu Varsayılanın (değerin) uygun şekilde bildirilmesi gerektiği ve ardından Varsayılan Parametre olarak usd olabileceği anlamına gelir. Ör:

class Pagination {
public:
    int currentPage;
    //...
    Pagination() {
        currentPage = 1;
        //...
    }
    // your Default Pagination
    static Pagination& Default() {
        static Pagination pag;
        return pag;
    }
};

Yönteminize göre ...

 shared_ptr<vector<Auditoria> > 
 findByFilter(Auditoria& audit, Pagination& pagination = Pagination::Default() ) {

Bu çözümler oldukça uygundur çünkü bu durumda "Global varsayılan Sayfalandırma" tek bir "referans" değeridir. Ayrıca, çalışma zamanında "gobal düzeyinde" bir yapılandırma gibi varsayılan değerleri değiştirme gücüne sahip olacaksınız, örn: kullanıcı sayfalandırma gezinme tercihleri ​​vb.

State için const niteleyicisi ile mümkündür:

virtual const ULONG Write(const ULONG &State = 0, bool sequence = true);

void revealSelection(const ScrollAlignment& = ScrollAlignment::alignCenterIfNeeded, bool revealExtent = false);

Bunun için de oldukça kirli bir numara var:

virtual const ULONG Write(ULONG &&State = 0, bool sequence = true);

Bu durumda telefonla aramanız gerekir std::move :

ULONG val = 0;
Write(std::move(val));

Bu sadece komik bir çözüm, gerçek kodda kullanılmasını kesinlikle önermiyorum!

Bunun için bir çözümüm var, varsayılan değerle ilgili aşağıdaki örneğe bakın int&:

class Helper
{
public:
    int x;
    operator int&() { return x; }
};

// How to use it:
void foo(int &x = Helper())
{

}

Bunu istediğiniz herhangi bir önemsiz veri türü için yapabilirsiniz, örneğin bool, double...

2 aşırı yük fonksiyonu tanımlayın.

virtual const ULONG Write(ULONG &State, bool sequence = true);

virtual const ULONG Write(bool sequence = true)
{
    int State = 0;
    return Write(State, sequence);
}

sanal sabit ULONG Yazma (ULONG & Durum = 0, bool dizisi = doğru);

Cevap oldukça basit ve açıklamakta pek iyi değilim, ancak const olmayan bir parametreye varsayılan bir değer geçirmek istiyorsanız, muhtemelen bu işlevde değiştirilecekse, şu şekilde kullanın:

virtual const ULONG Write(ULONG &State = *(ULONG*)0, bool sequence =
> true);