임시를 허용하지 않는 방법

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의 설명과 다음 토론을 참조하십시오. "기존 코드와 소스가 호환되는지 어떻게 알 수 있습니까? 그의 친구가 헤더를 포함하고 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;
}

생성자를 비공개로하지만 클래스에 생성 메서드를 제공합니다 .

이로 인해 컴파일러 오류가 발생하지 않지만 런타임 오류가 발생합니다. 잘못된 시간을 측정하는 대신 허용 가능한 예외가 발생합니다.

보호하려는 모든 생성자 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는 잘 고려 된 패치 포함 기능 제안이 사라지는 매장지입니다. :)

이는 로컬 객체를 잠금 및 잠금 해제, 실행 시간 측정 등을위한 가젯으로 사용하는 코드에서이 질문의 주제 인 버그 종류를 정확히 포착하려는 욕구에서 비롯되었습니다.

현재 구현에서는이 작업을 수행 할 수 없지만이 규칙을 유용하게 사용할 수 있습니다.

임시 개체는 상수가 아닌 참조에 바인딩 될 수 없습니다.

코드를 클래스에서 상수가 아닌 참조 매개 변수를 사용하는 독립 함수로 이동할 수 있습니다. 그렇게하면 임시가 상수가 아닌 참조에 바인딩하려고하면 컴파일러 오류가 발생합니다.

코드 샘플

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 my_foo (x) 대신 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");
}

참조 : Alexandrescu, C ++ Coding Standards, Item 40.