第十三號艦隊

#include <iostream>
int main()
{
        std::cout << "Hello" << std::endl;
        return 0;
}

pthread_mutex_t mutex;
pthread_cond_t cond;
std::queue<int> q;
int Get()
{
        pthread_mutex_lock(&mutex);
        if (q.empty())
                pthread_cond_wait(&cond, &mutex);
        int item = q.front();
        pthread_mutex_unlock(&mutex);
        return item;
}
void Add(int item)
{
        pthread_mutex_lock(&mutex);
        q.push(item);
        pthread_mutex_unlock(&mutex);
        pthread_cond_signal(&cond);
}

if (q.empty())
        pthread_cond_wait(&cond, &mutex);

struct D {
	B1 *p1;
	B2 *p2;
	D() {
		try {
			p1 = new B1;
			p2 = new B2;
		}
		catch (...) {
			delete p2;
			delete p1;
		}
	}
	~D()
	{
		delete p2;
		delete p1;
	}
};

struct D {
	unique_ptr<B1> p1;
	unique_ptr<B2> p2;
	D() : p1(new B1), p2(new B2) {}
	~D() = default;
};

#include <type_traits>
#include <typeinfo>
#ifndef _MSC_VER
#   include <cxxabi.h>
#endif
#include <memory>
#include <string>
#include <cstdlib>

template <class T>
std::string
type_name()
{
    typedef typename std::remove_reference<T>::type TR;
    std::unique_ptr<char, void(*)(void*)> own
           (
#ifndef _MSC_VER
                abi::__cxa_demangle(typeid(TR).name(), nullptr,
                                           nullptr, nullptr),
#else
                nullptr,
#endif
                std::free
           );
    std::string r = own != nullptr ? own.get() : typeid(TR).name();
    if (std::is_const<TR>::value)
        r += " const";
    if (std::is_volatile<TR>::value)
        r += " volatile";
    if (std::is_lvalue_reference<T>::value)
        r += "&";
    else if (std::is_rvalue_reference<T>::value)
        r += "&&";
    return r;
}

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";
}