随笔-6  评论-2  文章-1  trackbacks-0
  2009年6月12日
如果明确地引用一个NULL指针,则该引用是无效的
int *= 0;
int& y = *x;
这两行语句会引起一个段错误
别外返回局部变量的引用也是无效的
int& getLocalVariable()
{
        
int x;
        
return x;
}


posted @ 2009-06-12 13:52 L'双鱼 阅读(85) | 评论 (0)编辑 收藏
  2009年2月4日
一: 互斥体的概念
 Lockable Concept
TimedLockable Concept
SharedLockable Concept
UpgradeLockable Concept
    互斥体对象可以保护竞赛的数据和不同线程间的安全线程同步.线程可以调用互斥体的成员函数lock()来取得互斥体的所有权,unlock()释放所有权.在Boost::thread中,互斥体可以递归使用,允许几个线程同时拥有互斥体的所有权.
   Lockable 概念
    void lock() //boost::thread_resource_error if an error occurs
    bool try_lock()//boost::thread_resource_error if an error occurs.
    void unlock()
    Lockable的实现类必须提供以上函数.通过调用lock()获得所有权,unlock()释放所有权.   
    TimedLockable 概念
 bool timed_lock(boost::system_time  const&  abs_time)
template
<typename DurationType> bool timed_lock(DurationType const& rel_time
//boost::thread_resource_error if an error occurs.
    TimedLockable 概念精练于Lockable 支持超时尝试获锁,TimedLockable 的实现类除了实现Lockable类的成员外,还要实现上面两个函数.  
    SharedLockable 概念
 void lock_shared()
bool try_lock_shared()
bool timed_lock_shared(boost::system_time const& abs_time)
void unlock_shared()
    SharedLockable 精练于TimedLockable,用于提供共享所有权  
    UpgradeLockable概念
   
 void lock_upgrade()
void unlock_upgrade()
void unlock_upgrade_and_lock()
void unlock_upgrade_and_lock_shared()
void unlock_and_lock_upgrade()
    UpgradeLockable概念是一个完善SharedLockable概念,可以升级的所有权,以及共同的所有权和独自拥有。这是一个扩大到多读 者/单写模式所提供的SharedLockable概念:一个单一的线程可能升级所有权的同时,其他有共同的所有权。线程所有权可随时升级, 尝试拥有独家所有权。如果没有其他线程有共同的所有权,升级完成,立即和线程现在独家拥有,它必须放弃要求解锁()一样,如果它被收购,呼吁锁() 。
 Class template lock_guard

lock_guard(Lockable 
& m)
lock_guard(Lockable 
& m,boost::adopt_lock_t)
~lock_guard()



posted @ 2009-02-04 19:56 L'双鱼 阅读(323) | 评论 (0)编辑 收藏
  2009年1月23日
拓扑就是研究有形的物体在连续变换下,怎样还能保持性质不变.

posted @ 2009-01-23 17:58 L'双鱼 阅读(87) | 评论 (0)编辑 收藏
  2009年1月22日
1.
    寄存器
2. 栈
    位于常规内存区
3.堆
    多用途内存池(通常为对象)
4.静态存储区
    (非对象数据)
5.固定存储
6.非内存存储
    (流对象和persistent对象)


posted @ 2009-01-22 17:12 L'双鱼 阅读(84) | 评论 (0)编辑 收藏

"Evil does seek to maintain power by suppressing the truth."

"Or by misleading the innocent."

  Spock and McCoy, "And The Children Shall Lead", stardate 5029.5.

归根结底,所有问题都是列表,或所有问题都是算法

问题空间的元素同它在空间的表述称之为对象

万物皆对象

程序就是一组对象,告诉对方该做什么

每个对象都利用别的对象来组建自己的记忆

对象都有类型

所有属于同一类型的对象都能接受相同的消息

接口只管你能向这个对象发送什么消息

实现隐藏能减少程序的bug

继承: 复用接口

在新类中修改基类的行为称为覆写

"只覆写"基类的行为,称为替换规则,是(is-a)关系

在派生类中添加新接口是(is-like-a)关系

多态替换对象可以降低维护软件成本和增强设计

OPP语言采用后绑定的概念.

动态绑定是JAVA的缺省行为

interface是abstract的深化




posted @ 2009-01-22 10:01 L'双鱼 阅读(93) | 评论 (0)编辑 收藏
一. 线程启动
    线程的启动由传递一个没有构造函数的Callable类,之后复制到内存,由最新的线程调用.
struct callable
{
    
void operator()();
};
如果该类必须不可复制,那么可以用boost::ref传递一个Callable对象的引用到构造中.
boost::thread copies_are_safe()
{
    callable x;
    
return boost::thread(x); //参数为X的一份拷贝
// x is destroyed, but the newly-created thread has a copy, so this is OK 
boost::thread oops()
{
    callable x;
    
return boost::thread(boost::ref(x)); //参数为X的引用
// x is destroyed, but the newly-created thread still has a reference
  
// this leads to undefined behaviour
线程可以用一个函数或callable对象为参数构造,用boost::bind来实现
void find_the_question(int the_answer);

boost::thread deep_thought_2(boost::bind(find_the_question,
42));
void print();
boost::thread t=boost::thread(&print);

二.线程接合与脱离
当被销毁时,线程称为脱离(detached),当线程为脱离(detached)时,线程继续执行直到构造函数中函数或callable对象执行完毕,或程式终止.
void print();
boost::thread t(
&print);
t.join();
//线程销毁
t.join();//线程已经失效,t不指向任何线程,无作用
std::cout<<boolalpha<<t.joinable()<<std::endl;//print false statement

线程的脱离可以明确调用boost::detach()函数,这种情况下线程为非现脱离线程(now-detached thread),变为非线程(Not-a-Thread).
boost::thread::join() //如果线程为中断(interrupted),引发boost::thread_interrupted异常.
boost::thread::detach() //不引发异常,如果线程不脱离,线程析构时调用.



posted @ 2009-01-22 10:01 L'双鱼 阅读(1572) | 评论 (0)编辑 收藏
仅列出标题