プログラマ専用SNS ミクプラ

コード:

class Hoge
{
    public:
        void Begin();
        void End();

        // その他メンバ関数
        void Func1();
        void Func2();
};

void main() {
    Hoge a;
    a.Begin();
    
    a.Func1();
    a.Func2();

    a.End();
}

コード:

template <class T>
class Auto
{
    public:
        Auto() { T.Begin(); }
        ~Auto() { T.End(); }

    operator T&() { return val_; }　

    private:
        T val_;
};

// 例えば次のようにしたいがコンパイルエラー
void main() {
    Auto<Hoge> a;    
    a.Func1(); 　// aをHogeのオブジェクトであるかのように扱いたい
}    

// 実行可
void main() {
    Auto<Hoge> a;    
    static_cast<Hoge>(a).Func1(); 　// 余計ややこしい
} 

コード:

Hoge a;
Foo b;
Bar c;

// Beginを手動で何回も呼び出さないといけない・・・
a.Begin();
b.Begin();
c.Begin();

// do something

// Endも手動で呼び出さないといけない・・・
a.End();
b.End();
c.End();

コード:

class IBeginEnd
{
public:
    virtual ~IBeginEnd() {}
    virtual void Begin() = 0;
    virtual void End() = 0;
};
class Hoge : public IBeginEnd
{
public:
    void Begin();
    void End();
 
    // その他メンバ関数
    void Func1();
    void Func2();
};
class Foo : public IBeginEnd
{
// something
};
class Bar : public IBeginEnd
{
// something
};

int main() // void ではなく int が規格的に正しいです
{
    std::vector<IBeginEnd*> instances;
    Hoge a;
    Foo b;
    Bar c;
    instances.push_back(&a);
    instances.push_back(&b);
    instances.push_back(&c);

    for (int i = 0; i < instances.size(); ++i)
    {
        instances[i]->Begin();
    }

    // do something

    for (int i = 0; i < instances.size(); ++i)
    {
        instances[i]->End();
    }
}

コード:

void Init();  // HogeのBegin()はこの関数の後に呼ばれないといけない。
void Exit(); // HogeのEnd()はこの関数の前に呼ばれないといけない。

class Worker
{
public:
    Worker()  {        
        instances.push_back(&a)；
        instances.push_back(&b);
        instances.push_back(&c);
 
        for (int i = 0; i < instances.size(); ++i)
        {
            instances[i]->Begin();
        }
    }

    ~Worker()  {
        for (int i = 0; i < instances.size(); ++i)
        {
            instances[i]->End();
        }
    }

    void DoSomething();

private:
    Hoge a;
    Foo b;
    Bar c;

    std::vector<IBeginEnd*> instances;
};


void main()
{    
    Worker worker;

    Init();
    ....
    worker.DoSomething();
    ....
    Exit();
}

コード:

// Hoge, Foo, Barのコンストラクタとデストラクタで Begin, End を呼び出すようにしておきます
// したがって、Workerのコンストラクタでは暗黙的に各インスタンスの Begin が呼ばれ、
// Workerのデストラクタでは暗黙的に各インスタンスの End が呼ばれます。

int main() // int ですよ
{
    Init();
    {
        Worker worker; // Begin が呼ばれる
        worker.DoSomething();
    } // End が呼ばれる
    Exit();
}

コード:

class Hoge
{
    public:
        void Begin();
        void End();
 
        // その他メンバ関数
        void Func1();
        void Func2();
};

コード:

class Hoge
{
public:
	void Begin();
	void End();

	// その他メンバ関数
	void Func1();
	void Func2();
};

template<typename T>
class Auto: public T // Tを基底クラスとする
{
public:
	Auto(){ T::Begin(); }
	~Auto(){ T::End(); }
};

int main()
{
	Auto<Hoge> a;    

	// 継承関係にあるので…
	a.Func1();

	Hoge& temp = a;
	temp.Func2();

	return 0;
}