Bagaimana cara melarang pekerja sementara

Untuk kelas Foo, apakah ada cara untuk melarang pembuatannya tanpa memberinya nama?

Sebagai contoh:

Foo("hi");

Dan hanya izinkan jika Anda memberinya nama, seperti berikut?

Foo my_foo("hi");

Masa pakai yang pertama hanyalah pernyataan, dan yang kedua adalah blok penutup. Dalam kasus penggunaan saya, Foomengukur waktu antara konstruktor dan destruktor. Karena saya tidak pernah mengacu pada variabel lokal, saya sering lupa memasukkannya, dan tidak sengaja mengubah masa pakai. Saya ingin mendapatkan kesalahan waktu kompilasi.

Solusi berbasis makro lainnya:

#define Foo class Foo

Pernyataan itu Foo("hi");meluas ke class Foo("hi");, yang bentuknya buruk; tetapi Foo a("hi")berkembang menjadi class Foo a("hi"), yang benar.

Ini memiliki keuntungan karena kompatibel dengan sumber dan biner dengan kode yang ada (benar). (Klaim ini tidak sepenuhnya benar - silakan lihat Komentar Johannes Schaub dan diskusi selanjutnya di bawah ini: "Bagaimana Anda bisa tahu bahwa itu adalah sumber yang kompatibel dengan kode yang ada? Temannya menyertakan tajuknya dan memiliki void f () {int Foo = 0;} yang sebelumnya dikompilasi dengan baik dan sekarang salah dikompilasi! Selain itu, setiap baris yang mendefinisikan fungsi anggota kelas Foo gagal: void class Foo :: bar () {} " )

Bagaimana dengan sedikit retasan

class Foo
{
    public:
        Foo (const char*) {}
};

void Foo (float);


int main ()
{
    Foo ("hello"); // error
    class Foo a("hi"); // OK
    return 1;
}

Jadikan konstruktor pribadi tetapi berikan kelas metode buat .

Yang ini tidak menghasilkan kesalahan kompiler, tetapi kesalahan runtime. Alih-alih mengukur waktu yang salah, Anda mendapatkan pengecualian yang mungkin juga dapat diterima.

Setiap konstruktor yang ingin Anda jaga membutuhkan argumen default yang set(guard)dipanggil.

struct Guard {
  Guard()
    :guardflagp()
  { }

  ~Guard() {
    assert(guardflagp && "Forgot to call guard?");
    *guardflagp = 0;
  }

  void *set(Guard const *&guardflag) {
    if(guardflagp) {
      *guardflagp = 0;
    }

    guardflagp = &guardflag;
    *guardflagp = this;
  }

private:
  Guard const **guardflagp;
};

class Foo {
public:
  Foo(const char *arg1, Guard &&g = Guard()) 
    :guard()
  { g.set(guard); }

  ~Foo() {
    assert(!guard && "A Foo object cannot be temporary!");
  }

private:
  mutable Guard const *guard;
}; 

Ciri-cirinya adalah:

Foo f() {
  // OK (no temporary)
  Foo f1("hello");

  // may throw (may introduce a temporary on behalf of the compiler)
  Foo f2 = "hello";

  // may throw (introduces a temporary that may be optimized away
  Foo f3 = Foo("hello");

  // OK (no temporary)
  Foo f4{"hello"};

  // OK (no temporary)
  Foo f = { "hello" };

  // always throws
  Foo("hello");

  // OK (normal copy)
  return f;

  // may throw (may introduce a temporary on behalf of the compiler)
  return "hello";

  // OK (initialized temporary lives longer than its initializers)
  return { "hello" };
}

int main() {
  // OK (it's f that created the temporary in its body)
  f();

  // OK (normal copy)
  Foo g1(f());

  // OK (normal copy)
  Foo g2 = f();
}

Kasus f2, f3dan kembalinya "hello"mungkin tidak diinginkan. Untuk mencegah pelemparan, Anda dapat mengizinkan sumber salinan menjadi sementara, dengan menyetel ulang guardmenjadi sekarang lindungi kami, bukan sumber salinan. Sekarang Anda juga melihat mengapa kami menggunakan petunjuk di atas - ini memungkinkan kami untuk menjadi fleksibel.

class Foo {
public:
  Foo(const char *arg1, Guard &&g = Guard()) 
    :guard()
  { g.set(guard); }

  Foo(Foo &&other)
    :guard(other.guard)
  {
    if(guard) {
      guard->set(guard);
    }
  }

  Foo(const Foo& other)
    :guard(other.guard)
  {
    if(guard) {
      guard->set(guard);
    }
  }

  ~Foo() {
    assert(!guard && "A Foo object cannot be temporary!");
  }

private:
  mutable Guard const *guard;
}; 

Ciri-ciri untuk f2, f3dan untuk return "hello"saat ini selalu // OK.

Beberapa tahun yang lalu saya menulis tambalan untuk kompiler GNU C ++ yang menambahkan opsi peringatan baru untuk situasi itu. Ini dilacak dalam item Bugzilla .

Sayangnya, GCC Bugzilla adalah kuburan di mana saran fitur yang termasuk patch dianggap mati. :)

Hal ini dimotivasi oleh keinginan untuk menangkap dengan tepat jenis bug yang menjadi subjek pertanyaan ini dalam kode yang menggunakan objek lokal sebagai gadget untuk mengunci dan membuka kunci, mengukur waktu eksekusi dan sebagainya.

Apa adanya, dengan penerapan Anda, Anda tidak dapat melakukan ini, tetapi Anda dapat menggunakan aturan ini untuk keuntungan Anda:

Objek sementara tidak dapat terikat ke referensi non-const

Anda dapat memindahkan kode dari kelas ke fungsi berdiri bebas yang menggunakan parameter referensi non-const. Jika Anda melakukannya, Anda akan mendapatkan kesalahan compiler jika sementara mencoba untuk mengikat ke referensi non-const.

Contoh Kode

class Foo
{
    public:
        Foo(const char* ){}
        friend void InitMethod(Foo& obj);
};

void InitMethod(Foo& obj){}

int main()
{
    Foo myVar("InitMe");
    InitMethod(myVar);    //Works

    InitMethod("InitMe"); //Does not work  
    return 0;
}

Keluaran

prog.cpp: In function ‘int main()’:
prog.cpp:13: error: invalid initialization of non-const reference of type ‘Foo&’ from a temporary of type ‘const char*’
prog.cpp:7: error: in passing argument 1 of ‘void InitMethod(Foo&)’

Cukup tidak memiliki konstruktor default, dan memang memerlukan referensi ke sebuah instance di setiap konstruktor.

#include <iostream>
using namespace std;

enum SelfRef { selfRef };

struct S
{
    S( SelfRef, S const & ) {}
};

int main()
{
    S a( selfRef, a );
}

Tidak, saya khawatir ini tidak mungkin. Tapi Anda bisa mendapatkan efek yang sama dengan membuat makro.

#define FOO(x) Foo _foo(x)

Dengan ini, Anda cukup menulis FOO (x) alih-alih Foo my_foo (x).

Karena tujuan utamanya adalah mencegah bug, pertimbangkan ini:

struct Foo
{
  Foo( const char* ) { /* ... */ }
};

enum { Foo };

int main()
{
  struct Foo foo( "hi" ); // OK
  struct Foo( "hi" ); // fail
  Foo foo( "hi" ); // fail
  Foo( "hi" ); // fail
}

Dengan begitu Anda tidak bisa lupa memberi nama variabel dan Anda tidak bisa lupa untuk menulis struct. Verbose, tapi aman.

Deklarasikan konstruktor satu parametrik sebagai eksplisit dan tidak ada yang akan membuat objek dari kelas itu secara tidak sengaja.

Sebagai contoh

class Foo
{
public: 
  explicit Foo(const char*);
};

void fun(const Foo&);

hanya dapat digunakan dengan cara ini

void g() {
  Foo a("text");
  fun(a);
}

tapi tidak pernah seperti ini (melalui sementara di tumpukan)

void g() {
  fun("text");
}

Lihat juga: Alexandrescu, C ++ Coding Standards, Item 40.