01_泛型编程与STL之黑马程序员day01

最新推荐文章于 2022-01-07 17:18:40 发布
最新推荐文章于 2022-01-07 17:18:40 发布
阅读量197 收藏
点赞数
分类专栏： STL与泛型编程学习笔记_侯捷
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40817333/article/details/104454571
版权
2020/02/27完结

1.模板的基本介绍

模板技术使类型参数化，在编写代码时可以忽略类型，避免编写类似重复的代码。

为了让编译器区分普通函数和模板函数：在模板函数的函数声明前添加template< class T> 或者
template< typename T>。

模板函数可以通过传入函数的参数来自动推导类型，也可以显式地指定类型。

#include <iostream>
using namespace std;

template<class T>
void Swap(T& a, T& b){
    T temp = a;
    a = b;
    b = temp;
}

int main(){
    int a = 10;
    int b = 20;
    // 自动类型推导
    cout << "a:" << a << " b:" << b << endl;
    Swap(a, b); //编译器根据你传的值 进行类型自动推导
    cout << "a:" << a << " b:" << b << endl;
    
    //显示指定类型
    double c = 1.23;
    double d = 3.45;
    cout << "c:" << c << "d:" << d << endl;
    Swap<double>(c, d);
    cout << "c:" << c << "d:" << d << endl;
 
    return 0;
}

2.普通函数与模板函数的区别

普通函数可对传入的参数进行类型转换，例如：将char类型变量转换为int类型变量。
模板函数对传入的参数进行严格的类型匹配，不会进行类型转换

#include <iostream>
using namespace std;
// 模板函数
template<class T>
T MyAdd(T a, T b){
    return a + b;
}
// 普通函数
int MyAdd(int a, int b){
    return a + b;
}
int main(){
    int a = 10, b = 20;    
    char c1 = 'a', c2 = 'b';
    MyAdd<>(a, b);  // 调用模板函数    
    MyAdd(a, b);  // 调用普通函数    
    MyAdd(a, c1);  // 调用普通函数    
    MyAdd(c1, c2);  // 调用普通函数        
    return 0;
}

模板函数原理如下图：

3.类模板的介绍

在函数模板中，模板函数可以根据传入函数的参数自动推导类型。
在类模板中，类模板无法自动推导类型，必须显式指定类型。

#include <iostream>
using namespace std;
template<class T>
class Person {
public:   
    Person(T id,T age){
        this->mAge = age;        
        this->mId = id;    
    }
    void Show(){
        cout << "ID:" << mId << " Age:" << mAge << endl;    、
    }
public:    
    T mId;    
    T mAge;
};
int main(){        
    //函数模板在调用的时候，可以自动类型推导    
    //类模板必须显式指定类型    
    Person<int> p(10,20);        
    p.Show();
    return 0;
}

4.函数模板案例之对int类型和char类型数组排序

这里是对1、2、3部分的知识总结，不再赘述，代码如下：

#include <iostream>
using namespace std;

//对char类型和Int类型数组进行排序
//打印函数
template<class T>
void PrintArray(T* arr,int len){
 for (int i = 0; i < len;i++){
  cout << arr[i] << " ";
 }
 cout << endl;
}
//排序
template<class T>
void MySort(T* arr,int len){
    for (int i = 0; i < len;i ++){
        for (int j = i + 1; j < len;j++){
            //从大到小排序
            if (arr[i] < arr[j]){
                T temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
             }
        }
    }
}    
int main(){
    //数组
    int arr[] = {2,6,1,8,9,2};
    //数组长度
    int len = sizeof(arr) / sizeof(int);
    
    cout << "排序之前:" << endl;
    PrintArray(arr,len);
    //排序
    MySort(arr,len);
    //排序之后
    cout << "排序之后:" << endl;
    PrintArray(arr, len);
    
    cout << "--------------------" << endl;
    char chArr[] = {'a','c','b','p','t'};
    len = sizeof(chArr) / sizeof(char);
    PrintArray(chArr, len);
    MySort(chArr, len);
    PrintArray(chArr, len);
    
    reurn 0;
}

5.类模板派生普通类

派生子类时需要对模板父类显式指定类型

template<class T>
class Person{
public:
    Person(){
        mAge = 0;
    }
public:
    T mAge;
};

// 显式指明模板父类的类型是因为对象编译时需要分配内存
class SubPerson : public Person<int>{};

6.类模板派生类模板

具体用法借鉴下方代码

template <class T>
class Animal{
public:
    void description{
        cout << mAge << "岁的动物"  << endl;
    }
public:
    T mAge;
};
template <class T>
class Cat : public Animal<T>{};

7.类的写法_头文件(untitle.h)与源文件(untitle.cpp)的分离

// Person.h
#progrma once  //防止头文件被重复包含
#include <iostream>
#include <string>
using namespace std;

class Person{
public:
   Person(string name, int age);
   void Show();
public:
   string mName;
   int mAge;
   int mID;
};
//Person.cpp
#include "Person.h"

Person::Person(string name, int age){  
    this->mName = name;
    this->mAge = age;
}

void Person::Show(){
   cout << "Name:" << this->mName << " Age:" << this->mAge << endl;
}
//main.cpp
#include <iostream>
using namespace std;
#include "Person.h"
int main(void){
    Person p("AAA",20);
    p.Show();
    
    return 0;
}

8.类模板实现在类内实现

仿照下列代码编写即可：

#include <iostream>
#include<string>
using namespace std;

//类内实现
template<class T1,class T2>
class Person{
public:
    Person(T1 name,T2 age){
        this->mName = name;
        this->mAge = age;
    }
   void Show(){
       cout << "Name:" << this->mName << " Age:" << this->mAge << endl;
   }
public:
   T1 mName;
   T2 mAge;
};

int main(void){
    Person<string, int> p("AAA", 20);
    p.Show();
    
    return 0;
}

9.类模板类外实现

说明一：类内友元函数可以访问类的私有成员。
说明二：类内慎用友元函数！！！
具体代码写法如下：

//类内运算符重载友元函数的写法一
template<class T>
class Person{
public:
    //...  
    /*
    如果不添加<T>，那么friend ostream& operator <<(ostream& os, Person<T>& p) 与
    template<class T> ostream& operator<<(ostream& os, Person<T>& p)不是同一个函数，
    前者是后者的一个具体实现
    */
    friend ostream& operator << <T>(ostream& os, Person<T>& p);  //注意此处的<T>
private:
    //...
};

//重载左移运算操作符
template<class T>
ostream& operator<<(ostream& os, Person<T>& p){
    os << "Age:" << p.mAge << " ID:" << p.mID << endl;
    return os;
}
//最后可直接 cout << p;
//类内运算符重载友元函数的写法二
template<class T>
class Person{
public:
    //...
    // 这种写法无法在linux通过!!!
    template<class T>
    friend ostream& operator<<(ostream& os, Person<T>& p);  //注意这里没有<T>
private:
    //...
};
// 重载左移运算操作符的类外实现和调用同上，不再赘述
//普通友元函数的写法一：类外函数声明
template<class T> class Person;
template<class T> void PrintPerson(Person<T>& p);

template<class T>
class Person{
public:
    //...
    friend void PrintPerson<T>(Person<T>& p);  //注意此处的 <T>
private:
    //...
};

template<class T>
void PrintPerson(Person<T>& p){
    cout << "Age:" << p.mAge << " ID:" << p.mID << endl;
}

//最后直接调用PrintPerson(p);
//普通友元函数的写法二：
template<class T>
class Person{
public:
     //...
     //linux无法通过
     template<class T>
     friend void PrintPerson(Person<T>& p);  //注意此处没有<T>
private:
     //...
};
//友元函数的实现同上
//函数的调用同上
//原完整代码如下：
#include <iostream>
using namespace std;

template<class T> class Person;
template<class T> void PrintPerson(Person<T>& p);

template<class T>
class Person{
public:
    //普通友元函数
    //template<class T>
    friend void PrintPerson<T>(Person<T>& p);

    //重载左移操作符
    template<class T>
    friend ostream& operator<<(ostream& os, Person<T>& p); 
    // 或写成
    // friend ostream& operator << <T>(ostream& os, Person<T>& p);
    Person(T age, T id);
    void Show();
private:
    T mAge;
    T mID;
};

template<class T>
Person<T>::Person(T age, T id){
    this->mID = id;
    this->mAge = age;
}

template<class T>
void Person<T>::Show(){
    cout << "Age:" << mAge << " ID:" << mID << endl;
}

//重载左移运算操作符
template<class T>
ostream& operator<<(ostream& os, Person<T>& p){
    os << "Age:" << p.mAge << " ID:" << p.mID << endl;
    return os;
}
template<class T>
void PrintPerson(Person<T>& p){
    cout << "Age:" << p.mAge << " ID:" << p.mID << endl;
}

int main(void){
    Person<int> p(10,20);
    //p.Show();
    //cout << p;
    PrintPerson(p);
    
    return 0;
}

10.类模板源文件(.cpp)与头文件(.h)分开编写

类模板源文件与头文件的分开编写以下方代码(会报错)示例：

//Person.h
#pragma once

#include<iostream>
using namespace std;

template<class T>
class Person{
public:
    Person(T age);
    void Show();
public:
    T age;
};
//Person.cpp
#include "Person.h"

template<class T>
Person<T>::Person(T age){
    this->age = age;
}

template<class T>
void Person<T>::Show(){
    cout << "Age：" << age << endl;
}
//main.cpp
#include <iostream>
using namespace std;
#include "Person.h"
// 解决方法一：要想编译通过，此处将#include "Person.h"改为 #include "Person.cpp"即可
// 解决方法二：见下方的建议

int main(void){
    /*构造函数定义在当前文件没有找到，编译认为这个函数在其他文件中定义
    让链接器在链接的时候 去找这个函数的具体位置*/
    Person<int> p(10);  
    p.Show();
        
    return 0;
}

建议：编写模板类代码时，类模板的声明和实现写在一个文件中，且后缀名改成.hpp。
在上面的例子中，Person.h和Person.cpp写在一个文件之中，并取名Person.hpp。最后在main.cpp中包含Person.hpp即可。
说明：hpp文件其实质就是将.cpp的实现代码混入.h头文件当中，定义与实现都包含在同一文件。

分析报错原因：代码报错的原因和模板的实现机制、C++编译机制有关。
C++编译机制的解释：假设在一个Cpp项目中，包含了三个文件：a.cpp、b.cpp、c.cpp。编译器对三个文件进行独立编译(比如编译a.cpp文件时，只编译a文件的内容，查看a是否有错，而不链接b、c文件的内容)，如果在a文件的编译过程中，发现一个函数调用且该函数在a文件中无法找到，则在该函数位置生成一个符号。
模板实现机制：模板代码会经过两次编译。第一次编译检查模板代码的语法是否出错；第二次编译是在模板代码被调用时生成具体的代码(比如生成具体的int类型函数)。

在上面的例子中，main.cpp只包含了Person.h，而头文件中的类模板声明并不编译。在独立编译main.cpp的过程中，执行到Person p(10); p.Show();，编译器认为该函数在其他文件中实现，于是会在此处生成一个符号，编译通过。在独立编译Person.cpp的过程中，编译器对模板函数进行编译(通俗地说：对模板函数语法进行检查，并未生成具体类型的函数)，编译通过。
在链接器对Person.cpp和main.cpp进行链接时，由于main.cpp没有调用Person.cpp，所以模板函数没有经过第二次编译生成具体的函数(比如int类型构造函数)。main.cpp使用的还是类型不明确的模板函数，最后出现未知符号的报错。
为了解决这个问题，只需要让main.cpp调用模板函数，生成具体类型的函数，所以引入Person.cpp(而非
Person.h)就可以解决问题。

11.类模板中的static成员

下方是测试代码：

#include <iostream>
using namespace std;

template<class T>
class Person{
public:
    static int a;
};

template<class T> int Person<T>::a = 0;  //类外初始化

int main(void){
    Person<int> p1, p2, p3;
    Person<char> pp1, pp2, pp3;
    
    p1.a = 10;
    pp1.a = 100;
    
    cout << p1.a << " " << p2.a << " " << p3.a << endl;
    cout << pp1.a << " " << pp2.a << " " << pp3.a << endl;
    
    return 0;
}

对普通类而言，类的静态成员是这个类所共有的。这里仅说明模板类的静态成员是属于整个模板类还是对于不同数据类型的类有各自的静态成员？ 这里用图说明：

在这里插入图片描述
显然，类模板的静态成员针对不同的具体类而言的。从上面的测试代码可以知道：生成不同的具体类时，可以更改静态成员的值。

附：Cpp文件的编译过程

在这里插入图片描述

百事_可乐
关注
专栏目录
泛型编程与STL.pdf
01-04
泛型编程与STL.pdf
STL源码分析：泛型编程与STL
——
06-30 1720
定义抽象的concepts，并根据抽象的concepts来撰写算法与数据结构，是泛型编程的本质。运用STL时的几个最重要的观念：1.所谓使用STL，就是去扩充它。2.STL的算法和容器是独立分离的。3.无须继承。4.抽象化并不意味效率低。STL所实现的，是依据泛型思维架设起来的一个概念结构。这个以抽象概念为主体而非以实际类为主体的结构，形成了一个严谨的接口标准。在此接口下，任何组件都有最大的独立性...
泛型程序设计与STL
tf_apologize的博客
11-13 1502
泛型程序设计的基本概念         所谓泛型程序设计，就是编写不依赖于具体数据类型的程序。泛型程序设计的主要思想是将算法从特定的数据结构中抽象出来，使算法成为通用的、可以作用于各种不同的数据结构。 泛型程序设计的数据类型T的协议： 从函数模板的声明来看，类型参数T可以是任何数据类型，但实际上并非如此。类型T必须具备3个功能： ①类型T的变量之间能够比较大小 ②类型T必须具有公有的
泛型编程与STL中文版
08-04
高清《泛型编程与STL中文版》。。。。。。。。。。。。。。。。。。。。
《泛型编程与STL》（Matthew H. Austern[美] 著，侯捷 译）
01-19
《泛型编程与STL》阐述了泛型编程的中心思想：concepts、modeling、refinement,并为你展示这些思想如何导出STL的基础概念：iterators、containers、functionobjects.循此路线，你可以把STL想像为一个由concepts组成...
Cpp设计新思维_泛型编程与设计模式之应用
02-16
《Cpp设计新思维_泛型编程与设计模式之应用》这本书深入探讨了C++编程中的泛型编程和设计模式的应用，对于提升C++开发者的技术水平具有极高的价值。以下是本书涉及的一些关键知识点： 1. 泛型编程：泛型编程是C++中...
泛型编程与STL
chzy00的专栏
12-03 517
昨天又有做软件的朋友谈到STL，让我想起当初看到STL的时侯惊为天人的情景，今天抽空来谈谈C++和STL。 -------------------------------------------     C++提供了二种功能强大的抽象方法：面向对象编程与泛型编程。面向对象编程大家一定很熟悉了，这里就不再哆嗦了。提到泛型编程(Generic Programming)，有的人可能还不太熟悉，但是提
C++泛型编程与STL标准模板库
qq_42932834的博客
06-01 568
引言   标准模板库(Standard Template Library，STL) 是一个高效，实用的C++程序库。它被容纳于C++标准库中，是ANSI/ISO C++标准中最新的，也是极具革命性的一部分。该库包含了诸多计算机科学领域里常用的基本数据结构和基本算法，也为C++程序员们提供了可扩展的应用框架，高度体现了软件的可复用性。 STL概述   STL在C++程序设计中的作用是提供一个可供函...
泛型编程与STL（STL经典书籍）
04-24
侯捷老师译的，泛型编程与STL方面的经典书籍.
泛型编程与STL（含源代码）（STL专辑）
10-15
本资源中文版 中文名：泛型编程与STL 译者：侯捷 英文名：Generic Programming and the STL 时间：1998 作者：Matthew H. Austern 包含：书、源代码、勘误表 个人比较喜欢侯捷翻译的书，不仅仅翻译的好，而且写的序让人对书对知识有一定的收货，主要是翻译的态度很好。不像有些译者，不仅仅的序很水，而且翻译得也不专业，译者不但没有水平，而且态度也令人不爽。 值得一看的好书。
范型编程与STL 侯捷翻译 超星
11-22
超星版 简体中文 关于stl的经典书籍 目前纸版已经绝版
泛型编程与STL中文版-带书签
11-17
泛型编程与STL中文版 加书签版本 影印清晰版
泛型编程与STL.rar
03-16
详细讲解并实例说明泛型编程与STL的教程
C++-----STL与泛型编程（三）
一个人的学习和碎碎念
04-24 444
此系列博客，图片文字观点均是来自侯捷老师讲义课程，仅作为学习用途。 1、深度探索list GNU C2.9版本实现如下： list的定义如下：可以看到其中的数据只有一个指针，所以sizeof(list)等于4。这是在GNU C2.9版本下的结果。 双向链表的节点定义：可以看到其中有一个数据，有两个指针，一...
[C++]（STL和泛型编程）
weixin_38800498的博客
01-07 1784
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录1.认识headers2.STL体系结构基础介绍3.容器之分类与各种测试（1）3.容器之分类与各种测试（2）3.容器之分类与各种测试（3）3.容器之分类与各种测试（4） 1.认识headers C++ 标准库（STL大部分属于C++标准库） —STL和标准库的关系 2.STL体系结构基础介绍 1.容器帮助我们吧内存的问题解决，需要一个分配器来支持容器，容器是一个模板类，有一些操作是自己做，更多的是独立出来成为算法。算法和容器
C++侯捷STL标准库与泛型编程笔记
WLSTLA
11-29 1279
C++STL 本篇博文参考与侯捷老师的STL泛型编程课程,将其中比较重要的部分记录来下，方便今后的复习。十分推荐侯捷老师的C++系列，真的是圣经一样的存在！ 1.STL六大部件Component 容器(Containers) 分配器(Allocators) 算法(Alogorithms) 迭代器(Iterators) 适配器(Adapters) 仿函数(Functors) 2.分配器 allocator以::operator new 和::operator delete完成al
C++STL与泛型编程 侯捷 （1）
weixin_43116900的博客
04-05 438
泛型编程（Generic Programming，GP），就是使用template（模板）为主要工具来编写程序。 重要网页： http://www.cplusplus.com/ https://en.cppreference.com/w/ http://gcc.gnu.org/ ...
泛型编程与STL：C++模板深入解析
"大局觀：泛型程式設計与STL（Generic Programming） .pdf" 这篇文章讲述了泛型编程（Generic Programming）和标准模板库（STL）的重要性及其发展历程。泛型编程是一种编程范式，旨在创建独立于特定数据类型的代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值