วิธีการไม่อนุญาตชั่วคราว

สำหรับคลาส Foo มีวิธีที่จะไม่อนุญาตให้สร้างโดยไม่ตั้งชื่อได้หรือไม่?

ตัวอย่างเช่น:

Foo("hi");

และอนุญาตเฉพาะในกรณีที่คุณตั้งชื่อดังต่อไปนี้?

Foo my_foo("hi");

อายุการใช้งานของอันแรกเป็นเพียงคำสั่งและอันที่สองคือบล็อกปิดล้อม ในกรณีการใช้งานของฉันFooกำลังวัดเวลาระหว่างตัวสร้างและตัวทำลาย เนื่องจากฉันไม่เคยอ้างถึงตัวแปรภายในฉันจึงมักลืมใส่และเปลี่ยนอายุการใช้งานโดยไม่ได้ตั้งใจ ฉันต้องการรับข้อผิดพลาดเวลาคอมไพล์แทน

โซลูชันที่ใช้มาโครอื่น:

#define Foo class Foo

คำสั่งFoo("hi");ขยายไปถึงclass Foo("hi");ซึ่งผิดรูปแบบ; แต่Foo a("hi")ขยายเป็นclass Foo a("hi")ซึ่งถูกต้อง

สิ่งนี้มีข้อได้เปรียบที่เป็นทั้งซอร์สและไบนารีที่เข้ากันได้กับโค้ดที่มีอยู่ (ถูกต้อง) (การอ้างสิทธิ์นี้ไม่ถูกต้องทั้งหมดโปรดดูความคิดเห็นของ Johannes Schaub และการสนทนาที่ตามมาด้านล่าง: "คุณจะรู้ได้อย่างไรว่าเป็นซอร์สที่เข้ากันได้กับโค้ดที่มีอยู่เพื่อนของเขามีส่วนหัวของเขาและมีโมฆะ f () {int Foo = 0;} ซึ่งก่อนหน้านี้คอมไพล์ดีและคอมไพล์ผิด! นอกจากนี้ทุกบรรทัดที่กำหนดฟังก์ชันสมาชิกของคลาส Foo ล้มเหลว: โมฆะคลาส Foo :: bar () {} " )

วิธีการเกี่ยวกับการแฮ็กเล็กน้อย

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

void Foo (float);


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

กำหนดให้ตัวสร้างเป็นแบบส่วนตัว แต่ให้วิธีการสร้างแก่คลาส

อันนี้ไม่ส่งผลให้เกิดข้อผิดพลาดของคอมไพเลอร์ แต่เป็นข้อผิดพลาดรันไทม์ แทนที่จะวัดเวลาผิดคุณจะได้รับข้อยกเว้นซึ่งอาจยอมรับได้เช่นกัน

ตัวสร้างใด ๆ ที่คุณต้องการป้องกันจำเป็นต้องมีอาร์กิวเมนต์เริ่มต้นที่set(guard)ถูกเรียก

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

ลักษณะคือ:

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

กรณีของf2, f3และการกลับมาของ"hello"อาจจะไม่เป็นที่ต้องการ เพื่อป้องกันการขว้างปาคุณสามารถอนุญาตให้แหล่งที่มาของสำเนาเป็นแบบชั่วคราวได้โดยการตั้งค่าใหม่guardเพื่อป้องกันเราแทนแหล่งที่มาของสำเนา ตอนนี้คุณจะเห็นว่าเหตุใดเราจึงใช้คำแนะนำด้านบนซึ่งช่วยให้เรามีความยืดหยุ่น

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

ลักษณะสำหรับf2, f3และตอนนี้เสมอreturn "hello"// OK

ไม่กี่ปีที่ผ่านมาฉันได้เขียนโปรแกรมแก้ไขสำหรับคอมไพเลอร์ GNU C ++ ซึ่งเพิ่มตัวเลือกคำเตือนใหม่สำหรับสถานการณ์นั้น นี้จะติดตามในรายการ Bugzilla

น่าเสียดายที่ GCC Bugzilla เป็นสถานที่ฝังศพที่คำแนะนำคุณสมบัติที่รวมอยู่ในแพตช์ที่ได้รับการพิจารณาเป็นอย่างดีจะตาย :)

สิ่งนี้ได้รับแรงบันดาลใจจากความปรารถนาที่จะตรวจจับประเภทของจุดบกพร่องที่เป็นประเด็นของคำถามนี้ในรหัสซึ่งใช้วัตถุในพื้นที่เป็นอุปกรณ์สำหรับล็อคและปลดล็อกการวัดเวลาดำเนินการและอื่น ๆ

เช่นเดียวกับการใช้งานของคุณคุณไม่สามารถทำได้ แต่คุณสามารถใช้กฎนี้เพื่อประโยชน์ของคุณ:

อ็อบเจ็กต์ชั่วคราวไม่สามารถถูกผูกไว้กับการอ้างอิงที่ไม่ใช่ const

คุณสามารถย้ายรหัสจากคลาสไปยังฟังก์ชันอิสระซึ่งรับพารามิเตอร์อ้างอิงที่ไม่ใช่ const หากคุณทำเช่นนั้นคุณจะได้รับข้อผิดพลาดของคอมไพเลอร์หากมีการพยายามเชื่อมโยงกับการอ้างอิงที่ไม่ใช่ const ชั่วคราว

ตัวอย่างโค้ด

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

เอาต์พุต

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

เพียงแค่ไม่มีตัวสร้างเริ่มต้นและต้องมีการอ้างอิงถึงอินสแตนซ์ในตัวสร้างทุกตัว

#include <iostream>
using namespace std;

enum SelfRef { selfRef };

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

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

ไม่ฉันกลัวว่าจะทำไม่ได้ แต่คุณสามารถได้รับผลเช่นเดียวกันโดยการสร้างมาโคร

#define FOO(x) Foo _foo(x)

ด้วยสิ่งนี้คุณสามารถเขียน FOO (x) แทน Foo my_foo (x) ได้

เนื่องจากเป้าหมายหลักคือการป้องกันจุดบกพร่องให้พิจารณาสิ่งนี้:

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
}

structวิธีการที่คุณไม่สามารถลืมที่จะตั้งชื่อตัวแปรและคุณไม่สามารถลืมที่จะเขียน Verbose แต่ปลอดภัย

ประกาศตัวสร้างพารามิเตอร์หนึ่งพารามิเตอร์เป็นแบบชัดแจ้งและจะไม่มีใครสร้างอ็อบเจ็กต์ของคลาสนั้นโดยไม่ได้ตั้งใจ

ตัวอย่างเช่น

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

void fun(const Foo&);

สามารถใช้ได้ด้วยวิธีนี้เท่านั้น

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

แต่อย่าทำแบบนี้ (ผ่านสแต็กชั่วคราว)

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

ดูเพิ่มเติมที่: Alexandrescu, C ++ Coding Standards, Item 40