久久福利一区,欧美劲爆第一页,在线看片欧美

walkspeed — Wed, 18 Jul 2007 05:28:00 GMT

Boost.Function库用来提供一个对象化的函数指针�?br>
函数指针对设计很有用。它使调用者可以�g期调用，调用时机��p��用者确定。而且可以改变
响应者，以应对不同的要求�?br>
C中的函数指针只能用于自由函数。在C++中除了自由函数还有函数对象和�c�L��员函敎ͼ��q�些
C的函数指针是无法用的。这要求能适应C++语言的函数指针。既然C++语言本��n没有提供�Q?br>那就提供一个库。stl提供了，但是定义了很多类型，使用��h��q�不是很方便�Q�而且函数参数
的个数被限定在两个以下，更能是备受限制。Boost.Function库提供了一个好的解��x��案�?br>
Boost.Function库可以支持自由函敎ͼ�函数对象�Q�类成员函数。而且参数个数多达10个�?br>Boost.Function库利用模板技术来实现。生成的代码有很高的�q�行效率。本库可以不用编�?br>直接使用�?br>
Boost.Function的头文�g�?br>function.hpp

定义一个Boost.Function的对象（是一个返回值类型�ؓint�Q�第一个参数是std::string�c�d��
�W�二个参数是float�c�L��Q?br>
boost::function< int ( std::string, float ) > funptr;

上面�q�个定义方式是一�U�容易理解的定义方式。但有些�~�译器不支持�Q�如果想更多的编译器
支持�Q�则用下面这�U�定义方�?br>
boost::function2< int, std::string, float > funptr;

注意模板中有3个类型，而function�c�d��是boost::function2。应��回值类型不计算在参�?br>�c�d��中（原因很简单，C++的编译器不会�Ҏ��q�回�c�d��不同来区分函数定义的不同�Q��?br>
int freefun( std::string str, float f )
{
    std::cout << str << " : " << f << std::endl;
    return 0;
}

class CFun
{
public:
    int operator() ( std::string str, float f )
    {
        std::cout << str << " : " << f << std::endl;
        return 0;
    }
}

上面定义了一个自由函数和一个函数对象。下面将把他们付�l�function对象�?br>
赋��gؓ自由函数
funptr = &freefun;

赋��gؓ函数对象
CFun fun;
funptr = fun;

以上两种情况的调用方法一��_��如下
funptr( "float =", 10.0 );

Boost.Function对象要能指向�c�d��原函敎ͼ�其定义要如下

class FreeClass
{
public:
    int out( std::string str, float f )
    {
        std::cout << str << " : " << f << std::endl;
        return 0;
    }
};

boost::function< int ( FreeClass*, std::string, float ) > funptr;

跨��^台的定义�Ҏ��
boost::function3< int, FreeClass*, std::string, float > funptr;

赋值方�?br>funptr = &FreeClass::out;

调用�Ҏ��
FreeClass fc;

funptr( &fc, "float =", 10.0 );

walkspeed 2007-07-18 13:28 发表评论

Signal中用来管理slot的管理器

walkspeed — Wed, 25 Apr 2007 07:18:00 GMT

Signal会安优先�U�的不同来调用不同组�?/span>slot。这栯��?/span>signal能根据不同的优先�U�来��理slot�l�。典型的实现�Ҏ��是用std::map。将其定义�ؓ如下形式std::map< int, slot >。由于每个优先��下可能有一�l?/span>slot�Q�所以要��这一�l?/span>slot�l�织��C��L��理，�?/span>boost signal中��?/span>std::list来管理，其可能的形式大体如下std::list< slot >。这样就要修改刚才定义的map了，修改后的map可能的定义如�?/span>std::map< int, std::list< slot > >�?/span>

在实际的boost signal中�ƈ没有直接的存�?/span>slot�Q?/span>boost signal库中有个slot�c�）�Q�而是存储�?/span>function�Q?/span>boost function�cȝ��对象�Q�对象。而且��Z��方便控制signal�?/span>function之间的联�p�，引入�?/span>connection�c�，用来表示signal�?/span>function之间的联�p�R�?/span>Connection的对象当然和一�?/span>function攑֜�了一赗��这�?/span>boost signal提供了一�?/span>connection_slot_pair�c�L��存储一�?/span>function�?/span>connection寏V��这样在boost signal中一�?/span>slot�l�的实际定义如下std::list< connection_slot_pair >。�ƈ且被重定义�ؓgroup_list�c�d��Q?/span>typedef std::list group_list�Q�。相应的�?/span>boost signal�?/span>map的实际定义如�?/span>std::map�Q��ƈ且被重定义�ؓslot_container_type�Q?/span>typedef std::map slot_container_type�Q�。将以上的这些东西组�l�到一个类中，以便于管理。这个类��是named_slot_map�?/span>Signal中真正用来管�?/span>slot的管理器�?/span>

Named_slot_map的类数据成员如下定义�Q?/span>boost源码中的一部分�Q�数据成员部分）

class BOOST_SIGNALS_DECL named_slot_map

{

public:

typedef named_slot_map_iterator iterator;//named_slot_map容器的�P代器

private:

typedef std::list group_list;//function connection对组�c�d��

typedef std::map slot_container_type;//容器�c�d��

typedef slot_container_type::iterator group_iterator;//容器�q�代器类�?/span>

typedef slot_container_type::const_iterator const_group_iterator;

slot_container_type groups;//定义一个用来管�?/span>function connection�l�的容器对象

group_iterator back;//容器的�P代器对象

};

Named_slot_map也是一个容器�?/span>Stl的容器�ؓ了外界方便访问容器内数据单元�Q�提供了�q�代器�?/span>Named_slot_map也有自己的�P代器。这个�P代器��是named_slot_map_iterator�c�R�?/span>Named_slot_map提供了以下方法来获得�q�代�?/span>iterator begin()�Q?/span>iterator end()�?/span>Begin�Ҏ��提供首�P代器�Q?/span>end�Ҏ��提供��P代器。向容器中插入数据用insert。清除某个数据用而而然erase�Q�清�I�容器中的所有数据用clear�?/span>

walkspeed 2007-04-25 15:18 发表评论

由signal的一些东西联惛_��了AM

walkspeed — Tue, 24 Apr 2007 11:36:00 GMT

　　敏捷开发中提倡依赖关�p�d��置�Q�即�Q�依赖接口而非具体�c�，�Q��用接口的对象定义接口�?br>　　boost signal中的signal的模板参数是个函数类型。可以将其看成一个接口。signal对象依赖�q�个接口�Q�而且是有signal定义的。具体类��d��现镇��歌接口�Q�即实现�q�个函数�c�d��Q?br>　　signal和slot框架�l�成了一个observer模式的实现。signal是出版者，slot是订阅�?

walkspeed 2007-04-24 19:36 发表评论

walkspeed — Mon, 23 Apr 2007 08:57:00 GMT

　　本以为slot��是被signal存储�q�管理的slot。但是通过解读boost的源代码发现�q�个�c�dƈ没有被signal直接��理�Q�而仅仅用来构造了下connection。没有发现其他的用途。如果这��P��那�ؓ何不直接在signal的connect中直接进行connection的构造呢�?br>　　signal的connect函数没有直接接收function对象�Q�而是接收的slot<>对象�Q�而slot<>对象用来接收function。这个function看来未必一定是个函数对象了。可以是个原始函数或�c�d��C��?�q�个猜测要证实了才能��定。即便如此，�q�个�cȝ��作用是有限的。不�q�关于那个tackeable的用法还没有完全高清楚，可能那是�q�个�c�d��在的理由�Q�也�总�后会有什么的发展。但现在��实看不��Z��么大的用途�?br>　　奇怪于��Z��在signal中的slot��理器，不去直接��理slot<>的实例，而是��理connection和function的pair�?/p>

　　个�h觉得在slot<>中的最有用处的函数�?br>void slot_base::create_connection()
{
basic_connection* con = new basic_connection();

{
  con->signal = static_cast(this);
  con->signal_data = 0;
  con->blocked_ = false ;
  con->signal_disconnect = &bound_object_destructed;
}

data->watch_bound_objects.reset(con);

scoped_connection safe_connection(data->watch_bound_objects);

for(std::vector::iterator i = data->bound_objects.begin();
  i != data->bound_objects.end(); ++i)
{
  BOOST_SIGNALS_NAMESPACE::detail::bound_object binding;
  (*i)->signal_connected(data->watch_bound_objects, binding);

BOOST_SIGNALS_NAMESPACE::detail::auto_disconnect_bound_object disconnector(binding);

con->bound_objects.push_back(binding);
disconnector.release();
}

safe_connection.release();
data->watch_bound_objects.set_controlling(true);
}

walkspeed 2007-04-23 16:57 发表评论

walkspeed — Sat, 07 Apr 2007 08:20:00 GMT

�q�是我在看boost MPL时试着��译的东西，现在贴上来�?br>
A metafunction is a class or a class template that represents a function invocable at compile-time.
一个原操作是在�~�译器表��C��调用操作的一个类或一个模板类�?/p>

An non-nullary metafunction is invoked by instantiating the class template with particular template parameters (metafunction arguments);
一个非无参的原操作被一个有详细模板参数的模板类��h��Q?br>the result of the metafunction application is accessible through the instantiation's nested type typedef.
原操作应用的�q�回值是一个通过模板�c�d��例可取的内嵌的类型定义�?/p>

All metafunction's arguments must be types (i.e. only type template parameters are allowed).
所有的原操作的参数必须是类型�?/p>

A metafunction can have a variable number of parameters.
一个原操作能有一个数量变化的参数

A nullary metafunction is represented as a (template) class with a nested type typename member.
一个无参数原操作被表现为有内嵌重命名类型的�c?/p>

原操作的三种表达式（f是一个原操作�Q?br>1 f::type
2 f<>::type
3 f< a1,..,an >::type

Lambda Expression 构造和分配表达�?/p>

A Lambda Expression is a compile-time invocable entity in either of the following two forms:
一个构造和分配表达式是下面两个中的一个编译期调用单元

Metafunction Class
原操作类

Placeholder Expression
站位�W�表辑ּ�

Most of the MPL components accept either of those, and the concept gives us a consice way to describe these requirements.
大部分的MPL�l��g接收它们其中一个，

walkspeed 2007-04-07 16:20 发表评论

用vector来自动生成类

walkspeed — Sat, 07 Apr 2007 08:02:00 GMT

        Modern C++ Design中实��C��一个自动生成类的方法。它用的是Loki中的TypeList。我在这里��用了boost MPL中的vector来作为类型的容器。按boost MPL库的设计理念�Q�其他的�c�d��容器也应该可以利用这里的实现的（没有试过�Q�可能有问题�Q�特别是map�c�d��容器�Q?br>
        实现如下�Q�注�Q�我已将boost的头文�g攑ֈ�了vc的include目录中）

    #include < boost/mpl/vector.hpp >
    #include < boost/mpl/front.hpp >
    #include < boost/mpl/pop_front.hpp >

    template< typename Type >
    struct Holder
    {
        Type value_;
    };

    template< typename TypeSequeue, template< typename > class Unit >
    struct TypeConstract : public Unit< typename boost::mpl::front< TypeSequeue >::type >,
                           public TypeConstract< typename boost::mpl::pop_front< TypeSequeue >::type,
                                                 Unit >
    {
    };

    template< template< typename > class Unit >
    struct TypeConstract< boost::mpl::vector<>::type, Unit >
    {
    };

walkspeed 2007-04-07 16:02 发表评论

boost库中mpl中的Data_Types

walkspeed — Sat, 10 Mar 2007 06:10:00 GMT

    boost库中MPL部分提供了Data_Types。其中提供了�Ҏ��字类型的一个wrapper
    有一下这么几个，都在boost::mpl名字�I�间�?br />
    bool_ 是一个bool型的帔R��wrapper�Q�头文�g #include< boost/mpl/bool.hpp >
    int_ 是一个int型的帔R��wrapper�Q�头文�g #include< boost/mpl/int.hpp >
    long_ 是一个long型的帔R��wrapper�Q�头文�g #include< boost/mpl/long.hpp >
    size_t 是一个std::size_t型的帔R��wrapper�Q�头文�g #include< boost/mpl/size_t.hpp >
    integral_c 提供了对整�Ş的一个通用wrapper�Q�头文�g #include< boost/mpl/integral_c.hpp >

    �q�些帔R��提供了如下的能力�Q�假设一个常量类�?n �Q?br />    获得帔R��c�d��包含的类�?n::value_type
    获得帔R��c�d��的类型   �?n::type
    获得帔R��c�d��的值     �?n::value
    �q�回帔R��c�d��的值     �?n()

    bool_部分

    bool_的声明如�?br />
    template< bool C >
    struct bool_;

    库中定义了两个常用的bool型常量，true_和false_。定义分别如�?br />    typedef bool_< true > true_;
    typedef bool_< false > false_;

    bool_�Ҏ��如�?br />    bool_< true >::value_type == bool
    bool_< true >::type == bool< true >
    bool_< true >::value == true
    bool_< true >() == true

    int_部分

    int_的声明如�?br />
    template< int N >
    struct int_;

    int_�Ҏ��如�?br />    int_< 10 >::value_type == int;
    int_< 10 >::type == int_< 10 >;
    int_< 10 >::value == 10;
    int_< 10 >() == 10;

    long_部分

    long_的声明如�?br />
    template< long N >
    struct long_;

    long_�Ҏ��如�?br />    long_< -500 >::value_type == long;
    long_< -500 >::type == long_< -500 >;
    long_< -500 >::value == -500;
    long_< -500 >() == -500;

    size_t部分

    size_t的声明如�?br />
    template< std::size_t N >
    struct size_t;

    size_t的特性如�?br />    size_t< 20 >::value_type == std::size_t;
    size_t< 20 >::type == size_t< 20 >;
    size_t< 20 >::value == 20;
    size_t< 20 >() == 20;

    integral_c部分

    integral_c的声明如�?br />    template< typename T, T N >
    struct integral_c;

    integral_c的特性如�?br />    integral_c< short, 8 >::value_type == short;
    integral_c< short, 8 >::type == integral_c< short, 8 >;
    integral_c< short, 8 >::value == 8;
    integral_c< short, 8 >() == 8;

walkspeed 2007-03-10 14:10 发表评论