Teeworlds Friends

C++ Quelltext

#include <chrono>
#include <iostream>
#include <thread>
#include <future>
#include <type_traits>
 
template<typename Func, typename... Args, typename LambdaReturn = typename mlk::lambda_info<Func>::return_type>
auto doSmthInTheFuture(Func&& f, Args&&... args) {
	std::packaged_task<LambdaReturn(Args...)> task{f};
	std::future<LambdaReturn> future{task.get_future()};
	std::thread(std::move(task), std::forward<Args>(args)...).detach();
	return future;
}
 
template<int i, int max>
typename std::enable_if<(i >= max), void>::type createTask() {
	/* Do nothing; end call loop */
}
 
template<int i, int max>
typename std::enable_if<(i < max), void>::type createTask() {
	doSmthInTheFuture([](int sink) {
		std::this_thread::sleep_for(std::chrono::milliseconds(500));
		std::cout << "This is task number: " << sink << std::endl;
	}, i).wait();
 
	createTask<i + 1, max>();
}
 
template<int numTasks>
void taskFactory() {
	createTask<0, numTasks>();
}
 
int main() {
	taskFactory<5>();
 
	// create a task in the future
	auto future = doSmthInTheFuture([](int i) {
		std::this_thread::sleep_for(std::chrono::milliseconds(1000));
		std::cout << "I come from the future. Meaning of life: " << i << std::endl;
		return i * 2;
	}, 42 /* arguments for the task */);
 
	std::cout << "Waiting for the future..." << std::endl;
	future.wait(); // wait for the future to finish its task
	std::cout << "The future returned: " << future.get() << std::endl; // get the future return
 
 
	// Output:
	//	This is task number: 0
	//	This is task number: 1
	//	This is task number: 2
	//	This is task number: 3
	//	This is task number: 4
	//	Waiting for the future...
	//	I come from the future. Meaning of life: 42
	//	The future returned: 84
}

C++ Quelltext

class SomeType {
public:
	void handle() {
 
	}
};
 
template<typename AnyType>
void doStuffT(AnyType& obj) {
	obj.handle();
}
 
int main() {
	SomeType obj;
	doStuffT(obj);
}

C++ Quelltext

class Base {
public:
	virtual void handle() = 0;
};
 
class Derived final : public Base {
public:
	virtual void handle() override {
 
	}
};
 
void doStuff(Base* b) {
	b->handle();
}
 
int main() {
	Derived d;
	doStuff(&d);
}

C++ Quelltext

class Something
{
	void handle{ }
}
 
void doStuff(T) (T obj)
{
	obj.handle(); // per templateConstraint könnte man das ganze noch compile-time sicher machen, wäre dann so:  void doStuff(T) (T obj) if ( T.isHandler)
}
 
void main()
{
  	auto obj = new Something();
  	obj.doStuff();
}