欧美大香线蕉线伊人久久国产精品,欧美一区免费视频,欧美日韩一区在线观看视频

Mon, 25 Sep 2006 02:38:00 GMT

动态多态通过�l�承+虚函数实玎ͼ�静态多态通过模版实现�?br />动态多态看上去很自然清晎ͼ�除此之外怕是没有别的好处。这也是��Z��么stl、boost��Z��语法高手所亲眯的原因。说实话�l�常一看到模版都打��h��Q�要是模版参��C��多，理清之间关系��得化很多时间。不�q�某些地方，使用模版来实��C��些底层功能能辑ֈ�意想不到的效果�?br />静态多态的好处�Q?br />1、可以多态成员变�?自创的说法哦^_^)
2、避免虚指针的内存损耗以及虚函数调用�q�行效率损�?br />�~�点�Q?br />1、因为编译时会加入类型的��定�Q�代码尺�怼��E�稍大一�?br />2、无法对多态对象统一处理�Q�多态性稍有折�?br />
MFC�c�d��用模版，而WTL�c�d��量��用模版。我在看WTL代码的时候，�l�常被里面的实现所�q�h��Q�因为里面有很多设计采用动态多态和静态多态结合��用，�q�可能是一�U�不错的�l�合。下面我用一�D�代码演�C��些特点，看上��d��q�_��Q?br />

// Virtual && inherit
class Category1
{
public:
    virtual void SayCatName() = 0;
};

class Car1 : public Category1
{
private:
    static string    m_strName;
public:
    virtual void SayCatName()
    {
        cout << m_strName << endl;
    }
};
string Car1::m_strName = "Car1";

class House1 : public Category1
{
private:
    static string    m_strName;
public:
    virtual void SayCatName()
    {
        cout << m_strName << endl;
    }
};
string House1::m_strName = "Hourse1";
// !(Virtual && inherit)

// Template
template<typename T>
class Category2
{
protected:
    static string m_strName;
public:
    virtual void SayCatName()
    {
        T*    pT    = static_cast<T*>(this);
        pT->SayCatName();
    }
};

class Car2 : public Category2<Car2>
{
public:
    virtual void SayCatName()
    {
        cout << m_strName << endl;
    }
};
string Car2::m_strName = "Car2";

class House2 : public Category2<House2>
{
public:
    virtual void SayCatName()
    {
        cout << m_strName << endl;
    }
};
string House2::m_strName = "House2";
// !(Template)

// Virtual && inherit && Template
class CategoryBase
{
public:
    virtual void SayCatName() = 0;
};

template<typename T, typename TBase=CategoryBase>
class CategoryImpl : public TBase
{
protected:
    static string    m_strName;
};

class Car3 : public CategoryImpl<Car3>
{
public:
    virtual void SayCatName()
    {
        cout << m_strName << endl;
    }
};
string Car3::m_strName = "Car3";

class House3 : public CategoryImpl<House3>
{
public:
    virtual void SayCatName()
    {
        cout << m_strName << endl;
    }
};
string House3::m_strName = "House3";
// !(Virtual && inherit && Template)

int _tmain(int argc, _TCHAR* argv[])
{
    // test Virtual && inherit
    Category1*    pCatInstance    = new Car1();
    pCatInstance->SayCatName();
    delete pCatInstance;
    pCatInstance = NULL;
    pCatInstance = new House1();
    pCatInstance->SayCatName();
    delete pCatInstance;
    pCatInstance = NULL;
    // !(test Virtual && inherit)

    // test Template
    Category2<Car2>*    pCar2    = new Car2();
    pCar2->SayCatName();
    delete pCar2;
    pCar2 = NULL;
    Category2<House2>*    pHouse2    = new House2();
    pHouse2->SayCatName();
    delete pHouse2;
    pHouse2 = NULL;
    // !(test Template)

    // test Virtual && inherit && Template
    CategoryBase*    pBase    = new Car3();
    pBase->SayCatName();
    delete pBase;
    pBase = NULL;
    pBase = new House3();
    pBase->SayCatName();
    delete pBase;
    pBase = NULL;
    // !(test Virtual && inherit && Template)
    return 0;
}

里面体现了很多特性，有些例如静态函数的巧妙使用没有演示�?br />
例子完全是本��惛_��来的�Q�没有实际意义，仅从语法上去考虑�?img src ="http://m.shnenglu.com/wlwlxj/aggbug/12936.html" width = "1" height = "1" />

万连�?/a> 2006-09-25 10:38 发表评论

std::string一个极光��晦得问题

Tue, 18 Apr 2006 08:23:00 GMT

昨天做一个dll�Q�代码很快写完了�Q�然而��用得时候��L��遇到string内部指针删除错误�Q�郁闷了一天，今天没去公司�Q�好好研�I�了一下�?br />首先看下下面�q�段代码�Q�声明两个string对象�Q?br />

std:: string s1 = " wlwlxj " ;
std:: string s2 = " lxjwlwww " ;

调试状态下可以看到内部指针�Q?br />s1=0x00364ff9
s2=0x00365061
然后执行

s2 = s1;

按下f11�Q�进入xstring源文�Ӟ��

_Myt & operator = ( const _Myt & _X) // 赋值操作符
{ return (assign(_X)); } // 调用assign函数

�l�箋�q�入assign(_X)函数�Q?/p>

_Myt & assign( const _Myt & _X)
{ return (assign(_X, 0 , npos)); } // 调用assign函数

�l�箋�q�入assign函数�Q�好戏都在这里面�Q?br />

_Myt& assign(const _Myt& _X, size_type _P, size_type _M)
        {if (_X.size() < _P)
            _Xran();
        size_type _N = _X.size() - _P;
        if (_M < _N)
            _N = _M;
        if (this == &_X)
            erase((size_type)(_P + _N)), erase(0, _P);
        else if (0 < _N && _N == _X.size()                        // �q�个分支意思就是如果拷贝源有内容且��是��是源本�w�，�q�且
            && _Refcnt(_X.c_str()) < _FROZEN - 1          // 源字�W�串引用�ơ数��于255-1�ơ（可见引用�ơ数最�?55�ơ）�Q?/span>
            && allocator == _X.allocator)                           //且源字符和目的字�W�分配器一�?br />            {_Tidy(true);                                             // 删除本��n
            _Ptr = (_E *)_X.c_str();                                    // 复制内容到目的串
            _Len = _X.size();
            _Res = _X.capacity();
            ++_Refcnt(_Ptr); }                                             // 增加一�ơ引�?/span>
        else if (_Grow(_N, true))
            {_Tr::copy(_Ptr, &_X.c_str()[_P], _N);
            _Eos(_N); }
        return (*this); }

�q�样�l�果��是调用=号以后，s2地址和s1地址一��P��都是0x00364ff9�?br />
假如我们动态库有这样一个类class DLL接口�Q?/p>

SetString(std::string str)
{
m_str = str;
}

在客戯��用时候：

std::string str = "wlwlxj";
DLL d;
d.SetString(str); // 此时没有深拷贝，而是引用了str内部指针地址

在调用结束的时候，dll内部删除成员变量的时候，会判断m_str内部指针合法性，�׃��实际分配是在调用端，在dll内部自然��查指针非法�?br />
解决�Ҏ��是避免std::string引用计数�Q�接口处修改为SetString(const char*)�Q�这样在dll内部分配内存�Q�内部释放，��׃��会有问题�?img src ="http://m.shnenglu.com/wlwlxj/aggbug/5819.html" width = "1" height = "1" />

万连�?/a> 2006-04-18 16:23 发表评论

C++ Template: The Complete Guide 学习�Q? 模板中的命名

Sat, 08 Apr 2006 03:38:00 GMT

�W?�?模板中的名字
名字在大多数�~�程语言中都是最基本的概念，�E�序员用它来引用先前创徏的对象。当C++�~�译器遇��C��个名字，它要��L��扑�ƈ识别哪个对象被引用。从实现者角度来看，C++在一�U�强�c�d��语言。考虑表达式X*Y�Q�如果X和Y都是变量名，那么是乘法表辑ּ��Q�如果X是类型名�Q�这条语句把Y声明为X�c�d��的一个指针�?br />
�q�个例子表明C++�Q�和C一��P��是上下文敏感的语�a��Q�如果没有上下文�Q�一条程序指令很难被�~�译器理解。这与模板有什么关�p�d��Q�嗯�Q�模板必��d��理更多的上下文：(1)模板内部上下文；(2)模板实例化时的上下文�Q?3)模板实例化时模板参数的上下文。在C++中必��d��心处理名字，�Ҏ��你不应该感到惊讶�?br />
9.1 名字分类�?/strong>
事实上C++的名字分�c�L��很多�U�。�ؓ了便于记忆，我们提供了表�?.1和表�?.2描述了这些分�c�R��幸�q�的是你只用熟悉下面2�U�主要的命名概念�Q�就可以很好的理解C++模板中遇到的问题�Q?br />
1、限定名�Q�名字在作用域中被显式指�C�Z��用域解析�q�算�W?::)或者成员访问运��符(.或�?font face="Courier New">->)。例如：this->count是限定名�Q�而count不是�Q�尽��count有可能是某个�cȝ��成员�Q��?br />2、依赖名�Q�名字依赖于模板参数。例如：std::vector::iterator�Q�如果T是模板参敎ͼ�iterator��是依赖名；如果T是已知类型（比如int�Q�，iterator��是非依赖名�?br />
表格 9.1. 名字分类�?(�W�一部分)
分类
注释
标识�W?/p>
由字�W�、下划线(_)和数字组成的名字�Q�不能以数字开头。有一些标识符是保留的�Q�你不能在自��q��序中引入它们(一�U�避免引入的�W�方法是以_或者__作�ؓ前缀)。字�W�的概念很广泛，包括寚w��字母语言�~�码的特�D�字�W��?/p>
操作�W�类
关键字operator 后面跟着一个符受��例如operator new和operator []。很多操作符都是多义的，例如operator &可以是按位与�q�算�Q�也可以是取地址�q�算�?/p>
转换�c?/p>
指示用户定义的隐式类型�{换。例如operator int&�Q�我们可以把它�{换成int�c�d��的位与操�?/p>
模板�c?/p>
template后面跟着<>�Q�里面是模板参数。例如List(严格�Ԍ��C++标准只允许简单的标识�W��ؓ模板名，或许有争议说操作�W�类也是允许的；例如�Q�operator+ >)�?/p>
非限定类
更一般的标识�W�。可以是上面几类(标识�W�、操作符�c�R��{换类或模板类)或者是析构�?例如�Q�像~Data �?~List之类�?/tt>�W�号)�?/font>
限定�c?/p>
非限定类前面加上�c�L��者名字空间限定，或者全局作用域解析运��符。注意一个名字本�w�可以是限定的，例如::X, S::x, Array::y, and ::N::A::z�?/tt>
限定�?/p>
�q�个名词在标准中是没有的�Q�我们用它来表示执行限定查找的名字。特定情况下�Q�就是限定标识或者在非限定标识前面显式��用成员访问运��符(. 或�?->)。例如S::x, this->f, �?p->A::m。然而，除了class_mem 和this->class_mem在上下文环境中是�{�同的情况下不需要限定名�Q�其他情况下必须昑ּ�使用成员讉K��q�算�W��?/tt>
非限定名
非限定标识不是非限定名。这也不是一个标准中的术语，但是相当于执行非限定查找中的名字�?/p>

表格 9.2. 名字分类�?(�W�二部分)
分类
注释
名字
限定或者非限定的名字�?/p>
依赖�?/p>
名字依赖于模板参数。�Q何含有模板参数的限定或者非限定名字都是依赖名。此外，成员讉K��操作�W?.�?tt>->) 修饰的限定名 �Q�如果操作符左边的表辑ּ��c�d��依赖于模板参敎ͼ�那么�q�个限定名是依赖的。尤其这�U�情况：this->b中的b在模板中便是依赖名。最后，ident(x, y, z)调用形式中的ident当且仅当参数表达式中有类型依赖于模板参数�?/font>
非依赖名
不符合上面描�q�的名字��׃��是依赖名�?/p>

上面�q�些名词通常用来描述C++模板中的问题�Q�通读一�Ҏ��很有用的�Q�我们可以熟悉这些名词，但没有必要记住每个名词确切的意思。需要的时候，我们可以通过索引很容易的查阅�?img src ="http://m.shnenglu.com/wlwlxj/aggbug/5169.html" width = "1" height = "1" />

万连�?/a> 2006-04-08 11:38 发表评论

表格 9.1. 名字分类�?(�W�一部分)
分类	注释
标识�W?/p>	由字�W�、下划线(_)和数字组成的名字�Q�不能以数字开头。有一些标识符是保留的�Q�你不能在自��q��序中引入它们(一�U�避免引入的�W�方法是以_或者__作�ؓ前缀)。字�W�的概念很广泛，包括寚w��字母语言�~�码的特�D�字�W��?/p>
操作�W�类	关键字operator 后面跟着一个符受��例如operator new和operator []。很多操作符都是多义的，例如operator &可以是按位与�q�算�Q�也可以是取地址�q�算�?/p>
转换�c?/p>	指示用户定义的隐式类型�{换。例如operator int&�Q�我们可以把它�{换成int�c�d��的位与操�?/p>
模板�c?/p>	template后面跟着<>�Q�里面是模板参数。例如List(严格�Ԍ��C++标准只允许简单的标识�W��ؓ模板名，或许有争议说操作�W�类也是允许的；例如�Q�operator+ >)�?/p>
非限定类	更一般的标识�W�。可以是上面几类(标识�W�、操作符�c�R��{换类或模板类)或者是析构�?例如�Q�像~Data �?`~List之类�?/tt>�W�号)�?/font>`
限定�c?/p>	非限定类前面加上�c�L��者名字空间限定，或者全局作用域解析运��符。注意一个名字本�w�可以是限定的，例如::X, `S::x`, `Array::y`, and `::N::A::z�?/tt>`
限定�?/p>	�q�个名词在标准中是没有的�Q�我们用它来表示执行限定查找的名字。特定情况下�Q�就是限定标识或者在非限定标识前面显式��用成员访问运��符(`.` 或�?`->`)。例如S::x, `this->f`, �?`p->A::m。然而，除了class_mem 和this->class_mem在上下文环境中是�{�同的情况下不需要限定名�Q�其他情况下必须昑ּ�使用成员讉K��q�算�W��?/tt>`
非限定名	非限定标识不是非限定名。这也不是一个标准中的术语，但是相当于执行非限定查找中的名字�?/p>

表格 9.2. 名字分类�?(�W�二部分)
分类	注释
名字	限定或者非限定的名字�?/p>
依赖�?/p>	名字依赖于模板参数。�Q何含有模板参数的限定或者非限定名字都是依赖名。此外，成员讉K��操作�W?`.`�?tt>->) 修饰的限定名 �Q�如果操作符左边的表辑ּ��c�d��依赖于模板参敎ͼ�那么�q�个限定名是依赖的。尤其这�U�情况：this->b中的b在模板中便是依赖名。最后，ident(x, y, z)调用形式中的ident当且仅当参数表达式中有类型依赖于模板参数�?/font>
非依赖名	不符合上面描�q�的名字��׃��是依赖名�?/p>

C++ Template: The Complete Guide 学习�Q?.5后记

Fri, 07 Apr 2006 14:24:00 GMT
8.5 后记
�?0�q�代后期引入C++模板�Q�其概念和语法一直保持相对稳定。类模板、函数模板以及类型参数。非�c�d��参数是模板最基础的工兗��?br />
然而，在最初设计的基础上还是添加了一些内容，大部分是C++标准库的需要。成员模板是��d��内容中最基本的。很奇怪，只有成员函数模板被正式纳入C++标准�Q�成员类模板成�ؓ标准的一部分�q�存在争议�?br />
友元模板、缺省模板参数和模板模板参数都是最�q�才��d��q�语�a�中的。声明模板模板参数有时候称作高�U�泛性，它们最初被引入在C++标准库中提供一�U�分配器模型�Q�后来这�U�分配器模型被其它不依赖模板模板参数所替代。由于模板模板参数规��D��明到标准化进�E�后期仍不完善，几乎要被从语�a�中剔除。最�l�由于C++标准委员会大部分成员赞成保留下来�q�完成了规格说明�?img src ="http://m.shnenglu.com/wlwlxj/aggbug/5157.html" width = "1" height = "1" />

万连�?/a> 2006-04-07 22:24 发表评论

C++ Template: The Complete Guide 学习�Q?.4友元

Thu, 06 Apr 2006 15:48:00 GMT
独自一��学模板，实在郁闷�Q�翻译e文��D��自己学习�Q�（全部写完后整理）

8.4 友元
声明友元的思想其实很简单：标识一个类或者函敎ͼ�对于��其声明为友元所在的�c�d��有某�U�特权。但是在以下两个斚w��Q�问题似乎有点复杂：
1、一个友元声明只能是一个实体的唯一声明�Q�注�Q�我�q�没理解�Q�不能解释）
2、友元函数声明的同时可以定义�?br />
友元�c�d��声明的时候不允许定义�Q�所以一般不会有问题。在模板情况下，唯一一点不同就是可以将�c�L��板的一个特定实例声明�ؓ友元�Q?br />
template<typename T>
class Node;

template<typename T>
class Tree{
    friend class Node<T>;
    �?br />};
注意�Q�类模板在被一个类或者类模板声明为友元的时候必��L��可见的，而对于普通的�c�d��没有�q�种需求：
template<typename T>
class Tree{
    friend class Factory;        // OK, even if first declaration of Factory
    friend class class Node<T>;  // ERROR if Node isn't visible
};

8.4.1 友元函数
函数模板的实例可以通过在函数名后面跟一�?lt;>��其声明为友元�?lt;>里面可以包含模板参数�Q�如果编译器可以推导出模板参敎ͼ�可以省略调模板参敎ͼ�
template<typename T1, typename T2>
void combine(T1, T2);

class Mixer{
    friend void combine<>(int&, int&);
    // OK: T1 = int&, T2 = int&
    friend void combine<int, int>(int, int);
    // OK: T1 = int, T2 = int
    friend void combine<char>(char, int);
    // OK: T1 = char T2 = int
    friend void combine<char>(char&, int);
    // ERROR: doesn't match combine() template
    friend void combine<>(long, long) { }
    // ERROR: definition not allowed!
};
�Q�注�Q�在GCC下测试，VS2003不行�Q?br />注意�Q�我们可以对模板�q�行专门化定义，但是不能�Ҏ��板实例进行定义，所以声明模板实例�ؓ友元时不能定义�?br />
如果名字后面跟有<>�Q�有2�U�可能：
1、如果名字没有限定词�Q�也��是前面没有::�Q�，��׃��可能是模板实例。如果在声明友元的地�Ҏ��有非模板函数匚w��的话�Q�就是函数的首次声明�Q�声明同时可以定义�?br />2、如果名字有限定词，那么一定与前面声明的函数或者模板函数有养I��在匹配的时候优先选择非函数模板而不是函数模板，然而在声明的时候是不允许定义的�?br />
下面的例子�ȝ��了各�U�可能性：
void multiply (void*);   // ordinary function

template <typename T>
void multiply(T);        // function template

class Comrades {
    friend void multiply(int) {}
                         // defines a new function ::multiply(int)

    friend void ::multiply(void*);
                         // refers to the ordinary function above;
                         // not to the multiply instance

    friend void ::multiply(int);
                         // refers to an instance of the template

    friend void ::multiply<double*>(double*);
                         // qualified names can also have angle brackets
                         // but a template must be visible.

    friend void ::error() {}
                         // ERROR: a qualified friend cannot be a definition
};

�Q�注�Q�在VS2003和规则复合，GCC上编译完全通过�Q?br />
前面例子我们讨论了一般类�Q�相对于�c�L��板）里面的友元函敎ͼ�遵守的规则同样适用于类模板�Q�但模板参数在确定友元函数的时候会起作用：
template<typename T>
class Node {
    Node<T>* allocate();
};

template<typename T>
class List {
    friend Node<T>* Node<T>::allocate();
};

然而，当友元函数在�c�L��杉K��面声明�ƈ定义的时候会出现有趣的现象，因�ؓ模板里面��M��东西在未实例化之前都只是声明而没有具现。考虑下面的例子：
template<typename T>
class Creator {
    friend void appear() {  // a new function ::appear(), but it doesn't
        …                  �?/span>// exist until Creator is instantiated
    }
};

Creator<void> miracle;  // ::appear() is created at this point
Creator<double> oops;   // ERROR: ::appear() is created a second time!
�q�个例子中模板的两次实例化导致同一函数定义多次�Q�违反了一�ơ定义规则�?br />
所以对于上面的情况�Q�我们必��ȝ��保类模板的模板参数出现在声明�q�定义的友元函数形参里面�Q�除非想��L��多次实例化一个类模板�Q�这好像不太可能�Q�。把�q�个规律�q�用到前面那个例子：
template<typename T>
class Creator {
    friend void feed(Creator<T>*){  // every T generates a different
                                    // function ::feed()
    }
};

Creator<void> one;     // generates ::feed(Creator*)
Creator<double> two;   // generates ::feed(Creator*)
�q�个例子中，Creator每个实例都生成不同的函数。注意这些函数是�c�L��板实例��生的�Q�但函数本��n�q�不是函数模板的实例�Q�而是普通函数�?br />�q�要注意�q�些函数体定义于�c�M��Q�默认是内联的，所以在两个��译单元产生相同的函数是没有问题的。（注：�׃��内联函数��Z��代码替代技术，所以一个函数定义所在的h文�g被多�ơ包含不会有问题�Q�内联函数在�~�译器看来就是一�D�代码。）

8.4.2 友元模板
一般情冉|��们都是把函数模板或者类模板的某一实例声明为友元，但把模板本��n声明为友元有时候也是非常有用的。这��需要所谓的模板友元�Q�例如：
class Manager {
    template<typename T>
    friend class Task;

    template<typename T>
    friend void Schedule<T>::dispatch(Task<T>*);

    template<typename T>
    friend int ticket() {
        return ++Manager::counter;
    }
    static int counter;
};
和普通友元函��C��P��没有限定词且名字后面没有<>的函数模板在声明为友元同时可以定义�?br />声明原始函数模板或者原始类模板为友元的时候，所有相关的偏特化以及显�C�特例化都自动成为友元�?br />�Q�注�Q�测试代�?br />
class Manager {
    template<typename T>    // firend template
    friend class Task;
private:
    int    _dat;
};

template<typename T>
class Task {
};

template<>
class Task<int> {            // specialization
public:
    void accessData()
    {
        _manager._dat = 0;    // can access Manager's private data
    }
private:
    Manager    _manager;
};

�Q?br />(本节完，�?..... 自己收获不小)

万连�?/a> 2006-04-06 23:48 发表评论

Wed, 05 Apr 2006 15:24:00 GMT
不谈适用性，�U��a语法上实玎ͼ�我自己无能�ؓ力�?br />
template<typename T, template<T a> class T2>
class TmTm
{
};

万连�?/a> 2006-04-05 23:24 发表评论

Wed, 05 Apr 2006 14:26:00 GMT

研究Boost前，��x��入了解一下模板技术，找来一本书《C++ Template:The Complete Guide》研�I��?br />里面有这样一个小技巧，判断一个类中是否有某种�c�dŞ。下面是代码�Q?Win 2K+ VS2003)

#include < iostream >

// �q�回�c�d��,大小分别�?�?
typedef char RT1;
typedef struct
{
     char a[ 2 ];
} RT2;

// 选择�q�个版本��返回char,大小�?
template < typename T > RT1 test(typename T::X const * )
{
     int     dumy     = 0 ;
    dumy ++ ;
}

// 选择�q�个版本��返回char,大小�?
template < typename T > RT2 test()
{
     int     dumy     = 0 ;
    dumy ++ ;
}

// 依靠�~�译器自动选择test函数,然后依据�q�回�c�d��判断是否含有X
template < typename T >
bool type_has_member_type_X()
{
     return ( sizeof (test < T > ( 0 )) == 1 );
}

// 有X�c�d��的类
class HasX
{
public :
     class X
     {
    } ;
} ;

// 无X�c�d��的类
class NonX
{
public :
     class Y
     {
    } ;
} ;

int _tmain( int argc, _TCHAR * argv[])
{
     // �~�译器选择重蝲函数�{�略:选择�c�d��最匚w��版本
     // 們֐�于把0转化为常量空指针,所以选择�q�回为RT1版本
     if (type_has_member_type_X < HasX > ())
     {
        std::cout << " Has X " << std::endl;
    }
     else
     {
        std::cout << " Non X " << std::endl;
    }

     // 没有T::X,所以选择�q�回为RT2版本
     if (type_has_member_type_X < NonX > ())
     {
        std::cout << " Has X " << std::endl;
    }
     else
     {
        std::cout << " Non X " << std::endl;
    }
     return 0 ;
}
输出�l�果:
Has X
Non X

万连�?/a> 2006-04-05 22:26 发表评论

Mon, 27 Mar 2006 10:54:00 GMT

模板是一�U�源码复用技�?在某些情况下使用它可以��代码看�v来非�怼��?著名的boost库就是模板发扬的典范.
然而模板也存在弊端,大量使用模板可能��D��代码膨胀.下面介绍一�U�解决的�Ҏ��:

我们首先看一�D�一般代�?

template < typename T >
class Vector
{
public :
     virtual void Say()
     {
         const type_info &     t = typeid(T);
        std::cout << " Vector< " << t.name() << " >::Hello " << std::endl;
    }
} ;

// 特例�?/span>
template <>
class   Vector < void *>
{
public :
     virtual void Say()
     {
        std::cout << " Vector::Hello " << std::endl;
    }
} ;

int _tmain( int argc, _TCHAR * argv[])
{
    Vector < int *>     pIntVec;
    pIntVec.Say();
    Vector < double *>     pDoubleVec;
    pDoubleVec.Say();
     return 0 ;
}

输出:
Vector::Hello
Vector::Hello
从这�?我们可以看出�E�序在运行的�q�程中生产了两分Vector的代�?int*和double*),��管�q�里有特例化,然而类型不匚w��,�~�译器在�~�译�q�程中无法定位到特例化版�?如果�q�个Vector被滥用的�?我想即��是一个中�{�规模的�E�序也可能耗费成兆字节的代码控�?

我们必须��L��一�U�中间桥梁�ɾ~�译器在�~�译�q�程中定位到void*的特例化版本.按照模板选择�{�略,�~�译器��L��选择最特例化的模板,我们可以通过一个中间的模板联系起上面两个版本的模板.下面看一�D�代�?

template < typename T >
class Vector
{
public :
     virtual void Say()
     {
        std::cout << " Vector::Hello " << std::endl;
    }
} ;

// 特例�?/span>
template <>
class   Vector < void *>
{
public :
     virtual void Say()
     {
        std::cout << " Vector::Hello " << std::endl;
    }
} ;

// 特例�?/span>
template < typename T >
class Vector < T *> : public Vector < void *>
{
} ;

int _tmain( int argc, _TCHAR * argv[])
{
    Vector < int *>     pIntVec;
    pIntVec.Say();
    Vector < double *>     pDoubleVec;
    pDoubleVec.Say();
     return 0 ;
}

输出:
Vector::Hello
Vector::Hello
从这�?我们可以看出�E�序在运行过�E�中全部使用Vector的版�?class Vector模板便是关键的环�?�~�译器在�~�译�q�程�?�׃��class Vector比class Vector更特例化,所以遇到Vector和Vector旉��选择class Vector,而class Vector�l�承Vector,一个更加特例化版本,所以编译器不再产生新的模板而采用Vector�q�个最特例化版�?�q�样所有指针模杉K��归结到Vector,而class Vector为用��h��供了一个精��而且安全的界�?而Vector作�ؓ底层实现�l�节被隐�?

以上代码在VC 7.1(VS2003)中编译通过,�׃��VC6�Ҏ��板支持不�?所以模板的高��用法一般不要在VC6中��?
下蝲演示代码

万连�?/a> 2006-03-27 18:54 发表评论

欧美大香线蕉线伊人久久国产精品,欧美一区免费视频,欧美日韩一区在线观看视频

std::string一个极光���晦得问题

C++ Template: The Complete Guide 学习�Q? 模板中的命名

表格 9.1. 名字分类�?(�W�一部分)

表格 9.2. 名字分类�?(�W�二部分)

C++ Template: The Complete Guide 学习�Q?.5后记

C++ Template: The Complete Guide 学习�Q?.4友元

std::string一个极光��晦得问题