Nilai default ke parameter saat meneruskan referensi di C ++

Apakah mungkin untuk memberikan nilai default ke parameter suatu fungsi saat kita meneruskan parameter dengan referensi. di C ++

Misalnya, ketika saya mencoba mendeklarasikan fungsi seperti:

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

Ketika saya melakukan ini, itu memberikan kesalahan:

kesalahan C2440: 'argumen default': tidak dapat mengonversi dari 'const int' menjadi 'unsigned long &' Referensi yang bukan untuk 'const' tidak dapat terikat ke nilai non-l

Anda bisa melakukannya untuk referensi const, tetapi tidak untuk non-const. Ini karena C ++ tidak mengizinkan sementara (nilai default dalam kasus ini) untuk terikat ke referensi non-const.

Salah satu cara untuk melakukannya adalah dengan menggunakan instance aktual sebagai default:

static int AVAL = 1;

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

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

tetapi penggunaan praktis ini sangat terbatas.

Itu telah dikatakan di salah satu komentar langsung ke jawaban Anda, tetapi hanya untuk menyatakannya secara resmi. Yang ingin Anda gunakan adalah kelebihan beban:

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

Menggunakan kelebihan fungsi juga memiliki manfaat tambahan. Pertama, Anda dapat menetapkan default argumen apa pun yang Anda inginkan:

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...

Juga dimungkinkan untuk mendefinisikan ulang argumen default ke fungsi virtual di kelas turunan, yang menghindari overloading:

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
}

Hanya ada satu situasi di mana default benar-benar perlu digunakan, dan itu ada di konstruktor. Tidak mungkin memanggil satu konstruktor dari yang lain, sehingga teknik ini tidak berfungsi dalam kasus itu.

Masih ada cara C lama untuk menyediakan argumen opsional: pointer yang bisa berupa NULL jika tidak ada:

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

Template kecil ini akan membantu Anda:

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

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

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

private:
    T mValue;
};

Kemudian Anda akan dapat:

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

Tidak, itu tidak mungkin.

Melewati referensi menyiratkan bahwa fungsi tersebut mungkin mengubah nilai parameter. Jika parameter tidak disediakan oleh pemanggil dan berasal dari konstanta default, fungsi apa yang harus diubah?

Ada dua alasan untuk meneruskan argumen dengan referensi: (1) untuk performa (dalam hal ini Anda ingin meneruskan referensi const) dan (2) karena Anda memerlukan kemampuan untuk mengubah nilai argumen di dalam fungsi.

Saya sangat meragukan bahwa melewatkan waktu yang lama pada arsitektur modern terlalu memperlambat Anda. Jadi saya berasumsi bahwa Anda bermaksud mengubah nilai Statedi dalam metode. Kompilator mengeluh karena konstanta 0tidak dapat diubah, karena ini adalah nilai r ("non-lvalue" dalam pesan kesalahan) dan tidak dapat diubah ( constdalam pesan kesalahan).

Sederhananya, Anda menginginkan metode yang dapat mengubah argumen yang diteruskan, tetapi secara default Anda ingin meneruskan argumen yang tidak dapat diubah.

Dengan kata lain, non- constreferensi harus mengacu pada variabel aktual. Nilai default di function signature ( 0) bukanlah variabel nyata. Anda mengalami masalah yang sama seperti:

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

Jika Anda tidak benar-benar berniat untuk mengubah Statedi dalam metode ini, Anda dapat mengubahnya menjadi const ULONG&. Tetapi Anda tidak akan mendapatkan keuntungan kinerja yang besar dari itu, jadi saya akan merekomendasikan untuk mengubahnya menjadi non-referensi ULONG. Saya perhatikan bahwa Anda telah mengembalikan a ULONG, dan saya curiga bahwa nilainya adalah nilai Statesetelah modifikasi yang diperlukan. Dalam hal ini saya hanya akan mendeklarasikan metode sebagai berikut:

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

Tentu saja, saya tidak yakin apa yang Anda tulis atau ke mana. Tapi itu pertanyaan lain untuk lain waktu.

Anda tidak dapat menggunakan literal konstan untuk parameter default karena alasan yang sama Anda tidak dapat menggunakan satu sebagai parameter untuk pemanggilan fungsi. Nilai referensi harus memiliki alamat, nilai referensi konstan tidak perlu (yaitu dapat berupa nilai r atau literal konstan).

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

foo(0); // compiler error.

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

bar(0); // ok.

Pastikan nilai default Anda memiliki alamat dan Anda baik-baik saja.

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;
   }
}

Saya telah menggunakan pola ini beberapa kali di mana saya memiliki parameter yang bisa berupa variabel atau nol. Pendekatan biasa adalah meminta pengguna untuk memasukkan pointer ke kasus ini. Mereka mengirimkan pointer NULL jika mereka tidak ingin Anda mengisi nilainya. Saya suka pendekatan objek null. Itu membuat hidup penelepon lebih mudah tanpa memperumit kode panggilan.

Saya kira tidak, dan alasannya adalah bahwa nilai default dievaluasi menjadi konstanta dan nilai yang diteruskan oleh referensi harus dapat berubah, kecuali jika Anda juga menyatakannya sebagai referensi konstan.

Cara lain bisa jadi sebagai berikut:

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

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

maka panggilan berikut dimungkinkan:

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;
}

Dalam kasus OO ... Untuk mengatakan bahwa Kelas yang Diberikan memiliki dan "Default" berarti Default ini (nilai) harus dideklarasikan secara langsung dan kemudian dapat digunakan sebagai Parameter Default misalnya:

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

Tentang Metode Anda ...

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

Solusi ini sangat cocok karena dalam kasus ini, "Penomoran halaman default global" adalah nilai "referensi" tunggal. Anda juga dapat mengubah nilai default pada waktu proses seperti konfigurasi "level-gobal", misalnya: preferensi navigasi penomoran halaman pengguna, dll.

Itu mungkin dengan kualifikasi const untuk Negara:

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

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

Ada juga trik kotor untuk ini:

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

Dalam hal ini Anda harus memanggilnya dengan std::move:

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

Ini hanya beberapa solusi lucu, saya sama sekali tidak merekomendasikannya menggunakan kode nyata!

Saya memiliki solusi untuk ini, lihat contoh berikut tentang nilai default untuk int&:

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

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

}

Anda dapat melakukannya untuk tipe data sepele apa pun yang Anda inginkan, seperti bool, double...

Tentukan 2 fungsi kelebihan beban.

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

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

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

Jawabannya cukup sederhana dan saya tidak begitu pandai menjelaskan tetapi jika Anda ingin meneruskan nilai default ke parameter non-const yang mungkin akan dimodifikasi dalam fungsi ini adalah menggunakannya seperti ini:

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