c++实验三

最新推荐文章于 2022-03-18 08:17:52 发布
最新推荐文章于 2022-03-18 08:17:52 发布
阅读量500 收藏 1
点赞数
文章标签： vue.js vscode cil
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huanghuali_/article/details/121636016
版权

文章目录

一、模板函数（compare）

所谓函数模板，实际上是建立一个通用函数，它所用到的数据的类型（包括返回值类型、形参类型、局部变量类型）可以不具体指定，而是用一个虚拟的类型来代替（实际上是用一个标识符来占位），等发生函数调用时再根据传入的实参来逆推出真正的类型。这个通用函数就称为函数模板（Function Template）。

在函数模板中，数据的值和类型都被参数化了，发生函数调用时编译器会根据传入的实参来推演形参的值和类型。换个角度说，函数模板除了支持值的参数化，还支持类型的参数化。

一但定义了函数模板，就可以将类型参数用于函数定义和函数声明了。说得直白一点，原来使用 int、float、char 等内置类型的地方，都可以用类型参数来代替。

1.一般模板函数

添加以下代码到queue.h

//函数模板
template<class Type>
int compare(const Type& v1, const Type& v2)
{
   if(v1<v2) return -1;
   if(v1>v2) return 1;
   return 0;
}

添加以下代码到queue.cpp

void testTemplate()
{
    double a = 1.2;
    double b = 1.5;
    cout<<"a=1.2,b=1.5,a<b:"<<compare(a,b)<<endl;       //-1

    double a1=3.0;
    double b1=2.0;
    cout<<"a1=3.0,b1=2.0,a1>b1:"<<compare(a1,b1)<<endl;         //1
}

int main(){
    testTemplate();
    return 0;
}

运行结果：
在这里插入图片描述

2.特化模板函数

有时通用的函数模板不能解决个别类型的问题，我们必须对此进行定制，这就是函数模板的特化。
添加以下代码到queue.h

//函数的特化
template<>
int compare<const char*>(const char * const &v1, const char * const &v2);

添加以下代码到queue.cpp

// 函数的特化
template<>
int compare<const char*>(const char * const &v1, const char * const &v2)
{
    return strcmp(v1,v2);
}
void testTemplate()
{
 //函数的特化
  	char str[10];
    char str1[10];
    strcpy(str,"abc");
    strcpy(str1,"def");
    cout<<"compare abc,def: "<<compare<const char*>(str,str1)<<endl;
    cout<<"compare def,abc "<<compare<const char*>(str1,str)<<endl;

}

int main(){
    testTemplate();
    return 0;
}

运行结果：
在这里插入图片描述

二、模板类Queue或Stack

C++ 中类模板的写法如下：

template <类型参数表>
class 类模板名{
成员函数和成员变量
};

类型参数表的写法如下：

class类塑参数1, class类型参数2, ...

1.模板类（Queue，Stack）

添加以下代码到queue.h

//类模板
template<class Type> class Queue;
template<class Type>
class QueueItem
{
    QueueItem(const Type &t):item(t), next(0){}
    Type item;
    QueueItem * next;
    friend class Queue<Type>;
    //加friend成全局函数
    friend ostream& operator<<(ostream& os, const Queue<Type> &q);         //输出运算符重载
public:
    QueueItem<Type>* operator++(){
        return next;
    }
    Type & operator*(){
        return item;
    }
};

//类模板
template<class Type>
class Queue
{
public:
    Queue():head(0),tail(0){}
    Queue(const Queue& q):head(0),tail(0){      //头和尾赋值为空
        copy_items(q);
    }
    //成员模板函数
    template<class It>
    Queue(It beg, It end):head(0),tail(0){copy_items(beg,end);}
    template<class It>
    void assign(It beg, It end);
    Queue& operator=(const Queue&);
    ~Queue(){destroy();}
    Type& front() {return head->item;}          //要判断是否为空
    const Type& front() const{return head->item;}
    void push(const Type &);
    void pop();
    bool empty() const{return head==0;}

    friend ostream& operator<<(ostream& os, const Queue<Type> &q){
//        os<<"< ";
        QueueItem<Type> * p;
        for(p=q.head;p;p=p->next){
            os<<p->item<<" ";
        }
//        os<<">";
        return os;
    }
    const QueueItem<Type>* Head() const{return head;}
    const QueueItem<Type>* End() const{return (tail==NULL)?NULL:tail->next;}
private:
    QueueItem<Type> * head;
    QueueItem<Type> * tail;
    void destroy();          //删除
    void copy_items(const Queue &);
    template<class It> void copy_items(It beg,It end);
};

2.成员模板函数

类模板中的成员函数放到类模板定义外面写时的语法如下：

template <类型参数表>
返回值类型  类模板名<类型参数名列表>::成员函数名(参数表)
{
   ...
}

用类模板定义对象的写法如下：

类模板名<真实类型参数表> 对象名(构造函数实际参数表);

如果类模板有无参构造函数，那么也可以使用如下写法：

类模板名 <真实类型参数表> 对象名;

添加以下代码到queue.h

template<class Type>
void Queue<Type>::destroy()
{
    while (!empty()) {
        pop();
    }
}

template<class Type>
void Queue<Type>::pop(){
    if(head==0) return;
    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()){
        head = tail = pt;
    }else{
        tail->next = pt;
        tail = pt;
    }
}
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 beg, It end)
{
    destroy();
    copy_items(beg,end);
//    for(It it=beg;it!=end;it++)  //或者
//    {
//        push(*it);
//    }
}

template<class Type> template<class It> void Queue<Type>::copy_items(It beg,It end)     //beg输入的data的首地址data end是data的尾地址data+5
{
    while(beg!=end){
        push(*beg);
        ++beg;
    }
}

3.模板特化：模板函数特化、模板成员函数特化、模板类特化

C++中的模板特化不同于模板的实例化，模板参数在某种特定类型下的具体实现称为模板的特化。模板特化有时也称之为模板的具体化，分别有函数模板特化和类模板特化。
模板成员函数特化：
添加以下代码到queue.h

template<class Type>
void Queue<Type>::pop(){
    if(head==0) return;
    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()){
        head = tail = pt;
    }else{
        tail->next = pt;
        tail = pt;
    }
}

template<>
void Queue<const char*>::push(const char * const &val);
template<>
void Queue<const char*>::pop();

模板类特化：
添加以下代码到queue.cpp

//类部分模板特化
template<>
void Queue<const char*>::push(const char * const &val){
    char* new_item = new char[strlen(val)+1];           //加个结束符号 存得是new_item的地址
    strncpy(new_item,val,strlen(val)+1);
    QueueItem<const char*> * pt = new QueueItem<const char*>(new_item);
    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;
    head = head->next;
//    delete []p->item;  //删除的是new_item
    delete p;
}

实现
添加以下代码到queue.cpp

void testTemplate()
{
    Queue<int> qt;                  //class queue的使用
    double d = 3.3;
    qt.push(1);                     //1
    qt.push(d);                     //3  int定义为整形
    qt.push(10);                    //10
    cout<<qt<<endl;

    short data[5] = {0,3,6,9};
    Queue<int> qi(data,data+5);
    cout<<qi<<endl;                 //0,3,6,9,0
    while(!qi.empty())
    {
       cout<<qi.front()<<" ";           //0,3,6,9,0
        qi.pop();
    }

    vector<int> vi(data,data+5);            //0,3,6,9,0
    qi.assign(vi.begin(),vi.end());
    cout<<endl;
    cout<<qi;

    Queue<const char*> qst;
    char str[10];
    strcpy(str,"I am");     //string copy的缩写
    qst.push(str);
    strcpy(str,"03");
    qst.push(str);
    strcpy(str,"huang");
    qst.push(str);
    cout<<endl<<qst<<endl;

}

int main(){
    testTemplate();
    return 0;
}

运行结果：
在这里插入图片描述

三、模板类AutoPtr

智能指针的一种通用实现技术是使用引用计数。智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象的指针指向同一对象。智能指针主要用于管理在堆上分配的内存，它将普通的指针封装为一个栈对象。当栈对象的生存周期结束后，会在析构函数中释放掉申请的内存，从而防止内存泄漏。

1.构造函数

添加以下代码到autoptr.h

template<class T>
class AutoPtr
{
public:
    AutoPtr(T* pData);//构造函数
};

template<class T>
AutoPtr<T>::AutoPtr(T* pData)
{
    m_pData = pData;        //new一个存用户数的地方
    m_nUser = new int(1);       //new一个初始化的int
}

2.析构函数

添加以下代码到autoptr.h

template<class T>
class AutoPtr
{
public:
    AutoPtr(T* pData);//构造函数
    ~AutoPtr();//生命周期结束 析构函数
};

template<class T>
AutoPtr<T>::~AutoPtr(){
    decrUser();         //用户减一
}

template<class T>
void AutoPtr<T>::decrUser()
{
    --(*m_nUser);
    if((*m_nUser)==0){      //地址为空
        delete m_pData;
        m_pData = 0;
        delete m_nUser;
        m_nUser = 0;
    }
}

3.拷贝构造函数

添加以下代码到autoptr.h

template<class T>
class AutoPtr
{
public:
    AutoPtr(T* pData);//构造函数
    AutoPtr(const AutoPtr<T>& h);			//拷贝构造函数
    AutoPtr<T>& operator=(const AutoPtr<T>& h);//拷贝构造函数
    ~AutoPtr();//生命周期结束 析构函数
};

//拷贝构造函数
template<class T>
AutoPtr<T>::AutoPtr(const AutoPtr<T>& h)
{
    m_pData = h.m_pData;
    m_nUser = h.m_nUser;
    (*m_nUser)++;
}
//拷贝构造函数
template<class T>
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)++;
    return *this;
}

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

添加以下代码到autoptr.h

template<class T>
class AutoPtr
{
public:
    AutoPtr(T* pData);//构造函数
    AutoPtr(const AutoPtr<T>& h);
    AutoPtr<T>& operator=(const AutoPtr<T>& h);
    ~AutoPtr();//生命周期结束 析构函数
    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;
};

5.主函数调用AutoPtr

添加以下代码到main.cpp。
CMatrix.h ，CMatrix.cpp自行添加到文件夹中

#include "autoptr.h"
#include "cmatrix.h"
void TestAutoPtr()
{
    AutoPtr<CMatrix>h1(new CMatrix);
    double data[6] = {1,2,3,4,5,6};
    h1->Create(2,3,data);
    cout<<*h1<<endl;

    AutoPtr<CMatrix> h2(h1);
    (*h2).Set(0,1,10);          //h2进行修改 0行第1列改成10
    cout<<*h1<<endl<<*h2<<endl;             //1 10 3 4 5 6  h2跟h1指向了同一个地方
}


int main(){
//    testTemplate();
    TestAutoPtr();
    return 0;
}

运行结果：
在这里插入图片描述

席惜兮兮
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
青岛科技大学C++实验
12-18
青岛科技大学C++实验 C++考试复习 青岛科技大学C++实验 青岛科技大学C++实验 青岛科技大学C++实验
C++ 类模板
Chris_Home
02-22 421
自己写的一个Queue功能的类模板： /*my_queue.h*/ #include using namespace std; template class QueueItem ; template class Queue ; template class QueueItem{ public: T val ; QueueItem *next ; }; template cl
C++实验三之模板
qq_45749702的博客
11-16 497
文章目录一、模板函数1.1 一般模板函数1.2 特化模板函数二、模板类Queue或Stack2.1 成员模板函数2.2 模板特化三、模板类AutoPtr 一、模板函数 1.1 一般模板函数 在此之前，先说明一下模板的概念：模板就是建立通用的模具，大大提高复用性。需要注意的是：模板不可以直接使用，它只是一个框架。 而对函数模板来说，它的作用是建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。具体语法如下： template<typename T> 函数声
C++实验三——模板
m0_52868215的博客
11-16 437
目录 1. 基础概念 2. 模板函数 2.1 一般模板函数 2.2 特化模板函数 3. 类模板 3.2 成员模板函数 3.3 类模板特化 4.模板类AutoPtr 4.1 构造函数 4.2 析构函数 4.3 运算符重载 5. 小结 1. 基础概念 模板定义：模板是泛型编程的基础，泛型编程即以一种独立于任何特定类型的方式编写代码。模板是创建泛型类或函数...
C++ 程序设计 —— 实验三：模板
DreamWendy的博客
11-18 1018
一、模板函数（compare） 一般模板函数 特化模板函数 二、模板类Queue或Stack 模板类（Queue，Stack） 成员模板函数 模板特化：模板函数特化、模板成员函数特化、模板类特化 三、模板类AutoPtr 构造函数 析构函数 拷贝构造函数 等号、->、*等运算符重载 主函数调用AutoPtr ...
《C++程序设计实验3》
goubixiazimo的博客
03-18 2047
【描述】 晶晶的朋友贝贝约晶晶下周一起去看展览，但晶晶每周的1、3、5必须上课，请帮晶晶判断她能否接受贝贝的邀请，如果能输出YES；如果不能则输出NO。 【输入】 输入贝贝邀请晶晶去看展览的日期，用数字1到7表示从星期一到星期日。 【输出】 如果晶晶可以接受贝贝的邀请，输出YES，否则，输出NO。注意YES和NO都大写！ 【输入示例】 2 【输出示例】 YES （10分） 我的答案： #include <iostream> #include <cmath
C++ 实验三 基本图形生成算法
最新发布
05-01
C++ 实验三 基本图形生成算法
C++实验三 数组.pdf
03-30
C++实验三 数组.pdf
吉林大学C++上机实验报告
07-15
吉林大学C++上机实验报告
c++实验报告
04-01
c++实验报告内容：编写一个程序，从数据文件中读取数据，并计算数据的统计特性。在显示器上输出数据的总数、均值和标准差。
C++实验3代码全套
04-13
1.声明一个动物基类Animal，私有整型成员变量年龄age，请定义一个派生类Dog，在其成员函数SetAge(int n)中直接给age赋值，测试下看是否会出问题？如何解决？ 2.设计一个单基继承的类层次程序，用Person类派生出Student类，增加属性学号index和年级level。Person类中至少有姓名name、年龄age等数据成员，以及构造函数、输出函数等，其余成员函数根据需要添加。在主函数中进行测试。 3.定义一个学生类Student和教师类Teacher，学生类有姓名name、学号index等数据成员，教师类有姓名name、工作证号workID、职称title、课程course、周学时hoursPerWeek等数据成员。再定义一个助教类TeachingAssistant，多继承于学生类和教师类，该类可以使用学生类的全部数据成员，以及教师类的课程和周学时数据成员。要求：每个类提供自定义的构造函数和析构函数，并通过同名函数ShowInfo来显示全部数据成员的值。在主函数中进行测试。 4.声明一个Person，包含姓名name和年龄age等私有数据成员以及相关的成员函数；由它派生出领导类Leader，包含职务position和部门department私有数据成员以及相关的成员函数；再由Person派生出工程师类Engineer，包含职务position和专业speciality私有数据成员以及相关的成员函数；再由Leader和Engineer类派生出主任工程师类Chairman。在主函数中测试各类对象初始化和信息输出，查看是否会出问题？如何解决？
C++实验 第三版
11-14
C++实验练习题 类和对象 派生类与继承 内联函数 对象数组 对象指针
C++实验三.docx
05-22
1 、定义一个时间类Time，有三个私有成员变量Hour、Minute、Second，定义构造函数、析构函数以及用于改变、获取、输出时间信息的公有函数，主函数中定义时间对象，并通过调用各种成员函数完成时间的设定、改变、获取、输出等功能。 ① 按要求完成类的定义与实现。 ② 修改数据成员的访问方式，观察编译结果。 ③ 在Time类中定义一个成员函数，用于实现时间增加一秒的功能，主函数中通过对象调用该函数，并输出增加一秒后的时间信息。 ④ 定义一个普通函数。 拷贝构造函数是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象 在Time类中增加拷贝构造函数的定义，主函数中调用该函数，运用调试工具跟踪，分析整个程序调用构造函数（包括拷贝构造函数）和析构函数的次数；再将f函数的形式参数分别修改为引用参数和指针参数（此时函数代码修改为{t-> PrintTime( );},主函数中调用，再分析此时调用构造函数和析构函数的次数。
c++实验3-1
gonglonghe的博客
04-12 339
一、问题及代码 #include class Time { public: Time(int=0,int=0,int=0); void show_time( ); //根据is_24和from0，输出适合形式-20:23:5/8:23:5 pm/08:23:05 pm void add_seconds(int a); //增加n秒钟 void add_minutes(int b); //
C++ 实验三
weixin_45775594的博客
11-17 599
目录一、实验内容二、代码实现1.queue.h2.queue.cpp3.main.cpp4.实验结果三、知识点总结1.模板的特化2.模板函数3.类模板4.const type& 与 type& 的区别5.operator<<>>运算符重载一定要为友元函数 一、实验内容 1.模板函数（compare） 一般模板函数 特化模板函数 2、模板类Queue或Stack 模板类（Queue，Stack） 成员模板函数 模板特化：模板函数特化、模板成员函数特化、模板类特化 3、模
C++实验三
baidu_41883884的博客
05-31 4799
1．声明一个动物基类Animal，私有整型成员变量年龄age，请定义一个派生类Dog，在其成员函数SetAge(int a)中直接给age赋值，测试下看是否会出问题？如何解决？ #include <iostream> using namespace std; class Animal { public: void setAge(int a) { age = ...
出圈
Codewarning
11-03 412
题目描述 设有n个人围坐一圈并按顺时针方向从1到n编号，从第1个人开始进行1到m的报数，报数到第个m人，此人出圈，再从他的下一个人重新开始1到m的报数，如此进行下去直到所剩下一人为止。 输入 输入多行，每行2个数，分别表示n和m. 输出 计算每一行中最后剩下这个人的编号． 样例输入 10 3 样例输出 4 #include<bits/stdc++.h> using namespace ...
【C++】实验三 函数
阿腾木的小世界
11-24 4162
实践题1 实践题2 实践题3 实践题4 实践题5
操作系统 c/c++实验三答案
01-05
实验三主要是关于进程管理和线程管理的实验。在操作系统中，进程是程序的执行实例，而线程是进程中真正的执行单位。在C/C++语言中，可以通过调用系统提供的API函数来创建进程和线程，并进行相应的管理操作。 在本次...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值