Как запретить временные

Есть ли способ запретить создание класса Foo без указания имени?

Например:

Foo("hi");

И разрешить его, только если вы дадите ему имя, например, следующее?

Foo my_foo("hi");

Время жизни первого - это просто инструкция, а второго - закрывающий блок. В моем случае Fooизмерения время между конструктором и деструктором. Поскольку я никогда не ссылаюсь на локальную переменную, я часто забываю ее вставить и случайно меняю время жизни. Вместо этого я хотел бы получить ошибку времени компиляции.

Еще одно решение на основе макросов:

#define Foo class Foo

Утверждение Foo("hi");расширяется до class Foo("hi");неправильного формата; но Foo a("hi")расширяется до class Foo a("hi"), что правильно.

Это имеет то преимущество, что он совместим как с исходным кодом, так и с двоичным кодом с существующим (правильным) кодом. (Это утверждение не совсем верно - см. Комментарий Йоханнеса Шауба и последующее обсуждение ниже: «Как вы можете узнать, что исходный код совместим с существующим кодом? Его друг включает свой заголовок и имеет void f () {int Foo = 0;} который ранее компилировался нормально, а теперь компилируется неправильно! Кроме того, каждая строка, которая определяет функцию-член класса 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;
}

Сделайте конструктор закрытым, но дайте классу метод create .

Это приводит не к ошибке компилятора, а к ошибке времени выполнения. Вместо неправильного измерения времени вы получаете исключение, которое тоже может быть приемлемым.

Любой конструктор, который вы хотите защитить, должен 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значение now 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 - это кладбище, где умирают хорошо продуманные предложения по включенным исправлениям. :)

Это было мотивировано желанием отловить именно те ошибки, которые являются предметом этого вопроса, в коде, который использует локальные объекты в качестве гаджетов для блокировки и разблокировки, измерения времени выполнения и т. Д.

Как и в вашей реализации, вы не можете этого сделать, но можете использовать это правило в своих интересах:

Временные объекты не могут быть привязаны к неконстантным ссылкам

Вы можете переместить код из класса в автономную функцию, которая принимает неконстантный ссылочный параметр. Если вы это сделаете, вы получите ошибку компилятора, если временное приложение попытается привязаться к неконстантной ссылке.

Образец кода

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.