C++ 程序设计 —— 实验三：模板

最新推荐文章于 2022-01-21 09:59:07 发布
最新推荐文章于 2022-01-21 09:59:07 发布
阅读量1k 收藏 3
点赞数 1
分类专栏： c++ 面向对象编程 文章标签： c++ 面向对象编程 类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dreamwendy/article/details/121141555
版权

目录

一、模板函数

1、一般模板函数

2、特化模板函数

二、模板类

1、模板类

2、成员模板函数

①普通类的成员模板函数

②类模板的成员模板函数

3、模板特化

①模板函数特化

②模板成员函数特化

③模板类特化

4、模板类Queue代码实现

三、模板类AutoPtr

1、构造函数

2、析构函数

3、拷贝构造函数

4、等号、->、*等运算符重载

5、主函数调用AutoPtr

五、实验总结 

一、模板函数

举一个最简单的例子，为了比较两个整型变量的值，需要写下面的 Compare 函数：

int Compare(const int& a, const  int& b)
{
    if(a > b) return 1;
    if(a < b) return -1;
    return 0;
}

为了比较两个 double 型变量的值，还需要编写下面的 Compare 函数：

int Compare(const double& a, const  double& b)
{
    if(a > b) return 1;
    if(a < b) return -1;
    return 0;
}

如果还要比较两个 char 型变量的值，比较两个 CStudent 类对象的值等等，这些都需要我们再编写 Compare 函数。而这些 Compare 函数除了处理的数据类型不同外，形式上都是一样的。能否只写一遍 Compare 函数，就能用来交换各种类型的变量的值呢？继承和多态显然无法解决这个问题。因此，“模板”的概念就应运而生了。

函数模板的写法如下：

template <class 类型参数1, class类型参数2, ...>
返回值类型  模板名(形参表)
{
    函数体
}

其中的 class 关键字也可以用 typename 关键字替换，例如：

template <typename 类型参数1, typename 类型参数2, ...>

1、一般模板函数

// 一般模板函数
template <class Type>
int Compare(const Type& a, const Type& b){
    if(a > b) return 1;
    if(a < b) return -1;
    return 0;
}

Type是类型参数，代表类型。编译器由模板自动生成函数时，会用具体的类型名对模板中所有的类型参数进行替换，其他部分则原封不动地保留。同一个类型参数只能替换为同一种类型。编译器在编译到调用函数模板的语句时，会根据实参的类型判断该如何替换模板中的类型参数。

#include <iostream>
using namespace std;

template <class Type>
int Compare(const Type& a, const Type& b){
    if(a > b) return 1;
    if(a < b) return -1;
    return 0;
}

int main()
{
    int a = 1, b = 1;
    cout << Compare(a, b) << endl;       //编译器自动生成 void Compare(const int&, const int&)函数
    double c = 1.1, d = 2.2;
    cout << Compare(c, d) << endl;       //编译器自动生成 void Compare(const double&, const double&)函数
    return 0;
}

对于该函数模板，当实参为两个char指针时，比较的是指针的大小，而不是指针指向内容的大小，此时就需要为该函数模板定义一个特化版本，即特殊处理的版本。

2、特化模板函数

特化模板函数是在一个统一的函数模板不能在所有类型实例下正常工作时，需要定义类型参数在实例化为特定类型时函数模板的特定实现版本。

// 特化模板函数
template <>
int Compare<const char *>(const char * const &v1, const char * const &v2)
{
    return strcmp(v1, v2);
}

二、模板类

1、模板类

 C++除了支持函数模板，还支持类模板（Class Template）。函数模板中定义的类型参数可以用在函数声明和函数定义中，类模板中定义的类型参数可以用在类声明和类实现中。类模板的目的同样是将数据的类型参数化。

声明类模板的语法为：

template<typename 类型参数1 , typename 类型参数2 , …>
class 类名{
         类成员声明
};

类模板和函数模板都是以 template 开头，后跟类型参数；类型参数不能为空，多个类型参数用逗号隔开。一但声明了类模板，就可以将类型参数用于类的成员函数和成员变量了。换句话说，原来使用 int、float、char 等内置类型的地方，都可以用类型参数来代替。

template <class Type> class Queue;     //模板类Queue
template <class Type> class QueueItem{ //模板类QueueItem
private:
    QueueItem(const Type& t):item(t),next(0){}
    Type item;
    QueueItem *next;
    friend class Queue<Type>;          //友元类Queue
    friend ostream& operator<<(ostream& os, const Queue<Type> &q); //友元函数,对操作符<<进行重载
public:
    QueueItem<Type>* operator++(){     //对++操作符重载,获取下一个
        return next;
    }
    Type& operator*(){                 //对*操作符重载,返回当前item
        return item;
    }
};

2、成员模板函数

①普通类的成员模板函数

不管是普通类，还是类模板，它的成员函数可以是一个函数模板，称为成员函数模板，不可以是虚函数，否则编译器报错。

class A 
{
public:
	template<typename Type>
	void print(const Type& a)
	{
		cout << a << endl;
	}
};

int main()
{
	A a;
	a.print(5);	//编译器自动推断类型来实例化这个函数模板 
	return 0;
}

②类模板的成员模板函数

  1. 类模板的模板参数必须用<>指定，成员函数模板(函数模板)的参数可以由编译器自动推断。
  2. 类模板的成员函数(包括普通成员函数/成员函数模板)只有为程序所用才进行实例化。
  3. 如果某函数从未被使用,则不会实例化该成员函数。
// Queue.h
// 模板类Queue —— 队列
template <class Type> class Queue{
private:
    QueueItem<Type> *head;             //头
    QueueItem<Type> *tail;             //尾
    void destroy();                    //销毁队列
    void copy_items(const Queue& orig);
    template<class It>
    void copy_items(It begin, It end);
public:
    Queue():head(0),tail(0){}             //缺少构造函数
    Queue(const Queue& q):head(0),tail(0){//拷贝构造函数
        copy_items(q);
    }
    
    template<class It>                 //成员模板函数
    Queue(It begin, It end):head(0),tail(0){
        copy_items(begin, end);
    }
    
    template<class It>                 //成员模板函数
    void assign(It begin, It end);
    
    Queue& operator= (const Queue& q); //运算符重载
    ~Queue(){ destroy(); }             //析构函数
    Type& front(){ return head->item; }//获取队列头元素
    const Type& front() const;          
    void push(const Type& val);        //入队
    void pop();                        //出队
    bool empty() const{ return head == 0; } //判断队列是否为空
    friend ostream& operator<<(ostream& os, const Queue<Type>& q);  //友元函数,对操作符<<进行重载
    const QueueItem<Type>* Head() const{ return head; }             //返回队列头
    const QueueItem<Type>* End() const{ return (tail==NULL)?NULL:tail->next; }//返回队列尾 
};

3、模板特化

①模板函数特化

特化模板函数是在一个统一的函数模板不能在所有类型实例下正常工作时，需要定义类型参数在实例化为特定类型时函数模板的特定实现版本。

// 一般模板函数
template <class Type>
int Compare(const Type& a, const Type& b){
    if(a > b) return 1;
    if(a < b) return -1;
    return 0;
}

// 特化模板函数
template <> 
int Compare<const char *>(const char * const &v1, const char * const &v2)
{
    return strcmp(v1, v2);
}

②模板成员函数特化

申明（放在.h文件中） ：

template<>
int Compare<const char*>(const char * const &v1, const char * const &v2);
template<>
void Queue<const char*>::push(const char * const &val);
template<>
void Queue<const char*>::pop();

 实现（只能放在.cpp文件中）：

template <> 
int Compare<const char *>(const char * const &v1, const char * const &v2)
{
    return strcmp(v1, v2);
}

template<>
void Queue<const char*>::push(const char * const &val){
    char* newitem = new char[strlen(val)+1];  //+1是因为最后有一个结束符
     strncpy(newitem, val, strlen(val)+1);    //复制字符串
     QueueItem<const char*> * pt = new QueueItem<const char*>(newitem);
     if(empty()){
         head = tail = pt;
     }
     else {
         tail->next = pt;
         tail = pt;
     }
}

template<>
void Queue<const char*>::pop(){
    QueueItem<const char*> *p = head;
    delete  head->item;    //new分配的空间，要用delete
    head = head->next;
    delete p;
}

③模板类特化

模板类特化，与函数模板类似，当类模板内需要对某些类型进行特别处理时，使用类模板的特化。

类模板特化的三种类型：

  • 一是特化为绝对类型；
  • 二是特化为引用，指针类型；
  • 三是特化为另外一个类模板。
// 用于比较的类模板
template <class T>
class Compare{
public :
    bool  IsEqual(const T& a, const T& b){
         return a == b;
    }
};

// 特化为绝对类型
template <>
class Compare <double>{
public:
    bool IsEqual(const double& a, const double& b)
    {
         return abs(a - b) < 10e - 6 ;
    }
};

// 特化为引用，指针类型
template <class T>
class Compare <T*>{
public:
    bool IsEqual(const T *a, const T *b)
    {
         return Compare<T>::IsEqual(*a, *b);
    }
};

// 特化为另外一个类模板
template <class T>
class Compare <vector<T>>{
public:
    bool IsEqual(const vector<T>& a, const vector<T>& b){
        if(a.size() != b.size()){ 
            return false;
        }
        else{
            for(int i = 0; i < a.size(); i++){
                if(a[i] != b[i])  return  false;
            }
        }
        return true;
    }
};

4、模板类Queue代码实现

// queue.h
#include <iostream>
using namespace std;

template <class Type> class Queue;     //模板类Queue
template <class Type> class QueueItem{ //模板类QueueItem
private:
    QueueItem(const Type& t):item(t),next(0){}
    Type item;
    QueueItem *next;
    friend class Queue<Type>;          //友元类Queue
    friend ostream& operator<<(ostream& os, const Queue<Type> &q); //友元函数,对操作符<<进行重载
public:
    QueueItem<Type>* operator++(){     //对++操作符重载,获取下一个
        return next;
    }
    Type& operator*(){                 //对*操作符重载,返回当前item
        return item;
    }
};

//模板类Queue —— 队列
template <class Type> class Queue{
private:
    QueueItem<Type> *head;             //头
    QueueItem<Type> *tail;             //尾
    void destroy();                    //销毁队列
    void copy_items(const Queue& orig);
    template<class It>
    void copy_items(It begin, It end);
public:
    Queue():head(0),tail(0){}             //缺少构造函数
    Queue(const Queue& q):head(0),tail(0){//拷贝构造函数
        copy_items(q);
    }
    
    template<class It>                 //成员模板函数
    Queue(It begin, It end):head(0),tail(0){
        copy_items(begin, end);
    }
    
    template<class It>                 //成员模板函数
    void assign(It begin, It end);
    
    Queue& operator= (const Queue& q); //运算符重载
    ~Queue(){ destroy(); }             //析构函数
    Type& front(){ return head->item; }//获取队列头元素
    const Type& front() const;          
    void push(const Type& val);        //入队
    void pop();                        //出队
    bool empty() const{ return head == 0; } //判断队列是否为空
    friend ostream& operator<<(ostream& os, const Queue<Type>& q){  //友元函数,对操作符<<进行重载
        QueueItem<Type>* p;
        for(p = q.head; p; p = p->next){
            os<<p->item<<" ";
        }
        return os;
    }
    const QueueItem<Type>* Head() const{ return head; }             //返回队列头
    const QueueItem<Type>* End() const{ return (tail==NULL)?NULL:tail->next; }//返回队列尾 
};

// 销毁队列
template <class Type> 
void Queue<Type>::destroy(){
    while(!empty()){
        pop();
    }
}

// 出队，删除队列第一个元素
template <class Type> 
void Queue<Type>::pop(){
    QueueItem<Type> *p = head;
    head = head->next;   //保留头指针后的元素
    delete p;
}

// 入队
template<class Type> 
void Queue<Type>::push(const Type& val){
    QueueItem<Type> *pt = new QueueItem<Type>(val);
    if(empty()){   //若队列为空，让头指针和尾指针等于pt
        head = tail = pt;
    }
    else {         //若队列非空，未尾指针后移，尾指针等于pt
        tail -> next = pt;
        tail = pt;
    }
}

// 当类型为char，模板成员函数特化，在头文件李声明
template<>void Queue<const char*>::push(const char * const &val);
template<>void Queue<const char*>::pop();

// 复制队列元素
template<class Type> 
void Queue<Type>::copy_items(const Queue &orig){
    for(QueueItem<Type> *pt = orig.head; pt; pt=pt->next){
        push(pt->item);
    }
}

// 运算法重载
template<class Type>
Queue<Type>& Queue<Type>::operator=(const Queue& q){
    destroy();
    copy_items(q);
}

// 区间拷贝复制
template<class Type> template<class It> 
void Queue<Type>::assign(It begin, It end)
{
    destroy();
    copy_items(begin, end);
}

// 区间拷贝复制
template<class Type> template<class It> 
void Queue<Type>::copy_items(It begin,It end){
    while(begin!=end){
    push(*begin);
    ++begin;
    }
}

// queue.cpp
#include "queue.h"
#include<string.h>

template<>
void Queue<const char*>::push(const char * const &val){
    char* newitem = new char[strlen(val)+1];  //+1是因为最后有一个结束符
     strncpy(newitem, val, strlen(val)+1);    //复制字符串
     QueueItem<const char*> * pt = new QueueItem<const char*>(newitem);
     if(empty()){
         head = tail = pt;
     }
     else {
         tail->next = pt;
         tail = pt;
     }
}

template<>
void Queue<const char*>::pop(){
    QueueItem<const char*> *p = head;
    delete  head->item;    //new分配的空间，要用delete
    head = head->next;
    delete p;
}
// main.cpp
#include <iostream>
#include "queue.h"
#include <vector>
using namespace std;

int main()
{
    Queue<int> qt;
    double c = 5.3;
    qt.push(6);
    qt.push(c);   //输出为整型
    qt.push(10);
    cout<<qt;
    cout<<endl;

    short a[5] = {1,2,3,4};
    Queue<int> qi(a,a+5);
    cout<<qi;
    cout<<endl;

    vector<int> vi(a,a+5);
    qi.assign(vi.begin(),vi.end());
    cout<<qi;
    cout<<endl;

    Queue<const char*> q1;
    q1.push("hello");
    q1.push("I am");
    q1.push("wendy!");
    cout<<q1;
    cout<<endl;

    Queue<const char*> q2(q1);
    cout<<q2;
    return 0;
}

运行结果：

​

三、模板类AutoPtr

C++中我们都会用到指针。我们经常使用malloc或者new申请一块内存，然后用一个指针来保存起来。有内存的申请就必须要对它进行释放的处理，否则会造成最严重的后果——内存泄漏。少量申请的内存我们能够记得去释放，但如果成千上万行代码，全部记住就比较困难，所以智能指针就是为了解决这个问题而产生了。

​

1、构造函数

template<class T>
class AutoPtr{
public:
    AutoPtr(T* pData);            //构造函数声明
    AutoPtr(const AutoPtr<T>& h); //拷贝构造函数声明
    ~AutoPtr();                   //析构函数
private:
    void decrUser();  //减少引用数
    T *m_pData;       //数据
    int *m_nUser;     //引用数
};

template <class T>
AutoPtr<T>::AutoPtr(T* pData){    //构造函数实例化
    m_pData = pData;
    m_nUser = new int(1);         //初始时的引用计数为1
}

2、析构函数

~AutoPtr(){                   //析构函数
    decrUser();
}

template<class T>
void AutoPtr<T>::decrUser()   //减少引用数
{
    --(*m_nUser);
    if((*m_nUser)==0){        //当一个对象的引用为 0 时，这个对象资源被销毁
        delete m_pData;
        m_pData = 0;
        delete m_nUser;
        m_nUser = 0;
    }
}

3、拷贝构造函数

template<class T>
AutoPtr<T>::AutoPtr(const AutoPtr<T>& h){
    m_pData = h.m_pData;
    m_nUser = h.m_nUser;
    (*m_nUser)++;    //被引用或者被拷贝，引用的对象的引用计数要增加1
}

4、等号、->、*等运算符重载

template<class T>
class AutoPtr
{
public:
    AutoPtr(T* pData);            //构造函数声明
    AutoPtr(const AutoPtr<T>& h); //拷贝构造函数声明
    ~AutoPtr(){                   //析构函数
        decrUser();
    }
    
    AutoPtr<T>& operator=(const AutoPtr<T>& h);   //等号运算符重载声明
    T& operator*(){               //* 运算符重载
        return *m_pData;
    }
    T* operator->(){              //->运算符重载
        return m_pData;
    }
    const T& operator*() const{   //* 运算符重载
        return *m_pData;
    }
    const T* operator->() const{  //->运算符重载
        return m_pData;
    }
private:
    void decrUser();              //减少引用数
    T *m_pData;                   //数据
    int *m_nUser;                 //引用数
};

AutoPtr<T>& AutoPtr<T>::operator=(const AutoPtr<T>& h)  //实例化等号运算符重载
{
    if(this == &h) return *this;
    decrUser();
    m_pData = h.m_pData;
    m_nUser = h.m_nUser;
    (*m_nUser)++;                //引用数加1
    return *this;
}

5、主函数调用AutoPtr

#include <iostream>
#include "queue.h"
#include "AutoPtr.h"
#include "CMatrix.h"
#include <vector>
using namespace std;

int main()
{
    AutoPtr<CMatrix> h1(new CMatrix);     //创建类型为CMatrix的对象h1
    double data[9] = {1,2,3,4,5,6,7,8,9};
    h1->Create(3,3,data);                 //创建数据
    cout << *h1 << endl;
    AutoPtr<CMatrix> h2(h1);              //调用拷贝构造函数，创建对象h2
    (*h2).Set(0,1,10);                    //把h2数据的第0行，第1列数值改为10
    cout << *h1 << endl << *h2;
    return 0;
}

运行结果：

​

五、实验总结 

        我们常常需要编写多个形式和功能都相似的函数，因此用函数模板可以减少重复，提高复用性；有时候我们也需要编写多个形式和功能都相似的类，使用类模板更加方便，编译器从类模板可以自动生成多个类，避免了重复劳动。

       C++的内存管理是让人头疼的事，当我们写一个new语句时，一般会立即把delete语句也写上，但我们不能避免程序还未执行到delete时就跳转或者在函数中未执行到最后的delete语句就返回的情况，若我们不在每一个可能跳转或者返回的语句前释放资源，就会造成内存泄露。使用智能指针可以很大程度上的避免这个问题，因为智能指针就是一个类，当超出了类的作用域是，类会自动调用析构函数，析构函数会自动释放资源。

        本次实验实践了模板类，用模板类实现队列以及智能指针。模板类可用来创建动态增加或减少的数据结构，灵活性, 可重用性和可扩展性较好，可以大大减少开发时间，但是易读性比较不好，调试比较困难，模板的数据类型只能在编译时才能被确定。

DreamWendy
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++ 实验3 模板
qq_48864962的博客
11-17 829
目录 实验内容： 一、模板函数（compare）： 1.一般模板函数： 2.特化模板函数： 二、模板类Queue： 1.模板类（Queue）： 2.成员模板函数： 3.模板特化：模板函数特化、模板成员函数特化、模板类特化： 3.1.模板函数特化: 3.2.模板类特化: 三、模板类AutoPtr： 1.构造函数： 2.析构函数： 3.拷贝构造函数： 4.等号、->、*等运算符重载： 5.主函数调用AutoPtr： 总结： 实验内容： 1、模板函数（comp...
C++实验3 模板
whaha12的博客
11-16 205
文章目录一、实验内容1.模板函数（compare）2.模板类Queue或Stack3.模板类AutoPtr二、实验过程和相关代码1.模板函数（compare）一般模板函数特化模板函数2.模板类Queue或Stack3.模板类AutoPtr实验总结1.构造函数继承访问权限测试2.友元类继承测试3.多态性综合运用 一、实验内容 1.模板函数（compare） 一般模板函数 特化模板函数 2.模板类Queue或Stack 模板类（Queue，Stack） 成员模板函数 模板特化：模板函数特化、模板成员函数特..
C++实验（三）——模板
向阳而生的博客
11-16 827
模板的概念 模板就是建立通用的模具，大大提高复用性 C++提供两种模板机制:函数模板和类模板 函数模板针对仅参数类型不同的函数； 类模板针对仅数据成员和成员函数类型不同的类。 函数模板 template<typename T> 函数声明或定义 使用函数模板有两种方式：自动类型推导、显示指定类型 类模板 建立一个通用类，类中的成员 数据类型可以不具体制定，用一个虚拟的类型来代表。 template<typename T> 类 类模板与函数模板
C++实验6——模板
weixin_51703554的博客
01-21 3363
实验目的 掌握类模板的定义和使用 实验内容 在之前的实验中，我们定义了一个矩阵类Matrix和其子类图像类Image。在数据的存储和处理过程中，我们用过unsigned char和double类型的data指针获取矩阵元素或者图像像素的值。但是现实中的矩阵或者图像数据并不仅仅使用浮点类型和8bits的无符号整数类型，比如有的单反相机可以拍摄32bits无符号整数像素值的图像（unsigned int）；在图像处理中经常将图像灰度值缩放到区间[0,1]内的浮点数（double）；再比如对图像进行傅里叶变
C++实验三 模板
Keiji582的博客
11-16 692
模板函数与模板类实验环境模板概念特化模板函数模板类队列类 实验环境 操作系统：win10 gcc：8.1.0 开发软件：qt5.14.2 模板概念 在C++的相关代码开发中，我们常常会遇到的是关于代码通用性的问题；模板就是C++支持参数化程序设计的工具，通过它可以实现参数化多态性。这里可以看一下两个例子。 int sum(int x,int y) { return x+y; } double sum(double x,double y) { return x+y; } 事实上两个函数除了数据类型以外进
实验报告模板——实验1：类和简单对象.pdf
07-09
实验报告的标题“实验报告模板——实验1：类和简单对象.pdf”表明这是一份关于C++编程中类和对象的实践学习报告，主要针对计算机与通信工程学院的学生。实验的目标是深入理解类和对象的概念，熟悉类的成员访问控制，...
MisterZou的C++课程设计——指导老师：谢逸
01-06
在本项目中，"MisterZou的C++课程设计——指导老师：谢逸"是一个学生团队合作完成的编程项目，旨在提升他们的C++技能。这个压缩包包含了该小组成员，包括邹灿、汪光耀、刘恋、郭辉、赵玲玲、周宣运，共同编写的代码...
面向对象程序设计——基于Visual C++：第2章 C++语言基础.pptx
09-19
"面向对象程序设计——基于Visual C++：第2章 C++语言基础"，这表明我们将讨论C++编程语言的核心特性，以及如何使用Visual C++作为开发环境来编写和运行C++程序。本章主要涵盖了C++的基本概念，包括它与C语言的关系...
C++程序设计教程——设计思想与实现习题代码答案
12-07
《C++程序设计教程——设计思想与实现习题代码答案》是一本面向初学者和有一定基础的程序员的教育性资源，旨在帮助读者深入理解和掌握C++编程语言。这本书结合了作者两年的教学实践经验，使得内容既理论严谨又贴近...
C++实验报告——个人银行账户管理系统.docx
11-30
【C++实验报告——个人银行账户管理系统】 在本次C++课程设计中，胡成成同学完成了个人银行账户管理系统的实现，旨在通过编程实践巩固和应用C++语言知识，特别是面向对象编程的概念。实验的主要目标是设计一个能...
c++函数模板和类模板计实验报告
04-26
练习 C++中函数模板、类模板的创建和使用方法。 (1) 理解模板的作用。 (2) 学习函数模板及其声明方法，掌握模板函数及其生成方法。 (3) 学习函数模板的两种不同的实例化方法。 (4) 学习类模板的声明与使用方法。
C++实验（三）模板
LIAO_0312的博客
11-16 955
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码
c++模版实验1
ChristinaXinny的博客
12-02 214
对类内的枚举类型 记得初始化！！！！ // // Created by Christina Xinny on 2020/11/25. // #include <iostream> #include <string> using namespace std; //1) 定义学生类包含姓名和成绩两个数据成员，重载比较运算符（按成绩和按姓名两个模式比较）和输出运算符。 class Student { public: enum SortType { BY_N
C++实验三之模板
qq_45749702的博客
11-16 601
文章目录一、模板函数1.1 一般模板函数1.2 特化模板函数二、模板类Queue或Stack2.1 成员模板函数2.2 模板特化三、模板类AutoPtr 一、模板函数 1.1 一般模板函数 在此之前，先说明一下模板的概念：模板就是建立通用的模具，大大提高复用性。需要注意的是：模板不可以直接使用，它只是一个框架。 而对函数模板来说，它的作用是建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。具体语法如下： template<typename T> 函数声
C++ 实验三 模板
Rouger7921的博客
11-16 592
文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 一、模板函数（compare） 如果重载的函数，其解决问题的逻辑是一致的、函数体语句相同，只是处理的数据类型不同，那么写多个相同的函数体，是重复劳动，而且还可能因为代码的冗余造成不一致性。使用函数模板可解决这个问题。 1.一般模板函数 函数模板定义语法 语法形式： template <模板参数表> 函数定义 模板参数表的内容 ...
C++学习记录 实验3 模板
CoderJHT的博客
11-15 517
目录一、模板函数（compare）1.1 一般模板函数1.2 特化模板函数二、模板类（Queue或Stack）2.1 模板类2.2 成员模板函数2.3 模板特化2.3.1 模板函数特化2.3.2 模板成员函数特化2.3.3 模板类特化三、模板类（AutoPtr）3.1 构造函数3.2 析构函数3.3 拷贝构造函数3.4 等号、->、*等运算符重载3.5 主函数调用AutoPtr四、实验总结4.1 泛型编程 一、模板函数（compare） 1.1 一般模板函数 下面定义了一个名叫compare的函数模板
模板（C++第三次实验）
Scracs的博客
11-16 805
模板（C++第三次实验）1、模板函数（compare）：1.1 模板的概念1.2 一般模板函数1.3 类B通过public, protected, private等不同方式继承A，在类B的成员函数中测试访问A的成员函数或变量1.4 在类B中添加public, protected, private等不同属性的成员函数或变量，在外部测试访问B的各个成员函数或变量1.5 B以private方式继承A，尝试把A中的部分public成员提升为public2、友元类继承测试概念2.1 设计类A含有私有变量a，在类A中友
第十六章 模板与泛型编程
cherry 的专栏
03-14 261
1.1函数模板的声明 函数模板可以用来创建一个通用的函数，以支持多种不同的形参，避免重载函数的函数体重复设计。它的最大特点是把函数使用的数据类型作为参数。 函数模板的声明形式为： template (参数表) {     函数体 } 其中，template是定义模板函数的关键字；template后面的尖括号不能省略；typename（或class)是
Template 介绍
aixiu9473的博客
01-22 176
1. 模板的概念。 我们已经学过重载(Overloading)，对重载函数而言,C++的检查机制能通过函数参数的不同及所属类的不同。正确的调用重载函数。例如，为求两个数的最大值，我们定义MAX()函数需要对不同的数据类型分别定义不同重载(Overload)版本。 //函数1. int max(int x,int y); {return(x>y)?x:y ;} //函数2...
C++程序设计：谭浩强版——探索VC++编译系统
"启动VC++编译系统-C++程序设计 谭浩强完整版" 本文主要探讨了C++编程语言的起源、特点以及其在程序设计中的重要性，结合了谭浩强的C++程序设计教材，适用于学习C++语言的初学者。C++是从C语言发展而来，旨在增强...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

DreamWendy

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值