Як заборонити тимчасово

Для класу Foo, чи існує спосіб заборонити його конструювання, не даючи ім'я?

Наприклад:

Foo("hi");

І дозволити це лише в тому випадку, якщо ви дасте ім’я, як-от наступне?

Foo my_foo("hi");

Час життя першого - це лише твердження, а другого - блок, що додається. У моєму випадку використання - Fooце вимірювання часу між конструктором та деструктором. Оскільки я ніколи не посилаюсь на локальну змінну, я часто забуваю помістити її і випадково змінити час життя. Я хотів би отримати помилку часу компіляції.

Ще одне рішення на основі макросу:

#define Foo class Foo

Заява Foo("hi");розширюється до того class Foo("hi");, що неправильно формується; але Foo a("hi")розширюється на class Foo a("hi"), що правильно.

Це має перевагу в тому, що він є одночасно вихідним та бінарним сумісним із існуючим (правильним) кодом. (Ця претензія не зовсім коректна - дивіться коментар Йоганнеса Шауба та дискусію, що випливає нижче: "Як ви можете знати, що це джерело, сумісне з наявним кодом? який раніше компілював штрафи, а тепер неправильно компілюється! Також кожен рядок, що визначає функцію члена класу Foo, не вдається: void class 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.

Зразок коду

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. Докладний, але безпечний.

Оголосіть однопараметричний конструктор як явний, і ніхто ніколи не буде створювати об’єкти цього класу ненавмисно.

Наприклад

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

void fun(const Foo&);

може бути використаний лише таким чином

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

але ніколи так (через тимчасовий на стек)

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

Дивіться також: Олександреску, Стандарти кодування C ++, пункт 40.