第十三號艦隊

const int iBufSize = 32 * 1024;
BYTE* pBuffer = new BYTE[iBufSize];

int ReadFunc(void* ptr, uint8_t* buf, int buf_size)
{
	// Left to implement
}
int64_t SeekFunc(void* ptr, int64_t pos, int whence)
{
	// Left to implement
}
AVIOContext* pIOCtx = avio_alloc_context(pBuffer, iBufSize,  // internal Buffer and its size
                                         0,                  // bWriteable (1=true,0=false) 
                                         pContext,          // user data ; will be passed to our callback functions
                                         ReadFunc, 
                                         0,                  // Write callback function (not used in this example) 
                                         SeekFunc);

AVFormatContext* pCtx = avformat_alloc_context();
pCtx->pb = pIOCtx;
pCtx->iformat = av_find_input_format("h264");
pCtx->flags = AVFMT_FLAG_CUSTOM_IO;

if (avformat_open_input(&pCtx, "", 0, 0)) != 0)
    // Error Handling

avformat_close_input(pCtx);  // AVFormatContext is released by avformat_close_input
av_free(pIOCtx);             // AVIOContext is released by av_free
delete[] pBuffer;

module Math;
export int add(int x, int y)
{
	return x + y;
}

#include <stdio.h>
import Math;
int main()
{
	printf("2 + 3 = %d\n", add(2, 3));
	return 0;
}

module Math;
export int sub(int x, int y)
{
	return x - y;
}

int main()
{
	printf("2 + 3 = %d\n", add(2, 3));
  printf("3 - 2 = %d\n", sub(3, 2));
	return 0;
}

#include <iostream>
#include <experimental/generator>
using namespace std::experimental;
using namespace std;

generator<int> fib()
{
	int a = 0;
	int b = 1;
	for (;;) {
		yield a;
		auto next = a + b;
		a = b;
		b = next;
	}
}

int main(int argc, char* argv[])
{
	for (auto v : fib()) {
		if (v > 50)
			break;
		cout << v << endl;
	}
}

#include <future>
#include <iostream>
using namespace std;
using namespace std::chrono;

// this could be some long running computation or I/O
future<int> calculate_the_answer()
{
	return async([] {
		this_thread::sleep_for(1s); return 42;
	});
}

// Here is a resumable function
future<void> coro() {
	cout << this_thread::get_id() << " Started waiting... \n";
	auto result = await calculate_the_answer();
	cout << this_thread::get_id() << " : woke up, get " << result << endl;
}

int main(int argc, char* argv[])
{
	coro().get();
	cout << this_thread::get_id() << ": back in main\n";
}

void noncoro() {
	cout << this_thread::get_id() << " Started waiting... \n";
	auto result = calculate_the_answer().get();
	cout << this_thread::get_id() << " : woke up, get " << result << endl;
}

int main(int argc, char* argv[])
{
	noncoro();
	cout << this_thread::get_id() << ": back in main\n";
}

#include <windows.h>
#include <future>
#include <iostream>
#include <experimental/resumable>
using namespace std;
using namespace std::chrono;
using namespace std::experimental;

auto operator await(system_clock::duration duration) {
	class awaiter {
		static void CALLBACK TimerCallback(PTP_CALLBACK_INSTANCE, void *Context, PTP_TIMER) {
			coroutine_handle<>::from_address(Context)();
		}
		PTP_TIMER timer = nullptr;
		system_clock::duration duration;
	public:
		explicit awaiter(system_clock::duration d) : duration(d) {}
		bool await_ready() const { return duration.count() <= 0; }
		bool await_suspend(coroutine_handle<> resume_cb) {
			int64_t relative_count = -duration.count();
			timer = CreateThreadpoolTimer(TimerCallback, resume_cb.to_address(), nullptr);
			SetThreadpoolTimer(timer, (PFILETIME)&relative_count, 0, 0);
			return timer != 0;
		}
		void await_resume() {}
		~awaiter() { if (timer) CloseThreadpoolTimer(timer); }
	};
	return awaiter{ duration };
}

future<void> test() {
	cout << this_thread::get_id() << ": sleeping...\n";
	await 1s;
	cout << this_thread::get_id() << ": woke up\n";
}

int main() {
	test().get();
	cout << this_thread::get_id() << ": back in main\n";
}

#include <stdio.h>
#include <string>
namespace {
        #define ANSI_COLOR_RED     "\x1b[31m"
        #define ANSI_COLOR_GREEN   "\x1b[32m"
        #define ANSI_COLOR_YELLOW  "\x1b[33m"
        #define ANSI_COLOR_BLUE    "\x1b[34m"
        #define ANSI_COLOR_MAGENTA "\x1b[35m"
        #define ANSI_COLOR_CYAN    "\x1b[36m"
        #define ANSI_COLOR_RESET   "\x1b[0m"


        #define DEFINE_COLOR_STRING(color) \
                std::string operator"" _##color (const char* str) \
                { \
                        std::string tmp(ANSI_COLOR_##color); \
                        tmp += str; \
                        tmp += ANSI_COLOR_RESET; \
                        return tmp;\
                }
        DEFINE_COLOR_STRING(RED);
        DEFINE_COLOR_STRING(GREEN);
        DEFINE_COLOR_STRING(YELLOW);
        DEFINE_COLOR_STRING(BLUE);
        DEFINE_COLOR_STRING(MAGENTA);
        DEFINE_COLOR_STRING(CYAN);
};
std::cout << 123_RED << 456_YELLOW << 789_BLUE << std::endl;

template <typename T, std::size_t N>
class ArrayResult {
        constexpr static std::size_t size_ = N;
        T data_[N] {};
public:
        constexpr std::size_t size() const { return N; }
        constexpr T& operator[](std::size_t n) { return data_[n]; }
        constexpr const T& operator[](std::size_t n) const { return data_[n]; }
        using iterator = T*;
        using const_iterator = const T*;
        constexpr iterator begin() { return &data_[0]; }
        constexpr const_iterator begin() const { return &data_[0]; }
        constexpr iterator end() { return &data_[N]; }
        constexpr const_iterator end() const { return &data_[N]; }
};