C++博客-野猪世界-随笔分类-C/C++ STL Python Lua

python c++

野猪红 — Tue, 10 Dec 2013 10:27:00 GMT

#include

using namespace boost::python;

int add_five(int x) {

return x + 5;

}

#pragma comment(lib,"python27.lib")

BOOST_PYTHON_MODULE(Pointless)

{

def("add_five", add_five);

}

int main(int, char **) {

Py_Initialize();

try

{

initPointless(); // initialize Pointless

PyRun_SimpleString("import sys");

PyRun_SimpleString("sys.path.append('./')");

/*PyRun_SimpleString("import Pointless");

PyRun_SimpleString("print Pointless.add_five(4)");*/

PyRun_SimpleString("execfile('test.py')");

}

catch (error_already_set)

{

PyErr_Print();

}

Py_Finalize();

return 0;

}
//--------------------------------------------------------------------------------------
boost::python::manage_new_object
假如返回一个类型CZhu 那么使用时必须在python中注册CZhu对应的类
//--------------------------------------------------------------------------------------
boost::python::return_opaque_pointer
这个就仅仅是个python包装的指针用来传回给c++做点什么的

野猪红 2013-12-10 18:27 发表评论

模型

野猪红 — Fri, 31 May 2013 12:37:00 GMT

代码原则：
1 一个对象只管理属于她自己的东西，其他对象用UUID来索引
2 要将特殊化转为一般化，易于管理
3 参数要一般化，最小化，重用原则
4 对象要分层，每层用type区分，每层只有自己的数据

ogre渲染对象原则
1 考虑是在哪个RenderQueueGroup上
2 考虑和其对应实体联系，UUID的位置
3 透明雾化
4 对反射，折射的影响
5 如何序列化

野猪红 2013-05-31 20:37 发表评论

通用的多线程处理模型

野猪红 — Thu, 24 Jan 2013 12:07:00 GMT

好草多线程处理
放代码：

class ThreadTest
{
public:
    ThreadTest(){}
    ~ThreadTest(){}
    void startup();
    void addreq(int);

    void _threadMain();
    void _waitForNextRequest();
    void _processNextRequest();

    struct WorkerFunc OGRE_THREAD_WORKER_INHERIT
    {
        ThreadTest* mQueue;

        WorkerFunc(ThreadTest* q)
            : mQueue(q) {}

        void operator()();

        void run();
    };
    WorkerFunc* mWorkerFunc;

    typedef std::deque<int> RequestQueue;
    RequestQueue mRequestQueue;

    OGRE_MUTEX(mRequestMutex)
    OGRE_MUTEX(mProcessMutex)
    OGRE_MUTEX(mResponseMutex)
    OGRE_THREAD_SYNCHRONISER(mRequestCondition)

};

void ThreadTest::addreq(int i)
{
    OGRE_LOCK_MUTEX(mRequestMutex)
    mRequestQueue.push_back(i);
    OGRE_THREAD_NOTIFY_ONE(mRequestCondition)
}
void ThreadTest::startup()
{
    int i=3;
    while(i>0)
    {
        mWorkerFunc = OGRE_NEW_T(WorkerFunc(this), MEMCATEGORY_GENERAL);
        OGRE_THREAD_CREATE(t, *mWorkerFunc);
        i--;
    }

}
void ThreadTest::WorkerFunc::operator()()
{
    mQueue->_threadMain();
}

void ThreadTest::WorkerFunc::run()
{
    mQueue->_threadMain();
}
void ThreadTest::_threadMain()
{
    while (true)
    {
        _waitForNextRequest();
        _processNextRequest();
    }

}

void ThreadTest::_waitForNextRequest()
{
    OGRE_LOCK_MUTEX_NAMED(mRequestMutex, queueLock);
    if (mRequestQueue.empty())
    {
        OGRE_THREAD_WAIT(mRequestCondition, mRequestMutex, queueLock);
    }

}

void ThreadTest::_processNextRequest()
{
    OGRE_LOCK_MUTEX(mProcessMutex)
    {
        OGRE_LOCK_MUTEX(mRequestMutex);
        if (!mRequestQueue.empty())
        {
            int request = mRequestQueue.front();
            mRequestQueue.pop_front();
            cout<<request<<endl;
        }
    }

}

当然里面用到了一些ogre中的线程宏，展开也就是boost的线程api：
#define OGRE_LOCK_MUTEX(name) boost::recursive_mutex::scoped_lock ogrenameLock(name);
#define OGRE_LOCK_MUTEX_NAMED(mutexName, lockName) boost::recursive_mutex::scoped_lock lockName(mutexName);

#define OGRE_THREAD_WAIT(sync, mutex, lock) sync.wait(lock);
#define OGRE_THREAD_NOTIFY_ONE(sync) sync.notify_one();
#define OGRE_THREAD_NOTIFY_ALL(sync) sync.notify_all();

#define OGRE_THREAD_SYNCHRONISER(sync) boost::condition sync;

#define OGRE_MUTEX(name) mutable boost::recursive_mutex name;

#define OGRE_THREAD_WAIT(sync, mutex, lock) sync.wait(lock);

主线程不断调用addreq()来增加请求并通知线程后马上返回线程在得到通知后从阻塞中醒来处理请求
OGRE_LOCK_MUTEX(name)：就是在范围内只允许有一个线程进入
OGRE_THREAD_WAIT(mRequestCondition, mRequestMutex, queueLock)：该宏会失去queueLock，阻塞当前线程直到被通知，在返回前取得queueLock
来看_waitForNextRequest()的代码：
_waitForNextRequest()
{
   OGRE_LOCK_MUTEX_NAMED(mRequestMutex, queueLock);
    if (mRequestQueue.empty())
    {
        OGRE_THREAD_WAIT(mRequestCondition, mRequestMutex, queueLock);
    }
}
首先取得范围锁queueLock，如果mRequestQueue为空，就等着，同时要注意，由于失去queueLock，其他线程会得到queueLock，并再次导致queueLock的变化
如果有三个线程，分别是1,2,3
假设线程1最先取得queueLock，然后被阻塞，同时线程2或者3会在线程1失去queueLock时取得queueLock，最终，三个线程都会被阻塞，queueLock为失去
继续往下走，假设这时主线程addreq()，那么有一个线程会被唤醒，同时得到queueLock，然后跳出该函数时，queueLock也随着超出范围变为失去，然后来看
下一个函数_processNextRequest()的代码：
_processNextRequest()
{
      Request* request = 0;
      {
          OGRE_LOCK_MUTEX(mRequestMutex)

          if (!mRequestQueue.empty())
          {
              request = mRequestQueue.front();
              mRequestQueue.pop_front();
          }
       }

       if (request)
       {
            processRequestResponse(request, false);
       }

}
函数内容改了下以看得更加清楚，函数取得mRequestMutex，当其队列非空时，从队列中弹出一个请求，随后丢失mRequestMutex，并处理request
在处理完request后，将结果放进一个响应队列中，主线程在其循环中将会看到，整个流程就是这样子
总结：请求队列要注意是否为空，由于有多个线程，需要将其设为阻塞并在需要时唤醒

野猪红 2013-01-24 20:07 发表评论

Lua 中调用C函数

野猪红 — Wed, 27 Apr 2011 07:48:00 GMT

好的现在讲讲Lua中调用C函数
怎么调用？
extern "C"
{
#include
#include

#pragma comment(lib,"lua51.lib")

static int l_test(lua_State* l)
{
  double d=lua_tonumber(l,1);
  lua_pushnumber(l,d*d);
  return 1;
}

__declspec(dllexport) int luaopen_test(lua_State* l)
{
  static const luaL_reg maps[]={
   {"test",l_test},
   {NULL,NULL}
  };
  luaL_register(l,"mytest",maps);
  return 1;
}
}
参数在lua中给出，而在c函数中，通过取栈操作得到参数，c经过处理，把结果压入栈中，ok

要点有二：
1. __declspec(dllexport) 要有
2. luaopen_模块名，假设生成的dll叫test.dll，那么函数名就叫luaopen_test

好就是这样谢谢

野猪红 2011-04-27 15:48 发表评论

模板类的构造函数 =操作符重载

野猪红 — Mon, 09 Aug 2010 08:23:00 GMT

1 template<class T>
2 class ye
3 {
4 public:
5     ye(){cout<<"I'm ye()"<<endl;}
6
7     //-------------------------------
       //普通拷贝构造函数
8     ye(const ye<T>&y){cout<<"I'm ye(const ye&)"<<endl;}
       //模板拷贝构造函数
9     template<class K>
10     ye(const ye<K> &){cout<<"I'm templateye(const ye&)"<<endl;}
11     //-------------------------------
12
13     //-------------------------------
14     ye(T*)
15     {
16         cout<<"I'm ye(T*)"<<endl;
17     }
18     template<class Y>
19     ye(Y*){cout<<"I'm template ye(Y*)"<<endl;}
20     //-------------------------------
21
22     //-------------------------------
23     ye& operator=(const ye &)
24     {
25         cout<<"I'm operator=(const ye&)"<26         return *this;
27     }
28     template
29     ye& operator=(const ye &)
30     {
31         cout<<"I'm template operator=(const ye&)"<32         return *this;
33     }
34     //-------------------------------
35
36 };

上面是一个典型的模板类首先看构造函数
当我们输入
ye y;                 //输出I'm ye()
ye k=y;或ye k(y);//输出I'm ye(const ye&)
ye f=k;             //输出I'm templateye(const ye&)
到此没什么问题

现在注释掉两个拷贝构造函数
输入
ye y;   //输出I'm ye()
ye k=y; //无输出，使用默认的构造函数

清空输入
ye y;
ye k=y; //会出现编译错误

清空输入
ye y;
ye k;
y=k;         //I'm operator=(const ye&)
ye h;
h=k;         //I'm template operator=(const ye&)

如果把操作符重载函数注释掉
当出现y=k时就会调用相应默认的赋值函数
当出现h=k时就会出现编译错误

野猪红 2010-08-09 16:23 发表评论

stl 排序

野猪红 — Sun, 27 Jun 2010 08:35:00 GMT

好我喜欢这个小蝙蝠
vector list map 这些结构的使用率比较高看看如何定制其排序
1 vector
vector是无序结构可以使用标准算法std::sort方法来排序查看sort的源码可以了解到
sort算法总体是采用快速排序局部采用插入排序效率良好通过指定sort的第3个参数
一个函数对象的实例我们可以定制排序行为让其从大到小或从小到大我们看例子：

1 class SortMethod
2 {
3 public:
4     bool operator()(int a,int b) const
5     {
6         return a<b;
7     }
8 };
9
10 int main()
11 {
12
13     vector<int> v;
14     v.push_back(5);
15     v.push_back(8);
16     v.push_back(2);
17     std::sort(v.begin(),v.end(),SortMethod());
18
19     return 0;
20 }

如果要让其按反序排列修改重载函数为 return a>b 如果没有提供第3个参数
默认是std::less<>() 该类是重载了()操作符的模板类效果和SortMethod类似
现在我们的数据类型是int 如果是class或者struct且接受默认比较函数对象
就得在类中实现重载<操作符看例子：

class yezhu
{
public:
    yezhu():i(0){cout<<"I'm yezhu "<<i<<endl;}
    ~yezhu(){cout<<"del yezhu "<<i<<endl;}
    yezhu(int n):i(n){cout<<"I'm yezhu "<<i<<endl;}
    void setValue(int n){i=n;}
    int  getValue() const{return i;}
    bool operator<(const yezhu& val) const
    {
        return i<val.i;
    }
protected:
    int i;
};

int main()
{
    vector<yezhu> v;
    v.push_back(yezhu(3));
    v.push_back(yezhu(2));
    v.push_back(yezhu(1));
    std::sort(v.begin(),v.end());

    return 0;
}

2.list
list有自己的sort函数有一个可选参数默认是std::less<>() 不能用标准sort()函数排序

3.map
map是有序结构在其构造的时候可以指定比较函数对象注意这里提供的不是实例而是类型

int main()
{
    map<int,char,greater<int>> m;

    return 0;
}

野猪红 2010-06-27 16:35 发表评论