帐前卒专栏

ps -e | grep postgre
// find id of the process
kill -9 $processid

gdb postgresqlHomeDIR/bin/postgres -quiet
// enter gdb then use
set args -D DATADIR
run

// find postgres pid
pid = `ps auxww | \
    grep postgres: | \
    grep -v -e 'grep postgres:' -e 'postgres: stats' -e 'postgres: writer' -e 'postgres: archiver' -e 'postgres: logger' -e 'postgres: autovacuum' | \
    tee /dev/tty | \
    awk '{print $2}'`
gdb pid

./psql test

(gdb) file XXX.so

// flyweight.cpp : Defines the entry point for the console application.
// author: chillyc
// email: chillycreator @t gmail.com

#include<iostream>
#include<map>
namespace pattern{

	/// this is flyweight pattern 
	/// In text processing, there will be thousands of hundreds of characters.
	/// If we construct too many this class instance, and 
	/// imaging this class will have many member variables, will the system be efficient? 
	/// So we just record the characters state, and not care about other part of character.
	/// we shall save a lot of main memories, shall we?
	/// If there are many characters, but  they are only in differnt place, we can reuse characters.
	/// So there are Fly_Manager to record the shared objects or states.
	/// All objects should be derived from Metadata class.
	/// Graphdata is no-shared metadata. And Character is shared metadata.
	/// In main function, you will see the difference between two of them.

#ifndef STATE_H
#define STATE_H
	class State{
	private:
		int font_num;
		int style;

	public:
		void Set_Font_Num(int num){font_num = num;}
		void Set_Style(int style){this->style = style;}
		int Get_Font_Num(){return font_num;}
		int Get_Style(){return style;}
		State(){}
		State(int num,int style){
			font_num = num; 
			this->style = style;
		}
		State(const State& state){
			this->font_num = state.font_num; 
			this->style = state.style;
		}
		State* operator = (const State& state){
			this->font_num = state.font_num; 
			this->style = state.style;
			return this;
		}
	};

#endif

#ifndef METADATA_H
#define METADATA_H
	class Metadata{
	public:
		virtual void show()=0;
	};
#endif

#ifndef character_H
#define character_H
	// share the basic information
	// here you should image character has a huge infomation, 
	// and state is only a small part of this class
	class character: public Metadata{
	private:
		State state;
	public:
		// set state to default state
		character():Metadata(),state(1,1){}
		~character(){}
		void Set_State(State& state);
		virtual void show();

	};
	void character::Set_State(pattern::State& state){
		this->state = state;
	}

	void character::show(){
		std::cout << "write a character font is "<< state.Get_Font_Num()<< " style is "
			<< state.Get_Style()<<std::endl; 
	}
#endif

#ifndef GRAPHDATA_H
#define GRAPHDATA_H
	// not share 
	class Graphdata: public Metadata{
	private:
		State state;
	public:
		Graphdata(State & state):Metadata(),state(state){}
		// font num is not used
		Graphdata(int style):Metadata(),state(-1,style){}
		~Graphdata(){};
		virtual void show();
	};

#endif
	void Graphdata::show(){
		// only use its own state
		std::cout<< "print a graph! style is "<<state.Get_Style()<<std::endl;
	}

#ifndef FLYMANAGER_H
#define FLYMANAGER_H
	class Fly_Manager{
	public:
		// suggest you should make it as private or protected
		std::map<int,State> characters;
		Fly_Manager(){}
		void Set_I(int i, State& state);
		State& Get_I(int i);
		~Fly_Manager(){}

	};
#endif
	void Fly_Manager::Set_I(int i, State& state){
		characters[i] = state;
	}
	State& Fly_Manager::Get_I(int i){
		return characters[i];
	}

}
int main()
{
	pattern::Fly_Manager fm;
	pattern::character c;
	pattern::State s1(1,2);
	pattern::State s2(2,3);
	pattern::State s3(3,4);
	fm.Set_I(0,s1);
	fm.Set_I(1,s2);
	fm.Set_I(2,s3);
	pattern::Graphdata gd1(2);
	pattern::Graphdata gd2(9);
	for(int i = 0; i < 3; i++){
		c.Set_State(fm.Get_I(i));
		c.show();
	}
	gd1.show();
	gd2.show();
	return 0;
}

// Adapter.cpp : Defines the entry point for the console application.
// author: chillyc
// email: chillycreator @t gmail.com

#include<iostream>
#include<string>
using namespace std;

/// adapter pattern is used for combining two or more classes,
/// which have the same behaviors but different interfaces.
/// some classes is common used in future, and the other which are special will never used.
/// common used classes should be public, and the other is private.
/// some classes which inherit adapter class will never use the special ones. 
/// adapter pattern is divided into two patterns.
/// one is belong to class structure, and the other is belong to object structure.

#ifndef INTERFACEA_H
#define INTERFACEA_H
/// Interface A is a common interface!
class Interface_A{
public :
	virtual void connect_com();
};
#endif
void Interface_A::connect_com(){
	cout<<"connect a"<<endl;
}

#ifndef INTERFACEB_H
#define INTERFACEB_H
/// Interface B is not a common interface, 
/// it will be used in some special area!
class Interface_B{
public :
	virtual void connect_B();
};
#endif
void Interface_B::connect_B(){
	cout<< "connect b"<<endl;
}

#ifndef ADAPTERCLASS_H
#define ADAPTERCLASS_H
/// this class uses private inheritance to construct adapter.
/// and it is a kind of class structure.
class Adapter_Class: public Interface_A, private Interface_B{
public:
	Adapter_Class();
	~Adapter_Class();
	virtual void connect();
};

/// this class uses private member variable to construct adapter.
/// and it uses object relationship.
class Adapter_Object: public Interface_A{
private:
	Interface_B * b;
public:
	Adapter_Object();
	~Adapter_Object();

	virtual void connect();
};
#endif

Adapter_Class::Adapter_Class(){
	cout<< "Adapter_Class construct"<<endl;

}
Adapter_Class::~Adapter_Class(){}
void Adapter_Class::connect(){
	Interface_A::connect_com();
	Interface_B::connect_B();
}

Adapter_Object::Adapter_Object(){
	cout<<"Adapter_Object construct"<<endl;
	b = new Interface_B();

}
Adapter_Object::~Adapter_Object(){
	delete b;
}
void Adapter_Object::connect(){
	Interface_A::connect_com();
	b->connect_B();
}

int main()
{
	Adapter_Class ac;
	ac.connect();
	Adapter_Object ao;
	ao.connect();
	return 0;
}

// composite.cpp : Defines the entry point for the console application.
//

#include<iostream>
#include<string>
#include<vector>

namespace pattern{
	/// this pattern is composite pattern.
	/// in this pattern, it like a tree to call the leaves function.
	/// so there is an entry of high level (Graph), and each class has a function called "Draw" 
	/// the composite class is "Picture".
	/// and the leaves are "Line" and "Point".
	/// This pattern is combine many objects together which have same functions 
	/// and have level structures .
	/// And the composite class is like a manager.
	/// It has the same function also. 
	/// Benefits of this pattern is : outer class will never know the composite relationship;
	/// outer class will deal the composite class only, not all of innerclass. and composite class
	/// and inner class have same functions or level structures.
	/// Do you think the composite class like a facade in facade pattern?
#ifndef GRAPH_H
#define GRAPH_H

	class Graph{
	protected:
		std::string name;

	public:
		Graph(std::string name):name(name){std::cout<<"graph "<<name<<" construct"<<std::endl;}

		virtual void Draw()=0;
		virtual ~Graph(){std::cout<< "graph "<<name<< " destroy"<<std::endl;};
	};
#endif

#ifndef PICTURE_H
#define PICTURE_H
	class Picture:public Graph{
	private:
		std::vector<Graph*> list;
	public:
		Picture(std::string name):Graph(name){std::cout<<"Picture "<<name<<" construct!"<<std::endl;}
		virtual void Add(Graph*);
		virtual void Remove(Graph*);
		virtual void Draw();
		~Picture();
	};

#endif
	Picture::~Picture(){
		list.clear();
		std::cout<<"Picture destroy!"<<std::endl;
	}
	void Picture::Add(pattern::Graph * g){
		list.push_back(g);
	}
	void Picture::Remove(pattern::Graph *g){
		std::vector<Graph*>::iterator i=list.begin();
		while(i!=list.end()){
			if(g==*i){
				list.erase(i);
				break;
			}
			i++;
		}
	}
	void Picture::Draw(){
		std::vector<Graph*>::iterator i=list.begin();
		while(i != list.end()){
			(*i)->Draw();
			i++;
		}
	}

#ifndef SHAPE_H
#define SHAPE_H
	/// Shape class is parent class of "Line" and "Point"
	class Shape:public Graph{
	public:
		virtual void Draw()=0;
		Shape(std::string name):Graph(name){std::cout<<"Shape construct!"<<std::endl;}
		virtual ~Shape(){std::cout<<"Shape destroy!"<<std::endl;}

	};

#endif

#ifndef POINT_H
#define POINT_H
	class Point:public Shape{
	public:
		Point(std::string name):Shape(name){std::cout<<"Point construct!"<<std::endl;}
		~Point(){std::cout<<"Point destroy!"<<std::endl;}
		virtual void Draw();

	};
#endif
	void Point::Draw(){
		std::cout<<"Draw a point!"<<std::endl;
	}

#ifndef LINE_H
#define LINE_H
	class Line: public Shape{
	public:
		Line(std::string name):Shape(name){std::cout<<"Line construct!"<<std::endl;}
		~Line(){std::cout<<"Line destroy!"<<std::endl;}
		virtual void Draw();
	};

#endif
	void Line::Draw(){
		std::cout<<"Draw a line!"<<std::endl;
	}
}

int main()
{
	pattern::Line l ("line");
	pattern::Point p1 ("point 1");
	pattern::Point p2("point 2");
	pattern::Picture pic("Picture");
	pic.Add(&l);
	pic.Add(&p1);
	pic.Add(&p2);

	pic.Draw();
	// if you want destroy some shape, remove them first.
	pic.Remove(&p1);
	p1.~Point();
	pic.Draw();
	return 0;
}

// Facade.cpp : Defines the entry point for the console application.
// author: chillyc
// email: chillycreator @t gmail.com

#include<iostream>

namespace pattern{
	/// this pattern is facade pattern
	/// facade pattern is for hiding relationship and behavior of inner classes .
	/// client or outer class should only connect with facade class.
	/// But it will not forbid accessing inner classes.
#ifndef INNERA_H
#define INNERA_H
	class Inner_A{
	public:
		void Do(){std::cout<<"A"<<std::endl;}
	};
#endif
#ifndef INNERB_H
#define INNERB_H
	class Inner_B{
	public:
		void Do(){std::cout<<"B"<<std::endl;}
	};
#endif

#ifndef FACADE_H
#define FACADE_H
	class Facade{
	private:
		Inner_A* a;
		Inner_B* b;
	public:
		Facade(){
			a = new Inner_A();
			b = new Inner_B();

		}
		void Do(){
			a->Do();
			b->Do();
		}
		~Facade(){
			delete a;
			delete b;
		}
	};
#endif
}

int main()
{
	pattern::Facade f;
	f.Do();
	return 0;
}

// bridge.cpp : Defines the entry point for the console application.
//
/// author : chillyc
/// email : chillycreator @t gmail.com
/// uml:
///                   _ 
///                  / \
///                 /_ _\

#include<iostream>

namespace pattern{

/// why use bridge pattern?
/// If the original parent class is not suitable for being inherited by subclass, 
/// it will be refactor. And If there are some concepts are common, 
/// it will be abstracted as implement interface or abstract class.
/// for example: in KFC, there will be some softdrink to be sold, 
/// like coca cola, coff, and so on. And if you wish, you will add some additions like sugar,
/// or ice into softdrinks. If we design the classes as sugar-cocacola, sugar-coff, ice-cocacola,
/// and ice-coff. There will be four subclasses here. And in the future, is there add another
/// additions? If yes, the system will add another two classes! But if use bridge pattern,
/// it will add only one class called "another additions" inherited from addition class. 
/// This is benefits of this pattern.

#ifndef ADDITION_H
#define ADDITION_H
	/// this is the implement class in Bridge pattern.
	/// if you want add another additions, 
	/// inherit this class and the point of your class into Softdrink class.
	/// Do you have better implements for just adding class here and not modifying Softdrink class?
	class Addition{
	public:
		virtual void Add()=0;
		virtual ~Addition(){};
	};
#endif

#ifndef SUGAR_H
#define SUGAR_H
	class Sugar:public Addition{
	public:
		virtual void Add();
	};
#endif
	void Sugar::Add(){
		std::cout<<"add sugar"<<std::endl;
	}

#ifndef ICE_H
#define ICE_H
	class Ice:public Addition{
	public:
		virtual void Add();
	};
#endif
	void Ice::Add(){
		std::cout<<"add ice"<<std::endl;
	}

#ifndef SOFTDRINK_H
#define SOFTDRINK_H
	/// this class is the abstract class in Bridge pattern.
	/// I consider there will be some other implement methods.
	/// I use Addition objects as member variables, 
	/// and construct and destroy them in Softdrink.
	/// But if there is no member variables of Addition, It will be ok.
	/// for example: you can send Addition instances as parameters into Softdrink subclass.
	/// But in Bridge pattern, the uml is aggregation between implement class and abstract class.
	class Softdrink{
	public:
		Softdrink();
		virtual void drink()=0;
		virtual ~Softdrink()=0;
	protected:
		Addition *sugar;
		Addition *ice;
		/// another additions add here!
	};
	Softdrink::~Softdrink(){
		if(NULL != sugar){
			delete sugar;
		}
		if(NULL != ice){
			delete ice;
		}
	}
	Softdrink::Softdrink(){
		sugar = new Sugar();
		ice = new Ice();
	}
#endif

#ifndef COFF_H
#define COFF_H

	class Coff: public Softdrink{
	public:

		virtual void drink();

	};
#endif
	void Coff::drink(){
		std::cout<<"I am drinking coff!"<<std::endl;
		sugar->Add();
	}

#ifndef COCA_H
#define COCA_H
	class Coca: public Softdrink{
	public:
		virtual void drink();
	};
#endif
	void Coca::drink(){
		std::cout<<"I am drinking coca cola!"<<std::endl;
		ice->Add();
	}

}

int main()
{

	pattern::Coca coca;
	coca.drink();
	pattern::Coff coff;
	coff.drink();
	return 0;
}

// decorator.cpp : Defines the entry point for the console application.
// author: chillyc
// email: chillycreator @t gmail.com

#include<iostream>
namespace pattern{
	/// this pattern is decorator pattern.
	/// In this pattern the super class should have default process functions.
	/// for example: "Read" has default read word function, and it is useful in the future.
	/// Read_Char, Read_Chinese, Decorator inherit Read class.
	/// But those three subclass is not powerful to deal with sentences.
	/// Then the subclass of Decorator will deal with sentences, but it dose not know every word.
	/// So Sentence(Encode) pattern has become.
	/// But decorator pattern is not only dealing with this situation but also enhance some classes
	/// capacity without adding new classes.
	/// is it something like Bridge?
#ifndef READ_H
#define READ_H
	class Read{
	public:
		Read(){}
		virtual ~Read(){}

		/// this is default process function.
		/// and decorator class will use this function to read
		virtual void ReadWord(){std::cout<<"default read!"<<std::endl;}
		/// if the function is a pure virtual function,
		/// decorator class need not inherit this class and
		/// it just has an instance of Read as a member varible.
		// virtual void ReadWord()=0;

	};
#endif

#ifndef READCHAR_H
#define READCHAR_H
	class Read_Char:public Read{
	public:
		Read_Char():Read(){}
		~Read_Char(){}
		virtual void ReadWord();
	};
#endif
	void Read_Char::ReadWord(){
		std::cout<< "read a char"<<std::endl;

	}

#ifndef READCHINESE_H
#define READCHINESE_H
	class Read_Chinese:public Read{
	public:
		Read_Chinese():Read(){}
		~Read_Chinese(){}
		virtual void ReadWord();
	};
#endif
	void Read_Chinese::ReadWord(){
		std::cout<<"read a chinese word"<<std::endl;
	}

#ifndef DECORATOR_H
#define DECORATOR_H
	class Decorator:public Read{
	protected:
		Read* r;
	public:
		Decorator():Read(){r = NULL;}
		Decorator(Read* r):Read(),r(r){}
		virtual ~Decorator(){if(r!=NULL) delete r;}
		virtual void ReadWord();
	};
#endif
	void Decorator::ReadWord(){
		if(NULL == r)
			Read::ReadWord();
		else
			r->ReadWord();
	}

#ifndef READSENTENCE_H
#define READSENTENCE_H
	// this class is real work decorator class
	class Read_Sentence:public Decorator{

	public:
		Read_Sentence():Decorator(){}
		Read_Sentence(Read* r):Decorator(r){}
		~Read_Sentence(){}
		virtual void ReadWord();
	};
#endif
	void Read_Sentence::ReadWord(){
		/// parent class method is called first!
		Decorator::ReadWord();
		/// then your method be called
		std::cout<<"read a sentence"<<std::endl;
	}
}

int main()
{
	pattern::Read_Sentence rs1(new pattern::Read_Char());// read char
	pattern::Read_Sentence rs2(new pattern::Read_Chinese());// read chinese
	pattern::Read_Sentence rs3; // default read
	rs1.ReadWord();
	rs2.ReadWord();
	rs3.ReadWord();
	return 0;
}