第十三號艦隊

struct Counter {
	int value = 0;
	void inc() { value++;  }
};
Counter c;
c.inc();

struct Counter {
	int value = 0;
};
std::function<void(void)> make_inc()
{
	std::shared_ptr<Counter> obj = make_shared<Counter>();
	return [obj]() {
		obj->value++;
	};
}
std::function<void(void)> inc = make_inc();
inc();

typedef std::function<void(void)> Func;
std::tuple<Func, Func> make_counter()
{
	std::shared_ptr<Counter> obj = make_shared<Counter>();
	Func inc = [obj]() { obj->value++; };
	Func dec = [obj]() { obj->value--; };
	return make_tuple(inc, dec);
}
auto funcs = make_counter();
Func inc = std::get<0>(funcs);
Func dec = std::get<1>(funcs);
inc();

#include <iostream>
#include <boost/asio/yield.hpp>

int foo(boost::asio::coroutine& ct)
{
	std::cout << "before reenter" << std::endl;

	reenter(ct)
	{
		std::cout << "before yield1" << std::endl;
		yield std::cout << "yield1" << std::endl;
		std::cout << "before yield2" << std::endl;
		yield return 1;
	}

	std::cout << "after reenter" << std::endl;
	return 2;
}

int main(int argc, char* argv[])
{
	boost::asio::coroutine ct;
	while (!ct.is_complete())
	{
		int ret = foo(ct);
		std::cout << "return:" << ret << std::endl;
	}
	return 0;
}

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