STL杂记(3)

现在的位置: 首页 > 综合 > 正文

2012年08月27日 ⁄ 综合 ⁄ 共 5230字 ⁄ 字号小中大 ⁄ 评论关闭

1.模板的友员函数

template <typename T> 
class Creator { 
    friend void feed(Creator<T>*){  // every T generates a different  
                                    // function ::feed()  
        std::cout << "feed(Createor<" << typeid(T).name() << ">*)/n";
    } 
}; 

每个特例化Creator都会生成一个普通的feed函数，这样友员函数的使用也会引用模板的instantiate(实例化)

    Creator<void> c1;
    feed(&c1);
    Creator<double> c2;
    feed(&c2);

2.ADL

argument-dependent lookup (ADL)

特殊的名字搜索机制，注意如果名字有了修饰符则这一机制不会被启用

template <typename T> 
inline T const& max (T const& a, T const& b) 
{ 
    return a < b ? b : a; 
} 
namespace BigMath { 
    class BigNumber { 
    }; 
    bool operator < (BigNumber const&, BigNumber const&); 
} 
using BigMath::BigNumber; 
void g (BigNumber const& a, BigNumber const& b) 
{ 
    BigNumber x = max(a,b); 
} 

如果没有ADL,那么BigNumber x=max(a,b);将失败,因为max不知道BigMath这个名字空间

3.ADL更多名字线索

Otherwise, if the name is followed by a list of argument expressions enclosed in parentheses, ADL proceeds by looking up the name in namespaces and classes "associated with" the types of the call arguments.

class _Clsordinary
{
public:
    friend void notfound()
    { std::cout << "not be found/n"; }
    friend void ff(_Clsordinary& o)
    {
        std::cout << "with _Clsordinary, can be find/n";
    }
};

参数与被包括的搜索范围的关系

The precise definition of the set of associated namespaces and associated classes for a given type is determined by the following rules:

For built-in types, this is the empty set.
For pointer and array types, the set of associated namespaces and classes is that of the underlying type.
For enumeration types, the associated namespace is the namespace in which the enumeration is declared. For class members, the enclosing class is the associated class.
For class types (including union types) the set of associated classes is the type itself, the enclosing class, and any direct and indirect base classes. The set of associated namespaces is the namespaces in which the associated classes are declared. If the class is a class template instantiation, then the types of the template type arguments and the classes and namespaces in which the template template arguments are declared are also included.
For function types, the sets of associated namespaces and classes comprise the namespaces and classes associated with all the parameter types and those associated with the return type.
For pointer-to-member-of-class-X types, the sets of associated namespaces and classes include those associated with X in addition to those associated with the type of the member. (If it is a pointer-to-member-function type, then the parameter and return types can contribute too.)
2. #include <iostream>
4. namespace X {
5. template<typename T> void f(T);
6. }
8. namespace N {
9. using namespace X;
10. enumE{e1};
11. void f(E) {
12. std::cout << "N::f(N::E) called/n";
13. }
14. }
16. void f(int)
17. {
18. std::cout << "::f(int) called/n";
19. }
21. int main()
22. {
23. ::f(N::e1); // qualified function name: no ADL
24. f(N::e1); // ordinary lookup finds ::f() and ADL finds N::f(),
25. } // the latter is preferred

4.模板类内部的类名字

模板类中类名字可以在不带模板参数列表情况下做为类型名字使用，但它不会被认为是一个模板。我们可以在它前面加修改符::，让它不再是一个内部类型。

template<template<typename> class TT> class X { 
}; 
template<typename T> class C { 
   Ca;        // OK: same as ''C<T> a;''  
   C<void> b; // OK  
   X<C> c;    // ERROR: C without a template argument list  
              //        does not denote a template  
   X<::C> d;  // ERROR: <: is an alternative token for [  
   X< ::C> e; // OK: the space between < and :: is required  
} 

这里有个题外问题就是<:会被做成一个替换token看待，需要在它们之间加入空白符加以区分。

5.模板名字的组成

template<typename1 T> 
struct S: typename2 X<T>::Base { 
    S(): typename3 X<T>::Base(typename4 X<T>::Base(0)) {} 
    typename5 X<T> f() { 
        typename6 X<T>::C * p;  // declaration of pointer p  
        X<T>::D * q;            // multiplication!  
    } 
    typename7 X<int>::C * s; 
}; 
struct U { 
    typename8 X<int>::C * pc; 
}; 

6.ADL的蛋与鸡的问题

namespace N { 
    class X { 
    }; 
    template<int I> void select(X*); 
} 
void g (N::X* xp) 
{ 
    select<3>(xp);  // ERROR: no ADL!  
}

这也是模板名字的组成所造成的，名字由需要多个成分来确定。

要让ADL起作用，前提是xp必须被解释成一个函数的参数，而要使用select<3>()被解释为一个函数调用，必须知道select是一个模板，而这必须是ADL起作用的情况下，根据xp的类型来确定的。

7.模板参数的地位

在存在非参数依赖的类型的情况下，类型声明优先选择父类的类型声明

template<typename X> 
class Base { 
  public: 
    int basefield; 
    typedef int T; 
}; 
class D1: public Base<Base<void> > {  // not a template case really  
  public: 
    void f() { basefield = 3; }       // usual access to inherited member  
}; 
template<typename T> 
class D2 : public Base<double> {      // nondependent base  
  public: 
    void f() { basefield = 7; }       // usual access to inherited member  
    T strange;        // T is Base<double>::T, not the template parameter!  
}; 

8.参数依赖问题的解决办法

template<typename T> 
class DD : public Base<T> {      // dependent base  
  public: 
    void f() { basefield = 0; }  // (1) problem…  
}; 
template<>  // explicit specialization  
class Base<bool> { 
  public: 
    enum { basefield = 42 };    // (2) tricky!  
}; 
void g (DD<bool>& d) 
{ 
    d.f();                      // (3) oops?  
} 

使用延迟搜索或者添加修饰符::，或者使用引入using

// Variation 1:  
template<typename T> 
class DD1 : public Base<T> { 
  public: 
    void f() { this->basefield = 0; }  // lookup delayed  
}; 
// Variation 2:  
template<typename T> 
class DD2 : public Base<T> { 
  public: 
    void f() { Base<T>::basefield = 0; } 
};
// Variation 3:  
template<typename T> 
class DD3 : public Base<T> { 
  public: 
    using Base<T>::basefield;    // (1) dependent name now in scope  
    void f() { basefield = 0; }  // (2) fine  
}; 

【上篇】在Asp.Net2.0上出现未声明”siteMapFile”属性未设置的问题,请教有识之士!
【下篇】C# 调用外部dll

作者: cypher

该日志由 cypher 于12年前发表在综合分类下，最后更新于 2012年08月27日.
转载请注明: STL杂记(3) | 学步园 +复制链接

抱歉!评论已关闭.

学步园

STL杂记(3)

作者: cypher

书签

最新文章New

本站推荐

返回首页