【C＋＋】C＋＋で静的ポリモーフィズムを確認してみる

template<typename T>
void executeUpdate(T& value, float elapsedTime)
{
    // floatを引数に持つupdateメソッドを要求している
	value.update(elapsedTime);
}

struct UpdatableA
{
	void update(float elapsedTime)
	{
		std::cout << "updateA" << std::endl;
	}
};

struct UpdatableB
{
	void update(float elapsedTime)
	{
		std::cout << "updateB" << std::endl;
	}
};

struct CanNotUpdate
{
};

int main()
{
	UpdatableA updatableA;
	UpdatableB updatableB;
	CanNotUpdate canNotUpdate;


	executeUpdate(updatableA, 0.0f);
	executeUpdate(updatableB, 0.0f);
	//executeUpdate(canNotUpdate, 0.0f); //コンパイルエラー！

	return 0;
}

updateA
updateB

#include <concepts>

template<typename T>
concept NeedUpdate = requires(T& value, float elapsedTime)
{
	{value.update(elapsedTime)} -> std::convertible_to<void>;
};

template<NeedUpdate T>
void executeUpdate(T& value, float elapsedTime)
{
	value.update(elapsedTime);
}

#include <concepts>
#include <iostream>
#include <vector>
#include <chrono>
#include "proxy.h"

// 規約1
struct Draw : pro::dispatch<void()> {
	template <class T>
	void operator()(T& self) { self.Draw(); }
};
// 規約2
struct Area : pro::dispatch<double()> {
	template <class T>
	double operator()(const T& self) { return self.Area(); }
};

// クラスタイプ
struct DrawableFacade : pro::facade<Draw, Area> {
	static constexpr std::size_t maximum_size = sizeof(void*);
	static constexpr auto minimum_copyability = pro::constraint_level::nothrow;
};

// 静的ポリモーフィズムクラス
class StaticDrawA
{
public:
	StaticDrawA(int value) 
		: value_(value)
	{
	}

	void Draw()
	{
		++value_;
	}

	double Area() const
	{
		return static_cast<double>(value_);
	}

private:
	int value_;
};

// 静的ポリモーフィズムクラス
class StaticDrawB
{
public:
	StaticDrawB(double value)
		: value_(value)
	{
	}

	void Draw()
	{
		++value_;
	}

	double Area() const
	{
		return value_;
	}

private:
	double value_;
};

// 動的ポリモーフィズム元クラス
class IDynamicDraw
{
public:
	virtual ~IDynamicDraw() {};
	virtual void Draw() = 0;
	virtual double Area() const = 0;
};
// 動的ポリモーフィズム派生クラス
class DynamicDrawA : public IDynamicDraw
{
public:
	DynamicDrawA(int value)
		: value_(value)
	{
	}

	void Draw() override
	{
		++value_;
	}

	double Area() const override
	{
		return static_cast<double>(value_);
	}

private:
	int value_;
};
// 動的ポリモーフィズム派生クラス
class DynamicDrawB : public IDynamicDraw
{
public:
	DynamicDrawB(double value)
		: value_(value)
	{
	}

	void Draw() override
	{
		++value_;
	}

	double Area() const override
	{
		return value_;
	}

private:
	double value_;
};



int main()
{
	
	std::vector< pro::proxy<DrawableFacade>> staticDrawables;
	std::vector< IDynamicDraw* > dynamicDrawables;

	constexpr unsigned InstanceNum = 1000000;
    // 交互にA,Bを生成する
	for (int index = 0; index < InstanceNum; ++index)
	{
		if(index % 2 == 0)
		{
			{
				StaticDrawA* instance = new StaticDrawA(index);
				staticDrawables.push_back(instance);
			}

			{
				DynamicDrawA* instance = new DynamicDrawA(index);
				dynamicDrawables.push_back(instance);
			}
		}
		else
		{
			{
				StaticDrawB* instance = new StaticDrawB(index);
				staticDrawables.push_back(instance);
			}

			{
				DynamicDrawB* instance = new DynamicDrawB(index);
				dynamicDrawables.push_back(instance);
			}
		}
	}

	std::chrono::system_clock::time_point start, end;	// 処理時間計測用変数
	double staticElapsed = 0;
	double dynamicElapsed = 0;
	{
		start = std::chrono::system_clock::now();	// 計測開始

		for (int index = 0; index < staticDrawables.size(); ++index)
		{
			auto& staticDraw = staticDrawables.at(index);
			staticDraw.invoke<Draw>();
			staticDraw.invoke<Area>();
		}

		end = std::chrono::system_clock::now();		// 計測終了
		double elapsed = (double)std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() / 1000.0;
		staticElapsed += elapsed;

		std::cout << "static : " << staticElapsed << "[ms]\n";
	}

	{
		start = std::chrono::system_clock::now();	// 計測開始

		for (int index = 0; index < dynamicDrawables.size(); ++index)
		{
			auto* dynamicDraw = dynamicDrawables.at(index);
			dynamicDraw->Draw();
			dynamicDraw->Area();
		}

		end = std::chrono::system_clock::now();		// 計測終了
		double elapsed = (double)std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() / 1000.0;
		dynamicElapsed += elapsed;

		std::cout << "dynamic : " << dynamicElapsed << "[ms]\n";
	}

	
	for (int index = 0; index < staticDrawables.size(); ++index)
	{
		auto& staticDraw = staticDrawables.at(index);
		staticDraw.reset();
	}
	staticDrawables.clear();

	for (int index = 0; index < dynamicDrawables.size(); ++index)
	{
		auto* dynamicDraw = dynamicDrawables.at(index);
		delete dynamicDraw;
	}
	dynamicDrawables.clear();
}