Làm thế nào để không cho phép thời gian tạm thời

Đối với một lớp Foo, có cách nào để không cho phép xây dựng nó mà không cần đặt tên cho nó không?

Ví dụ:

Foo("hi");

Và chỉ cho phép nó nếu bạn đặt cho nó một cái tên, như sau?

Foo my_foo("hi");

Vòng đời của cái đầu tiên chỉ là câu lệnh và cái thứ hai là khối bao quanh. Trong trường hợp sử dụng của tôi, Foolà đo thời gian giữa hàm tạo và hàm hủy. Vì tôi không bao giờ tham chiếu đến biến cục bộ, tôi thường quên đưa nó vào và vô tình thay đổi thời gian tồn tại. Thay vào đó, tôi muốn gặp lỗi thời gian biên dịch.

Một giải pháp dựa trên vĩ mô khác:

#define Foo class Foo

Câu lệnh Foo("hi");mở rộng class Foo("hi");thành, không đúng; nhưng Foo a("hi")mở rộng thành class Foo a("hi"), đó là chính xác.

Điều này có lợi thế là nó tương thích với cả mã nguồn và mã nhị phân với mã hiện có (đúng). (Tuyên bố này không hoàn toàn đúng - vui lòng xem Bình luận của Johannes Schaub và cuộc thảo luận tiếp theo bên dưới: "Làm thế nào bạn có thể biết rằng nó là nguồn tương thích với mã hiện có? Bạn của anh ấy bao gồm tiêu đề của anh ấy và có void f () {int Foo = 0;} mà trước đây biên dịch tốt và bây giờ biên dịch sai! Ngoài ra, mọi dòng xác định hàm thành viên của lớp Foo đều bị lỗi: void class Foo :: bar () {} " )

Làm thế nào về một hack nhỏ

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

void Foo (float);


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

Đặt hàm tạo riêng tư nhưng cung cấp cho lớp một phương thức tạo .

Điều này không dẫn đến lỗi trình biên dịch mà là lỗi thời gian chạy. Thay vì đo sai thời gian, bạn nhận được một ngoại lệ có thể chấp nhận được.

Bất kỳ hàm tạo nào bạn muốn bảo vệ đều cần một đối số mặc định set(guard)được gọi.

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

Các đặc điểm là:

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

Trường hợp của f2, f3và việc trả lại "hello"có thể không được mong muốn. Để tránh bị ném, bạn có thể cho phép nguồn của một bản sao chỉ là nguồn tạm thời, bằng cách đặt lại nguồn guardđể bảo vệ chúng tôi ngay bây giờ thay vì nguồn của bản sao. Bây giờ bạn cũng thấy lý do tại sao chúng tôi sử dụng các con trỏ ở trên - nó cho phép chúng tôi linh hoạt.

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

Các đặc tính cho f2, f3và cho return "hello"bây giờ luôn // OK.

Một vài năm trước, tôi đã viết một bản vá cho trình biên dịch GNU C ++ bổ sung một tùy chọn cảnh báo mới cho tình huống đó. Điều này được theo dõi trong một mục Bugzilla .

Thật không may, GCC Bugzilla là một hố chôn nơi các đề xuất tính năng bao gồm bản vá được coi là tốt sẽ chết. :)

Điều này được thúc đẩy bởi mong muốn bắt chính xác loại lỗi là chủ đề của câu hỏi này trong mã sử dụng các đối tượng cục bộ làm tiện ích để khóa và mở khóa, đo thời gian thực thi, v.v.

Tương tự, với việc triển khai của bạn, bạn không thể làm điều này, nhưng bạn có thể sử dụng quy tắc này để có lợi cho mình:

Các đối tượng tạm thời không thể bị ràng buộc với các tham chiếu không phải const

Bạn có thể di chuyển mã từ lớp sang một hàm tự do nhận tham số tham chiếu không phải const. Nếu bạn làm như vậy, Bạn sẽ gặp lỗi trình biên dịch nếu tạm thời cố gắng liên kết với tham chiếu không phải const.

Mẫu mã

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

Đầu ra

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

Đơn giản là không có một hàm tạo mặc định và yêu cầu tham chiếu đến một thể hiện trong mọi hàm tạo.

#include <iostream>
using namespace std;

enum SelfRef { selfRef };

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

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

Không, tôi e rằng điều này là không thể. Nhưng bạn có thể nhận được hiệu ứng tương tự bằng cách tạo macro.

#define FOO(x) Foo _foo(x)

Với điều này, bạn chỉ có thể viết FOO (x) thay vì Foo my_foo (x).

Vì mục tiêu chính là ngăn chặn lỗi, hãy xem xét điều này:

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
}

Bằng cách đó, bạn không thể quên đặt tên cho biến và bạn không thể quên viết struct. Dài dòng, nhưng an toàn.

Khai báo hàm tạo một tham số là rõ ràng và không ai sẽ vô tình tạo một đối tượng của lớp đó.

Ví dụ

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

void fun(const Foo&);

chỉ có thể được sử dụng theo cách này

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

nhưng không bao giờ theo cách này (thông qua một tạm thời trên ngăn xếp)

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

Xem thêm: Alexandrescu, Tiêu chuẩn mã hóa C ++, Mục 40.