出自：http://blog.csdn.net/mailbomb

       在游戏中，经常需要进行碰撞检测的实现，例如判断前面是否有障碍以及判断子弹是否击中飞机，都是检测两个物体是否发生碰撞，然后根据检测的结果做出不同的处理。

       进行碰撞检测的物体可能有些的形状和复杂，这些需要进行组合碰撞检测，就是将复杂的物体处理成一个一个的基本形状的组合，然后分别进行不同的检测。

       下面简单介绍一下两种最基本的形状进行碰撞的时候进行的处理。

       1、矩形和矩形进行碰撞

   一般规则的物体碰撞都可以处理成矩形碰撞，实现的原理就是检测两个矩形是否重叠。我们假设矩形1的参数是：左上角的坐标是(x1,y1)，宽度是w1，高度是h1；矩形2的参数是：左上角的坐标是(x2,y2)，宽度是w2，高度是h2。

       在检测时，数学上可以处理成比较中心点的坐标在x和y方向上的距离和宽度的关系。即两个矩形中心点在x方向的距离的绝对值小于等于矩形宽度和的二分之一，同时y方向的距离的绝对值小于等于矩形高度和的二分之一。下面是数学表达式：

x方向：   | (x1 + w1 / 2) – (x2 + w2/2) | < |(w1 + w2) / 2|

y方向：   | (y1 + h1 / 2) – (y2 + h2/2) | < |(h1 + h2) / 2|

       在程序中，只需要将上面的条件转换成代码就可以实现了。

       但是矩形碰撞只是一种比较粗糙的碰撞检测方法，因为很多实际的物体可能不是一个规则的矩形。

       下面介绍一下圆形碰撞。

2、圆形和圆形的碰撞

       圆形和圆形的碰撞应该说是一种最简单的碰撞，因为在数学上对于两个圆形是否发生重叠，有计算两个圆心之间的距离的公式。那么条件就变为：计算两个圆心之间的距离是否小于两个圆的半径和。

       假设圆形1的左上角坐标是(x1,y1)，半径是r1，圆形2的左上角的坐标是(x2,y2)，半径是r2。

       因为MIDP1.0中没有浮点数，而且浮点数的运算比较慢，所以我们将条件做一个简单的变换：对于条件的两边都进行平方，这样就去掉了开方的运算步骤。

       下面是数学表达式：

        (x1 – x2)² + (y1 – y2)² < (r1 + r2)²

       在程序中，只需要将上面的条件转换成代码就可以了。

       上面介绍的只是最基本的碰撞检测算法的实现，而实际的编程过程中遇到的碰撞检测问题要比这些复杂很多，还需要其他形式的检测，还需要进行更加深入的学习。

email:cqucyf@263.net

新一篇: 平台无关性程序的构造

0 前言

就在几年前，用多线程执行程序还是一件非比寻常的事。然而今天互联网应用服务程序普遍使用多线程来提高与多客户链接时的效率；为了达到最大的吞吐 量，事务服务器在单独的线程上运行服务程序；GUI应用程序将那些费时，复杂的处理以线程的形式单独运行，以此来保证用户界面能够及时响应用户的操作。这 样使用多线程的例子还有很多。

但是C++标准并没有涉及到多线程，这让程序员们开始怀疑是否可能写出多线程的C++程序。尽管不可能写出符合标准的多线程程序，但是程序员们还是 会使用支持多线程的操作系统提供的多线程库来写出多线程C++程序。但是这样做至少有两个问题：这些库大部分都是用C语言完成的，如果在C++程序中要使 用这些库就必须十分小心；还有，每一个操作系统都有自己的一套支持多线程的类库。因此，这样写出来得代码是没有标准可循的，也不是到处都适用的（non- portable)。Boost线程库就是为了解决所有这些问题而设计的。

Boost是由C++标准委员会类库工作组成员发起，致力于为C++开发新的类库的组织。现在它已经有近2000名成员。许多库都可以在Boost源码的发布版本中找到。为了使这些类库是线程安全的（thread-safe)，Boost线程库被创建了。

许多C++专家都投身于Boost线程库的开发中。所有接口的设计都是从0开始的，并不是C线程API的简单封装。许多C++特性（比如构造函数和 析构函数，函数对象（function object)和模板）都被使用在其中以使接口更加灵活。现在的版本可以在POSIX,Win32和Macintosh Carbon平台下工作。

1 创建线程

起先，大家认为传统C创建线程的方法似乎比这样的设计更有用，因为C创建线程的时候会传入一个void*指针，通过这种方法就可以传入数据。然而， 由于Boost线程库是使用函数对象来代替函数指针，那么函数对象本身就可以携带线程所需的数据。这种方法更具灵活性，也是类型安全（type- safe)的。当和Boost.Bind这样的功能库一起使用时，这样的方法就可以让你传递任意数量的数据给新建的线程。

目前，由Boost线程库创建的线程对象功能还不是很强大。事实上它只能做两项操作。线程对象可以方便使用==和!=进行比较来确定它们是否是代表 同一个线程；你还可以调用boost::thread::join来等待线程执行完毕。其他一些线程库可以让你对线程做一些其他操作（比如设置优先级，甚 至是取消线程）。然而，由于要在普遍适用（portable）的接口中加入这些操作不是简单的事，目前仍在讨论如何将这些操组加入到Boost线程库中。

Listing1展示了boost::thread类的一个最简单的用法。 新建的线程只是简单的在std::out上打印“hello,world”，main函数在它执行完毕之后结束。

例1：

#include <boost/thread/thread.hpp>

#include <iostream>



void hello()

{

std::cout <<

"Hello world, I'm a thread!"

<< std::endl;

}



int main(int argc, char* argv[])

{

boost::thread thrd(&hello);

thrd.join();

return 0;

}

2 互斥体

互斥体的概念有不少变种。Boost线程库支持两大类互斥体，包括简单互斥体（simple mutex)和递归互斥体（recursive mutex)。如果同一个线程对互斥体上了两次锁，就会发生死锁（deadlock），也就是说所有的等待解锁的线程将一直等下去。有了递归互斥体，单个 线程就可以对互斥体多次上锁，当然也必须解锁同样次数来保证其他线程可以对这个互斥体上锁。

在这两大类互斥体中，对于线程如何上锁还有多个变种。一个线程可以有三种方法来对一个互斥体加锁：

1. 一直等到没有其他线程对互斥体加锁。
2. 如果有其他互斥体已经对互斥体加锁就立即返回。
3. 一直等到没有其他线程互斥体加锁，直到超时。

似乎最佳的互斥体类型是递归互斥体，它可以使用所有三种上锁形式。然而每一个变种都是有代价的。所以Boost线程库允许你根据不同的需要使用最有效率的互斥体类型。Boost线程库提供了6中互斥体类型，下面是按照效率进行排序：

boost::mutex,

boost::try_mutex, 

boost::timed_mutex, 

boost::recursive_mutex, 

boost::recursive_try_mutex,  

boost::recursive_timed_mutex 

这种方法保证正确的使用互斥体。然而，有一点必须注意：尽管Scope Lock模式可以保证互斥体被解锁，但是它并没有保证在异常抛出之后贡献资源仍是可用的。所以就像执行单线程程序一样，必须保证异常不会导致程序状态异 常。另外，这个已经上锁的对象不能传递给另一个线程，因为它们维护的状态并没有禁止这样做。

List2给出了一个使用boost::mutex的最简单的例子。例子中共创建了两个新的线程，每个线程都有10次循环，在std::cout上 打印出线程id和当前循环的次数，而main函数等待这两个线程执行完才结束。std::cout就是共享资源，所以每一个线程都使用一个全局互斥体来保 证同时只有一个线程能向它写入。

许多读者可能已经注意到List2中传递数据给线程还必须的手工写一个函数。尽管这个例子很简单，如果每一次都要写这样的代码实在是让人厌烦的事。 别急，有一种简单的解决办法。函数库允许你通过将另一个函数绑定，并传入调用时需要的数据来创建一个新的函数。 List3向你展示了如何使用Boost.Bind库来简化List2中的代码，这样就不必手工写这些函数对象了。

例2：

#include <boost/thread/thread.hpp>

#include <boost/thread/mutex.hpp>

#include <iostream>



boost::mutex io_mutex;



struct count

{

count(int id) : id(id) { }



void operator()()

{

for (int i = 0; i < 10; ++i)

{

boost::mutex::scoped_lock

lock(io_mutex);

std::cout << id << ": "

<< i << std::endl;

}

}



int id;

};



int main(int argc, char* argv[])

{

boost::thread thrd1(count(1));

boost::thread thrd2(count(2));

thrd1.join();

thrd2.join();

return 0;

}

例3： // 这个例子和例2一样，除了使用Boost.Bind来简化创建线程携带数据，避免使用函数对象

#include <boost/thread/thread.hpp>

#include <boost/thread/mutex.hpp>

#include <boost/bind.hpp>

#include <iostream>



boost::mutex io_mutex;



void count(int id)

{

for (int i = 0; i < 10; ++i)

{

boost::mutex::scoped_lock

lock(io_mutex);

std::cout << id << ": " <<

i << std::endl;

}

}



int main(int argc, char* argv[])

{

boost::thread thrd1(

boost::bind(&count, 1));

boost::thread thrd2(

boost::bind(&count, 2));

thrd1.join();

thrd2.join();

return 0;

}

3 条件变量

条件变量的使用总是和互斥体及共享资源联系在一起的。线程首先锁住互斥体，然后检验共享资源的状态是否处于可使用的状态。如果不是，那么线程就要等 待条件变量。要指向这样的操作就必须在等待的时候将互斥体解锁，以便其他线程可以访问共享资源并改变其状态。它还得保证从等到得线程返回时互斥体是被上锁 得。当另一个线程改变了共享资源的状态时，它就要通知正在等待条件变量得线程，并将之返回等待的线程。

List4是一个使用了boost::condition的简单例子。有一个实现了有界缓存区的类和一个固定大小的先进先出的容器。由于使用了互斥 体boost::mutex，这个缓存区是线程安全的。put和get使用条件变量来保证线程等待完成操作所必须的状态。有两个线程被创建，一个在 buffer中放入100个整数，另一个将它们从buffer中取出。这个有界的缓存一次只能存放10个整数，所以这两个线程必须周期性的等待另一个线 程。为了验证这一点，put和get在std::cout中输出诊断语句。最后，当两个线程结束后，main函数也就执行完毕了。

#include <boost/thread/thread.hpp>

#include <boost/thread/mutex.hpp>

#include <boost/thread/condition.hpp>

#include <iostream>



const int BUF_SIZE = 10;

const int ITERS = 100;



boost::mutex io_mutex;



class buffer

{

public:

typedef boost::mutex::scoped_lock

scoped_lock;



buffer()

: p(0), c(0), full(0)

{

}



void put(int m)

{

scoped_lock lock(mutex);

if (full == BUF_SIZE)

{

{

boost::mutex::scoped_lock

lock(io_mutex);

std::cout <<

"Buffer is full. Waiting..."

<< std::endl;

}

while (full == BUF_SIZE)

cond.wait(lock);

}

buf[p] = m;

p = (p+1) % BUF_SIZE;

++full;

cond.notify_one();

}



int get()

{

scoped_lock lk(mutex);

if (full == 0)

{

{

boost::mutex::scoped_lock

lock(io_mutex);

std::cout <<

"Buffer is empty. Waiting..."

<< std::endl;

}

while (full == 0)

cond.wait(lk);

}

int i = buf[c];

c = (c+1) % BUF_SIZE;

--full;

cond.notify_one();

return i;

}



private:

boost::mutex mutex;

boost::condition cond;

unsigned int p, c, full;

int buf[BUF_SIZE];

};



buffer buf;



void writer()

{

for (int n = 0; n < ITERS; ++n)

{

{

boost::mutex::scoped_lock

lock(io_mutex);

std::cout << "sending: "

<< n << std::endl;

}

buf.put(n);

}

}



void reader()

{

for (int x = 0; x < ITERS; ++x)

{

int n = buf.get();

{

boost::mutex::scoped_lock

lock(io_mutex);

std::cout << "received: "

<< n << std::endl;

}

}

}



int main(int argc, char* argv[])

{

boost::thread thrd1(&reader);

boost::thread thrd2(&writer);

thrd1.join();

thrd2.join();

return 0;

}

4 线程局部存储

有两种方法可以让不可重用的函数变成可重用的函数。第一种方法就是改变接口，用指针或引用代替原先使用静态数据的地方。比方说，POSIX定义了 strok_r，std::strtok中的一个可重入的变量，它用一个额外的char**参数来代替静态数据。这种方法很简单，而且提供了可能的最佳效 果。但是这样必须改变公共接口，也就意味着必须改代码。另一种方法不用改变公有接口，而是用本地存储线程（thread local storage）来代替静态数据（有时也被成为特殊线程存储，thread-specific storage）。

Boost线程库提供了智能指针boost::thread_specific_ptr来访问本地存储线程。每一个线程第一次使用这个智能指针的实 例时，它的初值是NULL，所以必须要先检查这个它的只是否为空，并且为它赋值。Boost线程库保证本地存储线程中保存的数据会在线程结束后被清除。

List5是一个使用boost::thread_specific_ptr的简单例子。其中创建了两个线程来初始化本地存储线程，并有10次循 环，每一次都会增加智能指针指向的值，并将其输出到std::cout上（由于std::cout是一个共享资源，所以通过互斥体进行同步）。main线 程等待这两个线程结束后就退出。从这个例子输出可以明白的看出每个线程都处理属于自己的数据实例，尽管它们都是使用同一个 boost::thread_specific_ptr。

例5：

#include <boost/thread/thread.hpp>

#include <boost/thread/mutex.hpp>

#include <boost/thread/tss.hpp>

#include <iostream>



boost::mutex io_mutex;

boost::thread_specific_ptr<int> ptr;



struct count

{

count(int id) : id(id) { }



void operator()()

{

if (ptr.get() == 0)

ptr.reset(new int(0));



for (int i = 0; i < 10; ++i)

{

(*ptr)++;

boost::mutex::scoped_lock

lock(io_mutex);

std::cout << id << ": "

<< *ptr << std::endl;

}

}



int id;

};



int main(int argc, char* argv[])

{

boost::thread thrd1(count(1));

boost::thread thrd2(count(2));

thrd1.join();

thrd2.join();

return 0;

}

5 仅运行一次的例程

解决这个问题的方法就是所谓的“一次实现”（once routine）。“一次实现”在一个应用程序只能执行一次。如果多个线程想同时执行这个操作，那么真正执行的只有一个，而其他线程必须等这个操作结束。 为了保证它只被执行一次，这个routine由另一个函数间接的调用，而这个函数传给它一个指针以及一个标志着这个routine是否已经被调用的特殊标 志。这个标志是以静态的方式初始化的，这也就保证了它在编译期间就被初始化而不是运行时。因此也就没有多个线程同时将它初始化的问题了。Boost线程库 提供了boost::call_once来支持“一次实现”，并且定义了一个标志boost::once_flag及一个初始化这个标志的宏 BOOST_ONCE_INIT。

List6是一个使用了boost::call_once的例子。其中定义了一个静态的全局整数，初始值为0；还有一个由 BOOST_ONCE_INIT初始化的静态boost::once_flag实例。main函数创建了两个线程，它们都想通过传入一个函数调用 boost::call_once来初始化这个全局的整数，这个函数是将它加1。main函数等待着两个线程结束，并将最后的结果输出的到 std::cout。由最后的结果可以看出这个操作确实只被执行了一次，因为它的值是1。

#include <boost/thread/thread.hpp>

#include <boost/thread/once.hpp>

#include <iostream>



int i = 0;

boost::once_flag flag =

BOOST_ONCE_INIT;



void init()

{

++i;

}



void thread()

{

boost::call_once(&init, flag);

}



int main(int argc, char* argv[])

{

boost::thread thrd1(&thread);

boost::thread thrd2(&thread);

thrd1.join();

thrd2.join();

std::cout << i << std::endl;

return 0;

}

6 Boost线程库的未来

Boost线程库已经作为标准中的类库技术报告中的附件提交给C++标准委员会，它的出现也为下一版C++标准吹响了第一声号角。委员会成员对 Boost线程库的初稿给予了很高的评价,当然他们还会考虑其他的多线程库。他们对在C++标准中加入对多线程的支持非常感兴趣。从这一点上也可以看出， 多线程在C++中的前途一片光明。

我偷个懒，下面的介绍摘自作者写的文档。

1.你不用声明并实现一个函数就可以得到和它功能相同的函数对象。例如，你需要
得到一个计算平面两点’(x1,y1)’ and ‘(x2,y2)’距离的函数。以前你需要这样做：
   float Euclid_Distance(float dx, float dy)
   {
      return sqrt(dx*dx+dy*dy);
   }

新办法是：
   //…any where of your program
   Variable x(1),y(2);
   Function fx = sqrt(x*x+y*y); //或者 sqrt((x^2.0f)+(y^2.0f);

2.对于分段函数，本库提供一种一目了然的表达：
    fx += WHEN(x>99.0f) | lg(x),
          WHEN(x>9.99f) | 10.0f-x,
          WHEN(x>0.0f)  | sin(x),
          sin(cos(x));
如你所见，这种办法要比使用”switch”或者”if-else”语句清晰多了。

3.几乎所有函数，都可以求得它的偏导数。
   fx = -cos(x);
   gx = fx.difference();
假如你修过微积分的课程，那么你现在已经知道”gx = sin(x)”.

4.动态创建函数对象。虽然我没有特意在这个方面作研究，但是我相信这个库确实
可以向这个方面发展。例如你打算写一个分析数学表达式的程序，这个库（或者其改
进版本）将会非常有用。如果有人对这方面的利用抱有兴趣，请联系作者。

5.任何你能找到的用处…

也许你心动了，这么好的东西到哪里可以找到？很简单，点这里就可以得到源码了，里面不但包含了所有的历史版本，还有作者写的几个sample。如果你有好的点子，要和作者联系，请写信到：yegong1985@鸡妹儿到炕

原文链接

信息在计算机上是用二进制表示的，这种表示法让人理解就很困难。因此计算机上都配有输入和输出设备，这些设备的主要目的就是，以一种人类可阅读的形 式将信息在这些设备上显示出来供人阅读理解。为保证人类和设备，设备和计算机之间能进行正确的信息交换，人们编制的统一的信息交换代码，这就是ASCII 码表，它的全称是“美国信息交换标准代码”。