第十三號艦隊

$ apt-get install g++ g++-4.8 g++-4.8-multilib gcc-4.8-doc libstdc++6-4.8-dbg libstdc++-4.8-doc
$ cd boost_1_55_0
$ ./bootstrap.sh ## Generate bjam

$ ./bjam --build-dir=./tmp --stagedir=./build

for (auto& kv : myMap) { 
	std::cout << kv.first << " has value " << kv.second << std::endl; 
}

#include <boost/range/adaptor/reversed.hpp>

for (auto i : boost::adaptors::reverse(x))
        std::cout << i << '\n';

template<class Fwd>
struct Reverser_generic {
	Fwd &fwd;
	Reverser_generic(Fwd& fwd_) : fwd(fwd_) {}
	typedef std::reverse_iterator<typename Fwd::iterator> reverse_iterator;
	reverse_iterator begin() { return reverse_iterator(std::end(fwd)); }
	reverse_iterator end() { return reverse_iterator(std::begin(fwd)); }
};

template<class Fwd >
struct Reverser_special{
	Fwd &fwd;
	Reverser_special(Fwd& fwd_) : fwd(fwd_) {}
	auto begin() -> decltype(fwd.rbegin()){ return fwd.rbegin(); }
	auto end() ->decltype(fwd.rbegin())   { return fwd.rend(); }
};

template<class Fwd>
auto reverse_impl(Fwd& fwd, long) -> decltype(Reverser_generic<Fwd>(fwd)){
	return Reverser_generic<Fwd>(fwd);
}

template<class Fwd>
auto reverse_impl(Fwd& fwd, int)
-> decltype(fwd.rbegin(), Reverser_special<Fwd>(fwd))
{
	return Reverser_special<Fwd>(fwd);
}

template<class Fwd>
auto reverse(Fwd&& fwd) -> decltype(reverse_impl(fwd, int(0))) {
	static_assert(!(is_rvalue_reference<Fwd&&>::value),
		"Cannot pass rvalue_reference to dj::reverse()");
	return reverse_impl(fwd, int(0));
}

$ curl http://beyondgrep.com/ack-2.12-single-file > ack
$ sudo mv ack /usr/local/bin
$ sudo chmod 755 /usr/local/bin/ack

$ ack -w eat 

$ ack -Q '$path/$'

$ ack about --ignore-dir=downloads 

$ ack --make -l CFLAG 

$ tail -f /var/log/syslog | ack --passthru 192.168.1.10 

#include <pthread.h>
static int count = 1;
void *incr_count(void *p) {
        count++;
        return 0;
}
static pthread_mutex_t m1 = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t m2 = PTHREAD_MUTEX_INITIALIZER;
void *lock_m1_then_m2(void *p) {
        pthread_mutex_lock(&m1);
        pthread_mutex_lock(&m2);
        pthread_mutex_unlock(&m2);
        pthread_mutex_unlock(&m1);
        return 0;
}
void *lock_m2_then_m1(void *p) {
        pthread_mutex_lock(&m2);
        pthread_mutex_lock(&m1);
        pthread_mutex_unlock(&m1);
        pthread_mutex_unlock(&m2);
        return 0;
}
int main() {
        pthread_t t1, t2, t3, t4;
        pthread_create(&t1, NULL, incr_count, NULL);
        pthread_create(&t2, NULL, incr_count, NULL);
        pthread_create(&t3, NULL, lock_m1_then_m2, NULL);
        pthread_create(&t4, NULL, lock_m2_then_m1, NULL);
        pthread_join(t4, NULL);
        pthread_join(t3, NULL);
        pthread_join(t2, NULL);
        pthread_join(t1, NULL);
        return count;
}                       

$ gcc demo.c -o demo -lpthread
$ valgrind --tool=drd ./demo

#include <pthread.h>
int Global;
void* Thread1(void* x) {
        Global++;
        return NULL;
}

void* Thread2(void* x) {
        Global--;
        return NULL;
}

int main() {
        pthread_t t[2];
        pthread_create(&t[0], NULL, Thread1, NULL);
        pthread_create(&t[1], NULL, Thread2, NULL);
        pthread_join(t[0], NULL);
        pthread_join(t[1], NULL);
        return 0;
}

$ clang simple_race.c -fsanitize=thread -g
$ ./a.out

$ git remote -f add <name of sub_repo> <address of sub_repo>
$ git subtree add --prefix=<name of sub_directory> <name of sub_repo> <branch> --squash

$ git remote add -f ai https://github.com/aoxu/ai.git  
$ git subtree add --prefix=ai ai master --squash  

$ git fetch <name of sub_repo> <branch>
$ git subtree pull --prefix=<name of sub_directory> <name of sub_repo> <branch> --squash

$ git fetch ai master  
$ git subtree pull --prefix=ai ai --squash  

$ git subtree push --prefix=<name of sub_directory> <name of sub_repo> <branch>

$ git subtree push --prefix=ai ai master  

$ git subtree split -P <sub_directory> -b <branch>

$ mkdir <new-repo> && cd <new-repo>
$ git init
$git pull <path of original repo> <name-of-new-branch>

$ git remote add origin <git@github.com:my-user/new-repo.git>
$ git push origin -u master

struct Obj {
  string name_;
	Obj(const string& name) :name(name_) {}
	~Obj() {}
};
class ObjFactory {
	map<string, shared_ptr<Obj>> lookup_;
public:
	shared_ptr<Obj> get(const string &name)
	{
		auto it = lookup_.find(name);
		if (it != lookup_.end())
			return it->second;
		lookup_[name] = shared_ptr<Obj>(new Obj(name));
		return lookup_[name];
	}
};

class ObjFactory {
	map<string, weak_ptr<Obj>> lookup_;
public:
	shared_ptr<Obj> get(const string &name)
	{
		auto it = lookup_.find(name);
		if (it != lookup_.end())
		{
			shared_ptr<Obj> obj((it->second).lock());
			return obj;
		}
		shared_ptr<Obj> instance(new Obj(name));
		weak_ptr<Obj> obj(instance);
		lookup_[name] = obj;
		return instance;
	}
};

for (int i = 0; i < 3; i++)
{
	shared_ptr<Obj> s = pFactory->get("HM");
	if (s) {
		cout << "create new obj" << endl;
	}
	else {
		cout << "cannot create new obj" << endl;
	}
}

class ObjFactory {
	map<string, weak_ptr<Obj>> lookup_;
	void deleteObj(Obj *pObj)
	{
		lookup_.erase(pObj->name_);
		delete pObj;
	}
public:
	shared_ptr<Obj> get(const string &name)
	{
		auto it = lookup_.find(name);
		if (it != lookup_.end())
		{
			shared_ptr<Obj> obj((it->second).lock());
			return obj;
		}
		shared_ptr<Obj> instance(new Obj(name), bind(&ObjFactory::deleteObj, this, placeholders::_1));
		weak_ptr<Obj> obj(instance);
		lookup_[name] = obj;
		return instance;
	}
};

{
	shared_ptr<Obj> obj1 = pFactory->get("Obj1");
	delete pFactory;
}

class ObjFactory : public enable_shared_from_this<ObjFactory> {
	map<string, weak_ptr<Obj>> lookup_;
	void deleteObj(Obj *pObj)
	{
		lookup_.erase(pObj->name_);
		delete pObj;
	}
public:
	shared_ptr<Obj> get(const string &name)
	{
		auto it = lookup_.find(name);
		if (it != lookup_.end())
		{
			shared_ptr<Obj> obj((it->second).lock());
			return obj;
		}
		shared_ptr<Obj> instance(new Obj(name), bind(&ObjFactory::deleteObj, shared_from_this(), placeholders::_1));
		weak_ptr<Obj> obj(instance);
		lookup_[name] = obj;
		return instance;
	}
};
	{
		shared_ptr<ObjFactory> pFactory(new ObjFactory);
		shared_ptr<Obj> obj1 = pFactory->get("Obj1");
	}

class ObjFactory : public enable_shared_from_this<ObjFactory> {
	map<string, weak_ptr<Obj>> lookup_;
	static void deleteObj(const weak_ptr<ObjFactory> &pWeakFactory, Obj *pObj)
	{
		shared_ptr<ObjFactory> pFactory(pWeakFactory.lock());
		if (pFactory) {
			pFactory->lookup_.erase(pObj->name_);
		}
		delete pObj;
	}
public:
	shared_ptr<Obj> get(const string &name)
	{
		auto it = lookup_.find(name);
		if (it != lookup_.end())
		{
			shared_ptr<Obj> obj((it->second).lock());
			return obj;
		}
		shared_ptr<Obj> instance(new Obj(name), bind(&ObjFactory::deleteObj, 
			weak_ptr<ObjFactory>(shared_from_this()), placeholders::_1));
		weak_ptr<Obj> obj(instance);
		lookup_[name] = obj;
		return instance;
	}
};

int func()
{
	static int i, state = 0;
	switch (state)
	{
	case 0: goto LABEL0;
	case 1: goto LABEL1;
	}
LABEL0:
	for (i = 0; i < 10; i++) {
		state = 1;
		return i;
LABEL1:;
	}
	return -1;
}

int func()
{
	static int i, state = 0;
	switch (state)
	{
	case 0:
		for (i = 0; i < 10; i++) {
			state = 1;
			return i;
	case 1:;
		}
	}
	return -1;
}