Effective C++笔记（9）—模板与泛型编程（一）

最新推荐文章于 2019-05-16 17:26:35 发布
最新推荐文章于 2019-05-16 17:26:35 发布
阅读量773 收藏 2
点赞数 1
分类专栏： Effective C++ 文章标签： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangxiao93/article/details/76098783
版权

模板内容很丰富，分两次记录吧

条款41：了解隐式接口和编译期多态

对应了显示接口和运行期多态。
下面一个例子说明：

void func(Widget &w)
{
    cout<<w.size()<<endl;
}

func参数类型被声明为Widget，所以w必须支持Widget接口。而Widget类中包含的接口可以在声明Widget的文件中（Widget.h）找到，因此被称为显示接口。Widget的接口可能是一个虚函数或者纯虚函数（取决于子类是否继承父类的默认版本），在运行期将根据w的动态类型决定究竟调用哪一个版本。

模板编程引入了编译器多态和隐式接口的概念，看下面例子：

template <class T>
void func(T &t)
{
    cout << t.size() << endl;
}

该模板函数要求T必须支持size接口，否则在编译器具现化的时候就会报错，比如说：

template <class T>
void func(T &t)
{
    cout << t.size() << endl;
}


class Foo
{

};

int main()
{

//  int a = 5;
//  func<int>(a);//编译期报错C2228 size的左边需要为class/struct/union类型

//  Foo foo;
//  func<Foo>(foo);//编译期报错C2039  size不是Foo的成员


    string s = "hello";
    func(s);//ok 输出5
    system("pause");
    return 0;
}

上面的例子可以看出，传入模板实参需要支持模板函数中所支持的隐式接口，否则将在编译期报错。上述例子中除了string，还可以是vector等STL容器包含size接口，在编译器具现化出不同的func版本，便是所谓的编译期多态。

简单的理解：
编译器多态：哪一个重载函数该被调用
运行期多态：哪一个虚函数将被绑定

当然除此之外，隐式接口需要基于有效的表达式，比如上述例子中，如果某个结构体中包含一个接口size()，但返回类型是一个void，那么在编译器也会有问题，因为<<操作符不接受void类型的右操作数（error C2679）

条款42：了解typename的双重意义

在模板声明的时候可以这样：

template <class T> class Widget;
template <typename T> class Widget;

使用class和typename都是ok的，但是这里要介绍typename另外一个class无法替代的作用。

举个例子：

template <class C>
void print2nd(const C& container)
{
    if (container.size() >= 2)
    {
        C::const_iterator iter(container.begin());
        ++iter;
        C::value_type value= *iter;
        cout << value << endl;
    }
}//打印容器的第二个元素

这里用到了两个嵌套从属类型：
C::const_iterator
C::value_type
这里可能有歧义，虽然我们知道在STL容器中进行了typedef。但C::const_iterator或者C::value_type可能是类型C里面的static成员变量，这样就会造成歧义。合法的C++代码应该加上typename关键字明确这是一个类型名：

template <class C>
void print2nd(const C& container)
{
    if (container.size() >= 2)
    {
        typename C::const_iterator iter(container.begin());
        ++iter;
        typename C::value_type value= *iter;
        cout << value << endl;
    }
}

在嵌套从属类型名前需要加上typename，除了以下情况：

template<class T>
class Derived :public Base<T>::Nested{//1.不允许出现在Base Class List
public：
    explicit Derived(int x): Base<T>::Nested(x){}//2.不允许出现在成员初始化列表中。
    {
        typename Base<T>::Nested tmp;//非上述两种情况需要加typename
    }
};

另外书中给出了最后一个例子，这个例子看过STL源码剖析的应该不陌生：

template <typename iterT>
void func(iterT iter)
{
    typename std::iterator_traits<iterT>::value_type t(*iter);
}

这里用迭代器萃取器获得迭代器所指对象的类型，做为临时变量t的类型。
结合书中的两个例子，上述print2nd也可以这样写：

template <class C>
void print2nd(const C& container)
{
    if (container.size() >= 2)
    {
        typename C::const_iterator iter(container.begin());
        ++iter;
        typedef typename C::const_iterator  const_iterator;
        typedef typename std::iterator_traits<const_iterator>::value_type value_type;
        value_type value(*iter);
        cout << value << endl;
    }
}

条款43：学习处理模板化基类的名称

先来看书上的例子：

class CompanyA
{
public:
    void sendCleartext(const string&msg)
    {
        cout << "A::sendCleartext" << endl << msg << endl;
    }
    void sendEncrypted(const string&msg)
    {
        cout << "A::sendEncrypted" << endl << msg << endl;
    }
};

class CompanyB
{
public:
    void sendCleartext(const string&msg)
    {
        cout << "B::sendCleartext" << endl << msg << endl;
    }
    void sendEncrypted(const string&msg)
    {
        cout << "B::sendEncrypted" << endl << msg << endl;
    }
};
template <class Company>
class MsgSender
{
public:
    void sendClear(const string &msg)
    {
        Company c;
        c.sendCleartext(msg);
    }
};

int main()
{
    //CompanyA a;
    MsgSender<CompanyA> sa;
    sa.sendClear("zhangxiao");//调用A的版本
    MsgSender<CompanyB> sb;
    sb.sendClear("zhangxiao2");//调用B的版本
    system("pause");
    return 0;
}

这是template的解法，当然完全可以用一个Company接口类，然后A和B分别继承这个抽象类，然后在实现虚方法。
不过本条款要说的核心是，模板基类的问题：

class CompanyZ
{
public:
    void sendEncrypted(const string&msg)
    {
        cout << "Z::sendEncrypted" << endl << msg << endl;
    }
};
template <>
class MsgSender < CompanyZ >
{
public:
    void sendClear(const string &msg)
    {
        CompanyZ cz;
        cz.sendCleartext(msg);
    }
};

template <class Company>
class LoggingMsgSender :public MsgSender<Company>
{
public:
    void sendClearMsg(const string &msg)
    {
    //在vs2013并没有出现作者说的编译错误问题！！
        sendClear(msg);
    }
};

int main()
{
    LoggingMsgSender<CompanyA> lms;
    lms.sendClearMsg("zhangxiao");
    system("pause");
    return 0;
}

在之前的基础上，加入了一个CompanyZ的特化版本，并用一个派生类继承了MsgSender。

在vs2013并没有出现作者说的编译错误问题！！

不过可能这是编译器相关，我并没有在gcc下尝试编译，不过作者用了一个词语：对严守规律的编译器而言，无法通过

作者在书中提到，在LoggingMsgSender具现化之前，并不能知道它继承的东西是何物，也就是不知道class MsgSender<Company>看起来像什么，就更不用说知道有个sendClear函数了

更加严谨的做法有三种：

//1.
template <class Company>
class LoggingMsgSender :public MsgSender<Company>
{
public:
    void sendClearMsg(const string &msg)
    {
        this->sendClear(msg);
    }
};
//2.
template <class Company>
class LoggingMsgSender :public MsgSender<Company>
{
public:
    using MsgSender<Company>::sendClear;
    void sendClearMsg(const string &msg)
    {
        sendClear(msg);
    }
};
//3.
template <class Company>
class LoggingMsgSender :public MsgSender<Company>
{
public:
    void sendClearMsg(const string &msg)
    {
        MsgSender<Company>::sendClear(msg);
    }
};

条款44：将参数无关的代码抽离template

两个函数都要调用相同的代码，我们会把相同的的代码放到一个函数中。
两个类中的某些代码重复，你会把共同的部分放到一个新class里面去，然后使用继承、复合等手段重复利用。

编写模板时，我们也希望达到相同的效果，但这并不容易，因为在具现化之前，我们需要预测一下哪些部分是重复的。先看书中的例子：

template <class T,std::size_t n>
class SquareMatrix{
public:
    void invert()
    {
        cout << "invert" << " " << n << endl;
    }
};
int main()
{
    SquareMatrix<int, 5>m1;
    SquareMatrix<int, 10>m2;
    m1.invert();// invert 5
    m2.invert();//invert 10
    system("pause");
    return 0;
}

上述代码通过非类型参数将模板类具象化出两个版本的invert分别表示计算 5×5 和 10×10 的方阵的逆矩阵。

这样template就造成了代码膨胀了，对其进行第一次修改：

template <class T>
class SquareMatrixBase{
protected:
    void invert(std::size_t n)
    {
        cout << "invert" << " " << n << endl;
    }
};
template<class T,std::size_t n>
class SquareMatrix :private SquareMatrixBase < T >
{
public:
    void invert()
    {
        SquareMatrixBase<T>::invert(n);
    }
};

int main()
{
    SquareMatrix<int, 5>m1;
    SquareMatrix<int, 10>m2;
    m1.invert();// invert 5
    m2.invert();//invert 10
    system("pause");
    return 0;
}

这样不同尺寸大小的矩阵只有一个版本的Invert。用一个模板基类去做处理，最后书中给出了这个例子的终极版本，就是解决如何将矩阵数据传给基类：
书中用了boost::scoped_array这是一个管理动态数组的智能指针，我的VS下面没有装boost，就用shared_ptr/unique_ptr来代替了(https://stackoverflow.com/questions/8624146/does-c11-have-wrappers-for-dynamically-allocated-arrays-like-boosts-scoped-ar)。

template <class T>
class SquareMatrixBase{
protected:
    SquareMatrixBase(size_t n_, T* p) :size(n_), pData(p){}//构造函数
    void setDataPtr(T* p){ pData = p; }//set 函数
    void invert()
    {
        cout << "invert" << " " << size << endl;
        for (size_t i = 0; i < size*size; ++i)
            cout << pData[i] << endl;
    }
private:
    std::size_t size;
    T* pData;
};
template<class T,std::size_t n>
class SquareMatrix :private SquareMatrixBase < T >
{
public:
    SquareMatrix() :SquareMatrixBase<T>(n, 0),
        //pData(new T[n*n]{}, std::default_delete<T[]>())//shared_ptr需要deleter
        pData(new T[n*n]{})
    {
        SquareMatrixBase<T>::setDataPtr(pData.get());//传给base
    }
    void invert()
    {
        SquareMatrixBase<T>::invert();
    }
    void SetData(T t[])
    {
        pData.reset(t);
        SquareMatrixBase<T>::setDataPtr(pData.get());//传给base
    }
private:
    //shared_ptr<T>pData;//shared_ptr这里除了需要指定deleter它不重载[]
    unique_ptr<T[]>pData;
};

int main()
{
#if 1
    SquareMatrix<int, 3>m1;
    int *array1 = new int[3 * 3];
    for (int i = 0; i < 9; ++i)
    {
        array1[i] = i + 1;
    }
    m1.SetData(array1);
    m1.invert();// 
#endif

    system("pause");
    return 0;
}

条款45：运用成员函数模板接受所有兼容类型

智能指针方便我们管理内存，原始指针方便做隐式转换，本条款通过实现智能指针的例子来讲述：

class A{};
class B : public A{};
template <class T>
class SmartPtr{
public:
    explicit SmartPtr(T* t){}
};
int main()
{
    A *pa= new B;//ok
    SmartPtr<A>pt1 = SmartPtr<B>(new B);//error
    delete pa;
    system("pause");
    return 0;
}

我们希望智能指针也能做到类之间的隐式转换，事实上，shared_ptr已经实现，不过我们就是要学习如何实现：

shared_ptr<A>pt1 = shared_ptr<B>(new B);//ok
pt1->func();//b::func

这里，我们需要为SmartPtr的构造函数写一个构造模板。即成员模板（member template）

template <class T>
class SmartPtr{
public:
    template <class U>
    SmartPtr(const SmartPtr<U>&other);
};

以上代码的意思是，对任何类型T和任何类型U，这里可以根据SmartPtr生成SmartPtr只要U到T之间存在隐式转换关系。

1.成员函数模板表示泛化的模式，表示生成“可接受所有兼容类型”的函数
2.如果声明了泛化的拷贝构造函数和赋值操作符，那么也要声明正常的拷贝构造函数和赋值运算符

基于上述两点约束，根据书中的例子，实现一个简单的智能指针。

class A{
public:
    virtual void func(){ cout << "a::func" << endl; }
    virtual  ~A(){}
};
class B : public A{
public:
    virtual void func(){ cout << "b::func" << endl; }
};


//
template <class T>
class SmartPtr{
public:
    //返回use_count
    int *use_count()const
    {
        return count;
    }
    //返回原始对象的指针
    T*get()const
    {
        return heldPtr;
    }
    //析构函数
    ~SmartPtr()
    {
        if (--(*count) == 0)
        {
            delete count;
            delete heldPtr;
            count = nullptr;
            heldPtr = nullptr;
        }
    }//

    //默认构造函数
    SmartPtr() :count(nullptr), heldPtr(nullptr)
    {
    }
    //使用内置指针初始化的构造函数
    template <class U>
    explicit SmartPtr(U * pu) : heldPtr(pu)
    {
        count = new int(1);
    }

    //泛化拷贝构造函数
    template <class U>
    SmartPtr(SmartPtr<U>&other) :count(other.use_count()),heldPtr(other.get())
     {
        ++(*count);
     }
    //拷贝构造函数
    SmartPtr(SmartPtr&other) :count(other.use_count()), heldPtr(other.get())
    {
        ++(*count);
    }
    //泛化赋值符号重载
    template<class U>
    SmartPtr &operator=(const SmartPtr<U>&other)
    {
        ++(*other.use_count());
        if ((count != nullptr) && (--(*count) == 0))
        {
            delete heldPtr;
            delete count;
        }
        heldPtr = other.get();
        count = other.use_count();
        return *this;
    }

    //赋值符号重载
    SmartPtr &operator=(const SmartPtr&other) 
    {
        ++(*other.use_count());
        if ((count!=nullptr)&&(--(*count) == 0))
        {
            delete heldPtr;
            delete count;
        }
        heldPtr = other.get();
        count = other.use_count();
        return *this;
    }

    //->重载 作用类似于get()
    T* operator->()const
    {
        return heldPtr;
    }
private:
    int* count;
    T* heldPtr;
};


int main()
{
    A *pa = new B;//ok
    //B*pb = new B;
    SmartPtr<A>global;
    {
        SmartPtr<B>pb(new B);
        SmartPtr<A>pt1 = SmartPtr<B>(new B);//copy构造函数
        global = pt1;//赋值函数
        global = pb;
        global->func();//
        SmartPtr<A>pt2 = pt1;
        pt1->func();
    }
    delete pa;

    system("pause");
    return 0;
}
NearXDU
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
模板与泛型编程
Bystander_seek的博客
07-03 263
模板与泛型编程 1.定义模板 ​ 模版是C++泛型编程的基础，一个模版就是一个类或函数的蓝图或者说是公式：例如在使用vector这样的泛型类型，或者是find函数这样的泛型类型，我们可以将蓝图转换为特定的类或者是函数，这种转换发生在编译时。当我们调用一个模板时，编译器会使用实参的类型来确定绑定到模版参数T上的类型，之后编译器利用推断出的模版参数来实例化一个特定版本的函数，这个过程被称之为实例化。编译器遇到一个模版的定义时，并不会产生代码，只有当我们实例化出模版的一个特定版本的时候，编译器才会产生代码，因此
effective c++读书笔记
05-27
- 模板C++：模板编程允许编写独立于数据类型的代码，是C++泛型编程的核心，也是C++强大的抽象工具之一。 - STL（标准模板库）：STL是一个包含容器、迭代器、算法和函数对象的模板库，它提供了一组通用的、经过优化...
effective_notes:看effective c++系列，做下笔记
04-07
模板是C++的泛型编程基础，它可以用于创建泛型函数和泛型类。模板元编程则进一步扩展了这一概念，允许在编译时进行计算。 四、STL容器 标准模板库（STL）包括容器如`std::vector`, `std::list`, `std::map`等，它们...
Effective_C++_3rd笔记.pdf
03-21
模板是C++中实现泛型编程的关键工具，本章重点包括： - **条款42**：解释了`typename`关键字在模板上下文中的双重含义，以及如何正确使用它。 - **条款44**：提倡将与参数无关的代码从模板中分离出来，以简化模板的...
Effective C++学习笔记
04-20
1. **视C++为一个语言联邦**：C++是由C、面向对象和泛型编程等多个部分组成的，理解这些部分如何协同工作至关重要。开发者应熟悉C++的各种特性，如指针、引用、类、模板等，并根据场景选择合适的工具。 2. **尽量以...
模板和泛型编程
liushui102的专栏
12-29 2577
       所谓泛型编程就是以独立于任何特定类型的方式编写代码。使用泛型程序时，我们需要提供具体程序实例所操作的类型或值。    在 C++ 中，模板是泛型编程的基础。模板是创建类或函数的蓝图或公式。     函数模板是一个独立于类型的函数，可作为一种方式，产生函数的特定类型版本。例如，可以编写名为 compare 的函数模板，它告诉编译器如何为我们想要比较的类型产生特定的 comp
C++ 模板与泛型编程
weixin_33724059的博客
01-14 108
《C++ Primer 4th》读书笔记 所谓泛型编程就是以独立于任何特定类型的方式编写代码。泛型编程与面向对象编程一样，都依赖于某种形式的多态性。 面向对象编程中的多态性在运行时应用于存在继承关系的类。我们能够编写使用这些类的代码，忽略基类与派生类之间类型上的差异。 在泛型编程中，我们所编写的类和函数能够多态地用于跨越编译时不相关的类型。一个类或一个函数可以用来操纵多种类型的对象。 面向...
C++------模板与泛型编程
一个人的学习和碎碎念
05-16 297
一、定义模板 1、函数模板 template<typename T> int compare(const T &v1,const T &v2 ) { if(V1<V2) return -1; if(v1>v2) return 1; } 模板定义以关键字template开始，后跟一个模板参数列表，这是一个逗号分隔的一个或多个模板...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值