解説

擬似例外処理機構は、static_exception クラスとして提供されています。

template <typename T>
class static_exception {
  public:
    T const& static_catch(Void) const;
  protected:
    Bool static_try(Void) const;
    Void static_throw(static_exception<T> const& param);
    Void static_throw(T const& param);
};

擬似例外処理機構は SFCApplication や SFRApplication クラスなど static_exception<T> から派生したクラスで使えます。

使用例

class MyApp : public SFCApplication {
  SFMSEALCOPY(MyApp)
  private:
    Void SubFunc(Void) static_throws;    
    SFCError MyAllocation(Void) { ... }  // エラーが発生する可能性のある処理
  public:
    Void MainFunc(Void);
  ...
};

Void SubFunc(Void) static_throws
{
  // 現在のエラーをチェックする
  if (static_try()) {  
    // エラーが設定されていないとき
    static_throw(MyAllocation());  // エラーを設定する
  }
  ...
}

Void MainFunc(Void)
{
  ...
  SubFunc();
  switch (static_catch()) {
    // エラーに応じた処理
    ...
  }
  ...
}

解説

型名を引数にとり、以下の型宣言を生成します。

typedef Base&    BaseRef;
typedef Base*    BasePtr;
typedef Base**   BaseHandle;

解説

型名を引数にとり、以下の型宣言を生成します。

typedef Base volatile    BaseVolatile;
typedef BaseVolatile&    BaseVolatileRef;
typedef BaseVolatile*    BaseVolatilePtr;
typedef BaseVolatile**   BaseVolatileHandle;

解説

型名を引数にとり、以下の型宣言を生成します。

typedef Base const    BaseConst;
typedef BaseConst&    BaseConstRef;
typedef BaseConst*    BaseConstPtr;
typedef BaseConst**   BaseConstHandle;

解説

型名を引数にとり、以下の型宣言を生成します。

typedef Base volatile const   BaseVolatileConst;
typedef BaseVolatileConst&    BaseVolatileConstRef;
typedef BaseVolatileConst*    BaseVolatileConstPtr;
typedef BaseVolatileConst**   BaseVolatileConstHandle;

解説

型名を引数にとり、以下と等価な型宣言を行います。

SFMTYPEDEFBASE(Base)
SFMTYPEDEFVOLATILE(Base)
SFMTYPEDEFCONST(Base)
SFMTYPEDEFVOLATILECONST(Base)

解説

型名を引数にとり、以下と等価な型宣言を行います。

SFMTYPEDEFPACK(Base)
SFMTYPEDEFPACK(BasePtr)
SFMTYPEDEFPACK(BaseHandle)

解説

型名とその別名を引数にとり、以下と等価な型宣言を行います。

typedef Type   Alias;
SFMTYPEDEFTYPE(Alias);

解説

クラス名を引数にとり、以下と等価な型宣言を行います。

class Class;
SFMTYPEDEFTYPE(Class);

使用例

SFMTYPEDEFCLASS(A)
class A {
  ...
}

マクロ展開の例

SFMTYPEDEFTYPE マクロは以下のようにマクロ展開されます。

SFMTYPEDEFCLASS(MyClass);
class MyClass {
private:
  ...
};

class MyClass;
typedef MyClass&                     MyClassRef;
typedef MyClass*                     MyClassPtr;
typedef MyClass**                    MyClassHandle;
typedef MyClass volatile             MyClassVolatile;
typedef MyClass volatile&            MyClassVolatileRef;
typedef MyClass volatile*            MyClassVolatilePtr;
typedef MyClass volatile**           MyClassVolatileHandle;
typedef MyClass const                MyClassConst;
typedef MyClass const&               MyClassConstRef;
typedef MyClass const*               MyClassConstPtr;
typedef MyClass const**              MyClassConstHandle;
typedef MyClass volatile const       MyClassVolatileConst;
typedef MyClass volatile const&      MyClassVolatileConstRef;
typedef MyClass volatile const*      MyClassVolatileConstPtr;
typedef MyClass volatile const**     MyClassVolatileConstHandle;
typedef (MyClass*)&                  MyClassPtrRef;
typedef (MyClass*)*                  MyClassPtrPtr;
typedef (MyClass*)**                 MyClassPtrHandle;
typedef MyClass* volatile            MyClassPtrVolatile; 
typedef MyClass* volatile&           MyClassPtrVolatileRef;
typedef MyClass* volatile*           MyClassPtrVolatilePtr;
typedef MyClass* volatile**          MyClassPtrVolatileHandle;
typedef MyClass* const               MyClassPtrConst;
typedef MyClass* const&              MyClassPtrConstRef;
typedef MyClass* const*              MyClassPtrConstPtr;
typedef MyClass* const**             MyClassPtrConstHandle;
typedef MyClass* volatile const      MyClassPtrVolatileConst;
typedef MyClass* volatile const&     MyClassPtrVolatileConstRef;
typedef MyClass* volatile const*     MyClassPtrVolatileConstPtr;
typedef MyClass* volatile const**    MyClassPtrVolatileConstHandle;
typedef (MyClass**)&                 MyClassHandleRef;
typedef (MyClass**)*                 MyClassHandlePtr;
typedef (MyClass**)**                MyClassHandleHandle;
typedef MyClass** volatile           MyClassHandleVolatile;
typedef MyClass** volatile&          MyClassHandleVolatileRef;
typedef MyClass** volatile*          MyClassHandleVolatilePtr;
typedef MyClass** volatile**         MyClassHandleVolatileHandle;
typedef MyClass** const              MyClassHandleConst;
typedef MyClass** const&             MyClassHandleConstRef;
typedef MyClass** const*             MyClassHandleConstPtr;
typedef MyClass** const**            MyClassHandleConstHandle;
typedef MyClass** volatile const     MyClassHandleVolatileConst;
typedef MyClass** volatile const&    MyClassHandleVolatileConstRef;
typedef MyClass** volatile const*    MyClassHandleVolatileConstPtr;
typedef MyClass** volatile const**   MyClassHandleVolatileConstHandle;

class MyClass {
private:
  ...
};

解説

クラス名を引数にとり、以下と等価な型宣言を行います。

SFMTYPEDEFCLASS(Class)
SFMTYPEDEFALIAS(SFXBrewPointer<Class>, Class##Smp)
SFMTYPEDEFALIAS(SFXBrewPointer<Class volatile>, Class##VolatileSmp)
SFMTYPEDEFALIAS(SFXBrewPointer<Class const>, Class##ConstSmp)
SFMTYPEDEFALIAS(SFXBrewPointer<Class volatile const>, Class##VolatileConstSmp)

解説

構造体名を引数にとり、以下の型宣言を行います。

struct Struct;
SFMTYPEDEFTYPE(Struct);

解説

共用体名を引数にとり、以下の型宣言を行います。

union Union;
SFMTYPEDEFTYPE(Union);

解説

static メンバのみで構成されるクラスはインスタンスを生成できません。

クラス名を引数にとり、以下のように展開されます。

private:
explicit Class(void);
Class(Class const&);
~Class(void);
const Class& operator=(Class const&);

使用例

SFMTYPEDEFCLASS(A)
class A {
  SFMSEALCONSTRUCT(A)
  ...
}

解説

ラッパー クラスでは、 SFMSEALCONSTRUCT の代わりに SFMSEALWRAPPER を使います。

解説

バッファを管理するクラスなどで、インスタンスのコピーに関する問題を回避します。

クラス名を引数にとり、以下のように展開されます。

private:
Class(Class const&);
Class& operator=(Class const&);

解説

クラスのインスタンスの代入に関する問題を回避します。

クラス名を引数にとり、以下のように展開されます。

private:
Class& operator=(Class const&);

使用例

4 文字リテラルの生成です。

SFCType val = four_char_code('A', 'b', 'c', 'd');
ACharPtr p = reinterpret_cast<ACharPtr>(&val);