Geçicilere nasıl izin verilmez

Bir Foo sınıfı için, ona bir isim vermeden inşa etmeye izin vermemenin bir yolu var mı?

Örneğin:

Foo("hi");

Ve sadece aşağıdaki gibi bir isim verirseniz izin verir misiniz?

Foo my_foo("hi");

İlkinin kullanım ömrü sadece ifadedir ve ikincisi de çevreleyen bloktur. Benim kullanım durumumda, Fookurucu ve yıkıcı arasındaki süreyi ölçmek. Yerel değişkene asla başvurmadığım için, sık sık onu yerleştirmeyi unutuyorum ve yanlışlıkla yaşam süresini değiştiriyorum. Bunun yerine bir derleme zamanı hatası almak istiyorum.

Başka bir makro tabanlı çözüm:

#define Foo class Foo

Bildirimi Foo("hi");genişler class Foo("hi");kötü şekillendirilmiş olan; ama doğru olan olarak Foo a("hi")genişler class Foo a("hi").

Bu, mevcut (doğru) kodla hem kaynak hem de ikili uyumlu olma avantajına sahiptir. (Bu iddia tamamen doğru değil - lütfen Johannes Schaub'un Yorumuna ve aşağıdaki tartışmaya bakın: "Kaynak kodun mevcut kodla uyumlu olduğunu nasıl bilebilirsiniz? Arkadaşı başlığını içeriyor ve void f () {int Foo = 0;} daha önce iyi derleyen ve şimdi yanlış derleyen! Ayrıca, Foo sınıfının bir üye işlevini tanımlayan her satır başarısız olur: void class Foo :: bar () {} " )

Biraz hacklemeye ne dersin

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

void Foo (float);


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

Yapıcıyı özel yapın, ancak sınıfa bir oluşturma yöntemi verin.

Bu bir derleyici hatasıyla sonuçlanmaz, ancak bir çalışma zamanı hatasıyla sonuçlanır. Yanlış bir zamanı ölçmek yerine, kabul edilebilir bir istisna elde edersiniz.

Korumak istediğiniz herhangi bir kurucu set(guard), çağrılan varsayılan bir argümana ihtiyaç duyar .

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

Özellikler şunlardır:

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

Durumunda f2, f3ve dönüşü "hello"istediği olmayabilir. Fırlatmayı önlemek için guard, kopyanın kaynağı yerine şimdi koruma ayarını sıfırlayarak kopyanın kaynağının geçici olmasına izin verebilirsiniz . Şimdi, yukarıdaki işaretçileri neden kullandığımızı da anlıyorsunuz - esnek olmamızı sağlıyor.

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

İçin karakteristikleri f2, f3ve için return "hello"her zaman şimdi // OK.

Birkaç yıl önce GNU C ++ derleyicisi için bu durum için yeni bir uyarı seçeneği ekleyen bir yama yazdım . Bu bir Bugzilla öğesinde izlenir .

Ne yazık ki, GCC Bugzilla, iyi düşünülmüş yama dahil özellik önerilerinin yok olmaya gittiği bir mezarlık alanıdır. :)

Bu, bu sorunun konusu olan ve yerel nesneleri kilitleme ve kilit açma, yürütme süresini ölçme vb. Araçlar olarak kullanan kodda tam olarak bu tür hataları yakalama arzusundan kaynaklanıyordu.

Olduğu gibi, uygulamanızda bunu yapamazsınız, ancak bu kuralı kendi yararınıza kullanabilirsiniz:

Geçici nesneler, const olmayan referanslara bağlanamaz

Kodu sınıftan, const olmayan bir referans parametresi alan bağımsız bir işleve taşıyabilirsiniz. Bunu yaparsanız, geçici bir sabit olmayan referansa bağlanmaya çalışırsa bir derleyici hatası alırsınız.

Kod Örneği

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

Çıktı

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&)’

Basitçe varsayılan bir kurucuya sahip değilsiniz ve her yapıcıda bir örneğe başvuru gerektirir.

#include <iostream>
using namespace std;

enum SelfRef { selfRef };

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

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

Hayır, korkarım bu mümkün değil. Ancak bir makro oluşturarak aynı etkiyi elde edebilirsiniz.

#define FOO(x) Foo _foo(x)

Bunu yerine getirdiğinizde, Foo my_foo (x) yerine FOO (x) yazabilirsiniz.

Birincil amaç hataları önlemek olduğundan, şunu göz önünde bulundurun:

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
}

Bu şekilde değişkeni adlandırmayı ve yazmayı unutamazsınız struct. Ayrıntılı, ama güvenli.

Bir parametrik kurucunun açık olduğunu ve hiç kimsenin istemeden o sınıfın bir nesnesini yaratmayacağını bildirin.

Örneğin

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

void fun(const Foo&);

sadece bu şekilde kullanılabilir

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

ama asla bu şekilde (yığın üzerinde geçici olarak)

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

Ayrıca bakınız: Alexandrescu, C ++ Kodlama Standartları, Madde 40.