C++博客-万星星-随笔分类-模板

动态多态与静态多态

万连文 — Mon, 25 Sep 2006 02:38:00 GMT

动态多态通过继承+虚函数实现，静态多态通过模版实现。
动态多态看上去很自然清晰，除此之外怕是没有别的好处。这也是为什么stl、boost为一群语法高手所亲眯的原因。说实话经常一看到模版都打冷战，要是模版参数一多，理清之间关系就得化很多时间。不过某些地方，使用模版来实现一些底层功能能达到意想不到的效果。
静态多态的好处：
1、可以多态成员变量(自创的说法哦^_^)
2、避免虚指针的内存损耗以及虚函数调用运行效率损耗
缺点：
1、因为编译时会加入类型的确定，代码尺寸会稍稍大一点
2、无法对多态对象统一处理，多态性稍有折扣

MFC类很少使用模版，而WTL类大量使用模版。我在看WTL代码的时候，经常被里面的实现所迷惑，因为里面有很多设计采用动态多态和静态多态结合使用，这可能是一种不错的结合。下面我用一段代码演示这些特点，看上去很平常：

// 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;
}

里面体现了很多特性，有些例如静态函数的巧妙使用没有演示。

例子完全是本人臆想出来的，没有实际意义，仅从语法上去考虑。

万连文 2006-09-25 10:38 发表评论

std::string一个极其隐晦得问题

万连文 — Tue, 18 Apr 2006 08:23:00 GMT

昨天做一个dll，代码很快写完了，然而使用得时候总是遇到string内部指针删除错误，郁闷了一天，今天没去公司，好好研究了一下。
首先看下下面这段代码，声明两个string对象：

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

调试状态下可以看到内部指针：
s1=0x00364ff9
s2=0x00365061
然后执行

s2 = s1;

按下f11，进入xstring源文件：

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

继续进入assign(_X)函数：

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

继续进入assign函数，好戏都在这里面：

_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()                        // 这个分支意思就是如果拷贝源有内容且就是就是源本身，并且
            && _Refcnt(_X.c_str()) < _FROZEN - 1          // 源字符串引用次数少于255-1次（可见引用次数最多255次），
            && allocator == _X.allocator)                           //且源字符和目的字符分配器一致
            {_Tidy(true);                                             // 删除本身
            _Ptr = (_E *)_X.c_str();                                    // 复制内容到目的串
            _Len = _X.size();
            _Res = _X.capacity();
            ++_Refcnt(_Ptr); }                                             // 增加一次引用
        else if (_Grow(_N, true))
            {_Tr::copy(_Ptr, &_X.c_str()[_P], _N);
            _Eos(_N); }
        return (*this); }

这样结果就是调用=号以后，s2地址和s1地址一样，都是0x00364ff9。

假如我们动态库有这样一个类class DLL接口：

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

在客户调用时候：

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

在调用结束的时候，dll内部删除成员变量的时候，会判断m_str内部指针合法性，由于实际分配是在调用端，在dll内部自然检查指针非法。

解决方法就是避免std::string引用计数，接口处修改为SetString(const char*)，这样在dll内部分配内存，内部释放，就不会有问题。

万连文 2006-04-18 16:23 发表评论

C++ Template: The Complete Guide 学习－9 模板中的命名

万连文 — Sat, 08 Apr 2006 03:38:00 GMT

第9章模板中的名字
名字在大多数编程语言中都是最基本的概念，程序员用它来引用先前创建的对象。当C++编译器遇到一个名字，它要去查找并识别哪个对象被引用。从实现者角度来看，C++在一种强类型语言。考虑表达式X*Y：如果X和Y都是变量名，那么是乘法表达式；如果X是类型名，这条语句把Y声明为X类型的一个指针。

这个例子表明C++（和C一样）是上下文敏感的语言：如果没有上下文，一条程序指令很难被编译器理解。这与模板有什么关系呢？嗯，模板必须处理更多的上下文：(1)模板内部上下文；(2)模板实例化时的上下文；(3)模板实例化时模板参数的上下文。在C++中必须小心处理名字，对此你不应该感到惊讶。

9.1 名字分类学
事实上C++的名字分类有很多种。为了便于记忆，我们提供了表格9.1和表格9.2描述了这些分类。幸运的是你只用熟悉下面2种主要的命名概念，就可以很好的理解C++模板中遇到的问题：

1、限定名：名字在作用域中被显式指示作用域解析运算符(::)或者成员访问运算符(.或者->)。例如：this->count是限定名，而count不是（尽管count有可能是某个类的成员）。
2、依赖名：名字依赖于模板参数。例如：std::vector::iterator，如果T是模板参数，iterator就是依赖名；如果T是已知类型（比如int），iterator就是非依赖名。

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

表格 9.2. 名字分类学 (第二部分)
分类	注释
名字	限定或者非限定的名字。
依赖名	名字依赖于模板参数。任何含有模板参数的限定或者非限定名字都是依赖名。此外，成员访问操作符(`.`或`->`) 修饰的限定名，如果操作符左边的表达式类型依赖于模板参数，那么这个限定名是依赖的。尤其这种情况：this->b中的b在模板中便是依赖名。最后，ident(x, y, z)调用形式中的ident当且仅当参数表达式中有类型依赖于模板参数。
非依赖名	不符合上面描述的名字就不是依赖名。

上面这些名词通常用来描述C++模板中的问题，通读一边是很有用的，我们可以熟悉这些名词，但没有必要记住每个名词确切的意思。需要的时候，我们可以通过索引很容易的查阅。

万连文 2006-04-08 11:38 发表评论

C++ Template: The Complete Guide 学习－8.5后记

万连文 — Fri, 07 Apr 2006 14:24:00 GMT

8.5 后记
自80年代后期引入C++模板，其概念和语法一直保持相对稳定。类模板、函数模板以及类型参数。非类型参数是模板最基础的工具。

然而，在最初设计的基础上还是添加了一些内容，大部分是C++标准库的需要。成员模板是添加内容中最基本的。很奇怪，只有成员函数模板被正式纳入C++标准，成员类模板成为标准的一部分还存在争议。

友元模板、缺省模板参数和模板模板参数都是最近才添加进语言中的。声明模板模板参数有时候称作高级泛性，它们最初被引入在C++标准库中提供一种分配器模型，后来这种分配器模型被其它不依赖模板模板参数所替代。由于模板模板参数规格说明到标准化进程后期仍不完善，几乎要被从语言中剔除。最终由于C++标准委员会大部分成员赞成保留下来并完成了规格说明。

万连文 2006-04-07 22:24 发表评论

C++ Template: The Complete Guide 学习－8.4友元

万连文 — Thu, 06 Apr 2006 15:48:00 GMT

独自一人苦学模板，实在郁闷，翻译e文逼迫自己学习：（全部写完后整理）

8.4 友元
声明友元的思想其实很简单：标识一个类或者函数，对于将其声明为友元所在的类具有某种特权。但是在以下两个方面，问题似乎有点复杂：
1、一个友元声明只能是一个实体的唯一声明（注：我还没理解，不能解释）
2、友元函数声明的同时可以定义。

友元类在声明的时候不允许定义，所以一般不会有问题。在模板情况下，唯一一点不同就是可以将类模板的一个特定实例声明为友元：

template<typename T>
class Node;

template<typename T>
class Tree{
friend class Node<T>;
…
};

注意：类模板在被一个类或者类模板声明为友元的时候必须是可见的，而对于普通的类则没有这种需求：

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 友元函数
函数模板的实例可以通过在函数名后面跟一对<>将其声明为友元。<>里面可以包含模板参数，如果编译器可以推导出模板参数，可以省略调模板参数：

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!
};

（注：在GCC下测试，VS2003不行）
注意：我们可以对模板进行专门化定义，但是不能对模板实例进行定义，所以声明模板实例为友元时不能定义。

如果名字后面跟有<>，有2种可能：
1、如果名字没有限定词（也就是前面没有::），就不可能是模板实例。如果在声明友元的地方没有非模板函数匹配的话，就是函数的首次声明，声明同时可以定义。
2、如果名字有限定词，那么一定与前面声明的函数或者模板函数有关，在匹配的时候优先选择非函数模板而不是函数模板，然而在声明的时候是不允许定义的。

下面的例子总结了各种可能性：

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
};

（注：在VS2003和规则复合，GCC上编译完全通过）

前面例子我们讨论了一般类（相对于类模板）里面的友元函数，遵守的规则同样适用于类模板，但模板参数在确定友元函数的时候会起作用：

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

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

然而，当友元函数在类模板里面声明并定义的时候会出现有趣的现象，因为模板里面任何东西在未实例化之前都只是声明而没有具现。考虑下面的例子：

template<typename T>
class Creator {
    friend void appear() {  // a new function ::appear(), but it doesn't
        …                   // exist until Creator is instantiated
    }
};

Creator<void> miracle;  // ::appear() is created at this point
Creator<double> oops;   // ERROR: ::appear() is created a second time!

这个例子中模板的两次实例化导致同一函数定义多次，违反了一次定义规则。

所以对于上面的情况，我们必须确保类模板的模板参数出现在声明并定义的友元函数形参里面（除非想阻止多次实例化一个类模板，这好像不太可能）。把这个规律运用到前面那个例子：

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*)

这个例子中，Creator每个实例都生成不同的函数。注意这些函数是类模板实例产生的，但函数本身并不是函数模板的实例，而是普通函数。
还要注意这些函数体定义于类中，默认是内联的，所以在两个翻译单元产生相同的函数是没有问题的。（注：由于内联函数基于代码替代技术，所以一个函数定义所在的h文件被多次包含不会有问题，内联函数在编译器看来就是一段代码。）

8.4.2 友元模板
一般情况我们都是把函数模板或者类模板的某一实例声明为友元，但把模板本身声明为友元有时候也是非常有用的。这就需要所谓的模板友元，例如：

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;
};

和普通友元函数一样，没有限定词且名字后面没有<>的函数模板在声明为友元同时可以定义。
声明原始函数模板或者原始类模板为友元的时候，所有相关的偏特化以及显示特例化都自动成为友元。
（注：测试代码

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;
};

）
(本节完，汗...... 自己收获不小)

万连文 2006-04-06 23:48 发表评论

能生成这个类的一个对象嘛？？？

万连文 — Wed, 05 Apr 2006 15:24:00 GMT

不谈适用性，纯粹语法上实现，我自己无能为力。

template<typename T, template<T a> class T2>
class TmTm
{
};

万连文 2006-04-05 23:24 发表评论

一个模板巧妙技术，语法技巧

万连文 — Wed, 05 Apr 2006 14:26:00 GMT

研究Boost前，想深入了解一下模板技术，找来一本书《C++ Template:The Complete Guide》研究。
里面有这样一个小技巧，判断一个类中是否有某种类形。下面是代码：(Win 2K+ VS2003)

#include < iostream >

// 返回类型,大小分别为1、2
typedef char RT1;
typedef struct
{
     char a[ 2 ];
} RT2;

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

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

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

// 有X类型的类
class HasX
{
public :
     class X
     {
    } ;
} ;

// 无X类型的类
class NonX
{
public :
     class Y
     {
    } ;
} ;

int _tmain( int argc, _TCHAR * argv[])
{
     // 编译器选择重载函数策略:选择类型最匹配版本
     // 倾向于把0转化为常量空指针,所以选择返回为RT1版本
     if (type_has_member_type_X < HasX > ())
     {
        std::cout << " Has X " << std::endl;
    }
     else
     {
        std::cout << " Non X " << std::endl;
    }

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

输出结果:
Has X
Non X

万连文 2006-04-05 22:26 发表评论

抑制模板代码膨胀的一种技术

万连文 — Mon, 27 Mar 2006 10:54:00 GMT

模板是一种源码复用技术,在某些情况下使用它可以使代码看起来非常优雅,著名的boost库就是模板发扬的典范.
然而模板也存在弊端,大量使用模板可能导致代码膨胀.下面介绍一种解决的方案:

我们首先看一段一般代码:

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

// 特例化
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
从这里,我们可以看出程序在运行的过程中生产了两分Vector的代码(int*和double*),尽管这里有特例化,然而类型不匹配,编译器在编译过程中无法定位到特例化版本.如果这个Vector被滥用的化,我想即使是一个中等规模的程序也可能耗费成兆字节的代码控件.

我们必须寻找一种中间桥梁使编译器在编译过程中定位到void*的特例化版本.按照模板选择策略,编译器总是选择最特例化的模板,我们可以通过一个中间的模板联系起上面两个版本的模板.下面看一段代码:

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

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

// 特例化
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
从这里,我们可以看出程序在运行过程中全部使用Vector的版本.class Vector模板便是关键的环节.编译器在编译过程中,由于class Vector比class Vector更特例化,所以遇到Vector和Vector时都选择class Vector,而class Vector继承Vector,一个更加特例化版本,所以编译器不再产生新的模板而采用Vector这个最特例化版本,这样所有指针模板都归结到Vector,而class Vector为用户提供了一个精美而且安全的界面,而Vector作为底层实现细节被隐藏.

以上代码在VC 7.1(VS2003)中编译通过,由于VC6对模板支持不好,所以模板的高级用法一般不要在VC6中使用.
下载演示代码

万连文 2006-03-27 18:54 发表评论