自己实现的一个寻径算法的框架，具体算法采用动态库模式，可以非常方便灵活地尝试多种寻径算法

/**
 * 寻径算法框架
 * by lxslove
 * e-mail:moodlxs@163.com
 * 用法：
 * 注意：编译本框架需要加上-ldl选项
 * g++ -ldl src.cpp
 *
 * 地图文件格式为不同符号的矩阵，具体什么符号代表可通行，什么符号代表不可通行，由自己决定。举个例子：
 * ###################
 * # ######   ########
 * # ###### ##########
 * #        ##########
 * ######## #     ####
 * ##   #### ## ######
 * ### #  ######### ##
 * ###### ##### # # ##
 * #### # ##### ######
 * ######      #######
 * ###################
 * 以上的例子，假设空格是可通行的，#是不可通行的。
 *
 * 具体的算法采用插件的形式，插件（so文件）需要提供find_path函数接口，该函数的形式为：
 * extern "C"
 * int find_path(size_t start_pos, size_t end_pos, vector<char>* map_data, vector<char>* path_list)
 * {
 *             return 0;	//成功则返回0
 * }
 * 编译so文件的方式例子如下：
 * g++ -fPIC -shared -o 1.so 1.cpp 1.h 
 *
 * start_pos/end_pos为地图数据在map_data中的位置，path_list暂时没用到
 * 在得到路径时，需要在find_path接口方法中修改map_data的符号，标志其为路径，具体修改为什么符号由自己决定，举个例子：
 * ###################
 * #@######@  ########
 * #@######@##########
 * #@@@@@@@@##########
 * ######## #     ####
 * ##   #### ## ######
 * ### #  ######### ##
 * ###### ##### # # ##
 * #### # ##### ######
 * ######      #######
 * ###################
 * 以上例子中，将相应位置的符号修改为@
 * 框架会直接显示地图数据，是什么符号就显示什么符号。
 * */

#define DL cout
#include <stdio.h>
#include <string.h>
#include <libgen.h>
#include <dlfcn.h>
#include <sys/time.h>
#include <string>
#include <fstream>
#include <iostream>
#include <vector>

using namespace std;

/// 插件接口
// 参数为：
// 开始位置，结束位置，地图数据列表， 路径列表,暂时不用,固定为NULL
typedef int (*pfunc)(size_t, size_t, vector<char>*, vector<char>*);

const char* const FUNC_NAME = "find_path";

class XJFrame
{
	private:
		string 			m_map_path;						/// 地图位置
		pfunc			p_func;							/// 插件的接口函数
		vector<char> 	m_map_data;						/// 地图数据指针
		vector<size_t>* m_p_path_data;					/// 路径数据指针
		size_t 			m_map_width;					/// 地图宽度
		size_t			m_map_heigh;					/// 地图高度
		void *			m_p_module;						/// 模块指针
		struct timeval  m_use_time;							/// 算法耗时

	public:
		size_t get_map_width()
		{
			return m_map_width;
		}

		size_t get_map_heigh()
		{
			return m_map_heigh;
		}

		const struct timeval* get_use_time()
		{
			return &m_use_time;
		}

	private:
		XJFrame(const XJFrame& rv);
		XJFrame& operator=(const XJFrame& rv);

	public:
		XJFrame()
			:m_map_width(0), m_map_heigh(0), m_p_module(NULL), m_p_path_data(NULL)
		{
		}

		XJFrame(const string& map_path)
			:m_map_path(map_path), m_map_width(0), m_map_heigh(0), m_p_module(NULL), m_p_path_data(NULL)

		{
		}

		~XJFrame()
		{
			if (m_p_module) 
			{
				dlclose(m_p_module);
				m_p_module = NULL;
			}
			if (m_p_path_data)
			{
				delete m_p_path_data;
				m_p_path_data = NULL;
			}
		}


		void set_map_path(const string & map_path)
		{
			m_map_path = map_path;
		}

		int open_module(const string & module_path)
		{
			if (module_path.empty())
			{
				DL << "module_path not setting!\n";
				return -1;
			}

			if (m_p_module)
			{
				dlclose(m_p_module);
				m_p_module = NULL;
			}

			void* m_p_module = dlopen(module_path.c_str(), RTLD_LAZY );
			if( !m_p_module )
			{
				DL << "can't open module: " << module_path <<", error:" << dlerror() << "\n";
				return -1;
			}
			p_func = (pfunc)dlsym(m_p_module, FUNC_NAME);
			const char *dlsym_error = dlerror();
			if (dlsym_error)
			{
				DL << "load  symbol: " << FUNC_NAME << "! err: " << dlsym_error << "\n";
				return -1;
			}

			return 0;
		}


		int init_map()
		{
			if (m_map_path.empty()) 
			{
				DL << "map_path not setting!\n";
				return -1;
			}

			m_map_data.clear();

			ifstream in_file(m_map_path.c_str());
			if (!in_file) 
			{
				DL << "open file error:" << m_map_path << "\n";
				return -1;
			}

			size_t len;
			char buffer[1024];
			while (!in_file.eof())
			{
				in_file.getline(buffer, sizeof(buffer));
				len = strlen(buffer);
				if (len == 0)
				{
					break;
				}

				//根据第一次的宽度计算地图宽度
				if (!m_map_width)
				{
					m_map_width = len;
				}
				else if (m_map_width != len) 
				{
					DL << "map format error！0\n";
					return -1;
				}

				//计算地图高度
				++m_map_heigh;

				//读取地图信息
				for (size_t i = 0; i < len; ++i)
				{
					if ((*(buffer + i)) != ' ' && (*(buffer + i)) != '#')
					{
						DL << "map format error！2\n";
						return -1;
					} 
					else
					{
						m_map_data.push_back(*(buffer + i));
					}
				}
			}
			
			in_file.close();

			return 0;
		}

		void display_map()
		{
			if (m_map_data.empty())
			{
				DL << "Please load map before!" << endl;
				return ;
			}

			DL << "Map Info: width:" << m_map_width << ", heigh:" << m_map_heigh << endl;
			for (int i = 0; i < m_map_data.size(); ++i) 
			{
				DL << m_map_data[i];
				if ((i + 1) % m_map_width == 0) 
				{
					DL << "\n";
				}
			}
		}

		int find_path(size_t start_pos, size_t end_pos)
		{
			if (m_map_data.empty())
			{
				DL << "Please load map before!" << endl;
				return -1;
			}
			struct timeval tvs, tve;
			gettimeofday(&tvs, NULL);
			int ret = p_func(start_pos, end_pos, &m_map_data, NULL);
			gettimeofday(&tve, NULL);
			if (tve.tv_usec < tvs.tv_usec)
			{
				--tve.tv_sec;
				tve.tv_usec+=1000;
			}
			m_use_time.tv_sec = tve.tv_sec - tvs.tv_sec;
			m_use_time.tv_usec = tve.tv_usec - tvs.tv_usec;
		}
};

int main(int argc, char** argv)
{
	XJFrame xjframe;
	int user_select;
	bool is_exit = false;

	if (argc == 3) 
	{
		xjframe.set_map_path(argv[1]);
		xjframe.init_map();
		xjframe.open_module(argv[2]);
		xjframe.display_map();
	}
	do
	{
		cout << "MENU:\nSetMap(1)\tSetModule(2)\tDisplayMap(3)\tFindPath(4)\tExit(0)" << endl;
		cout << "Input:" << flush;
		while (!(cin >> user_select)) 
		{
			cout <<"Input error, retry:"<< flush;
			cin.clear();
			cin.ignore(10000,'\n');
		}

		string str;
		int ret; 
		switch (user_select)
		{
			case 1:
				cout << "Your Map Path:";
				cin >> str;
				xjframe.set_map_path(str);
				ret = xjframe.init_map();
				if (ret != 0) 
				{
					cout << "Set Map Error" << endl;
				}
				else 
				{
					cout << "Set Map Success" << endl;
				}

				break;

			case 2:
				cout << "Your Module Path:";
				cin >> str;
				ret = xjframe.open_module(str);
				if (ret != 0) 
				{
					cout << "Set Module Error" << endl;
				}
				else 
				{
					cout << "Set Module Success" << endl;
				}

				break;

			case 3:
				xjframe.display_map();
				break;

			case 4:
				cout << "Enter the start position and end position,format:x y x y";
				{
					int sx,sy,ex,ey;
					if (!(cin >> sx >> sy >> ex >> ey))
					{
						cout << "Input Error!" << endl;
						break;
					}
					else
					{
						int start_pos = sy * xjframe.get_map_width() + sx;
						int end_pos = ey * xjframe.get_map_width() + ex;

						ret = xjframe.find_path(start_pos, end_pos);
						if (ret != 0)
						{
							cout << "can not find any path!" << endl;
						} 
						else
						{
							cout << "path find!" << endl;
							xjframe.display_map();
						}
						cout << "Use Time:" << xjframe.get_use_time()->tv_sec << " second " << xjframe.get_use_time()->tv_usec << " microsecond" << endl;
					}
				}

				break;

			case 0:
				is_exit = true;
				break;
			default:
				break;
		}
		cin.clear();
		cin.ignore(10000,'\n');
	}while (!is_exit);
	cout << "byebye" << endl;

	return 0;
}