一時を禁止する方法

クラスFooに、名前を付けずに構築を禁止する方法はありますか？

例えば：

Foo("hi");

そして、次のような名前を付けた場合にのみ許可しますか？

Foo my_foo("hi");

最初のライフタイムは単にステートメントであり、2番目のライフタイムは囲みブロックです。私の使用例で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;
}

コンストラクターをプライベートにしますが、クラスに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のソースではなく保護するようにをリセットすることにより、コピーのソースを一時的なものにすることができます。これで、上記のポインターを使用した理由もわかります。これにより、柔軟性を高めることができます。

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 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。冗長ですが安全です。

1パラメータコンストラクタを明示的に宣言すると、そのクラスのオブジェクトが意図せずに作成されることはありません。

例えば

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

void fun(const Foo&);

この方法でのみ使用できます

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

しかし、これは決してありません（スタック上の一時的なものを介して）

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

参照：Alexandrescu、C ++コーディング標準、アイテム40。