面向对象实验5

一、实验名称

模板编程

二、实验目的

         熟悉函数模板与类模板的编程方法。

三、实验原理

函数模板：声明一个类型，在函数调用时发生实际模板函数创建。

类模板：声明一个类型，对象实例创建时发生模板类的创建。

1、编写比较两个数大小的函数MAX。

   1）整数版本

main.cpp文件：

#include <iostream>

#include "Max.h"

using namespace std;

int main() {

    int num1, num2;

    cout << "请输入第一个整数: ";

    cin >> num1;

    cout << "请输入第二个整数: ";

    cin >> num2;

    int result = MAX(num1, num2);

    cout << "两个整数" << num1 << " 和 " << num2 << " 最大的是: " << result << std::endl;

    return 0;

}

Max.cpp文件

#include <iostream>

int MAX(int a, int b) {

    return (a > b) ? a : b;

}

.h文件

#pragma once

int MAX(int a, int b);

1. 使用函数模板

Max1.h文件

#pragma once

#include <iostream>

using namespace std;

template <typename T>

T MAX(T a, T b) {

    return a > b ? a : b;

}

.cpp文件

#include <iostream>

#include "Max1.h"

using namespace std;

int main() {

    int num1, num2;

    cout << "请输入第一个整数: ";

    cin >> num1;

    cout << "请输入第二个整数: ";

    cin >> num2;

    int a = MAX(num1, num2);

    cout << "两个整数" << num1 << " 和 " << num2 << " 最大的是: " << a << endl;

    double num3, num4;

    cout << "请输入第一个小数: ";

    cin >> num3;

    cout << "请输入第二个小数: ";

    cin >> num4;

    double b = MAX(num3, num4);

    cout << "两个小数" << num3 << " 和 " << num4 << " 最大的是: " << b << endl;

    return 0;

}

2、编写单链表的头插法实现类Link，使用类模板的形式实现。单链表的数据节点采用Node类，其数据成员如下，可以存储任意类型的数据。完成Node类和Link类的设计。

template <typename T>

class Node

        {

              public:

                     T data;

                     Node* next;

     }

temp.h文件

#pragma once

#include <iostream>

using namespace std;

// 定义节点类 Node

template <typename T>

class Node {

public:

    T data;

    Node* next;

    // 构造函数初始化节点

    Node(const T& value) : data(value), next(nullptr) {}

};

// 定义链表类 Link

template <typename T>

class Link {

private:

    Node<T>* head; // 链表头指针

public:

    // 构造函数初始化链表

    Link() : head(nullptr) {}

    // 头插法插入节点

    void insertAtBeginning(const T& value) {

        Node<T>* newNode = new Node<T>(value); // 创建新节点

        if (head == nullptr) {

            head = newNode; // 如果链表为空，新节点即为头节点

        }

        else {

            newNode->next = head; // 新节点的下一个节点为当前头节点

            head = newNode; // 更新头指针为新节点

        }

    }

    // 显示链表内容

    void display() {

        Node<T>* temp = head;

        while (temp != nullptr) {

            cout << temp->data << " ";

            temp = temp->next;

        }

        cout << endl;

    }

    // 析构函数释放链表内存

    ~Link() {

        Node<T>* temp;

        while (head != nullptr) {

            temp = head;

            head = head->next;

            delete temp;

        }

    }

};

.cpp文件

#include <iostream>

#include "Max1.h"

#include "temp.h"

using namespace std;

int main()

{

    Link<int> intList; // 创建一个存储整数的链表

    intList.insertAtBeginning(1);

    intList.insertAtBeginning(2);

    intList.insertAtBeginning(3);

    cout << "The list contains: ";

    intList.display(); // 显示链表内容

    return 0;

}

 

3、使用类模板，编写一个能够适应至少int，float两种数据类型的链式队列类（LinkQueue），要求提供对外的五个公有（public）方法：

1）CreateQ（初始化建立带头结点的队列链表）

2）EnterIQ（入队）

3）LeaveQ（出队）

4）ShowQ（遍历显示数据队列数据）

5）DeleteQ（清空队列）

Temp1.h文件

#pragma once

#include <iostream>

using namespace std;

// 定义队列节点类 QueueNode

template <typename T>

class QueueNode {

public:

    T data;

    QueueNode* next;

    // 构造函数初始化节点

    QueueNode(const T& value) : data(value), next(nullptr) {}

};

// 定义链式队列类 LinkQueue

template <typename T>

class LinkQueue {

private:

    QueueNode<T>* front; // 队头指针

    QueueNode<T>* rear;  // 队尾指针

public:

    // 构造函数初始化队列

    LinkQueue() : front(nullptr), rear(nullptr) {}

    // 创建队列

    void CreateQ() {

        if (front == nullptr) {

            front = rear = new QueueNode<T>(0); // 创建头结点

        }

    }

    // 入队

    void EnterQ(const T& value) {

        if (front == nullptr) {

            CreateQ(); // 如果队列为空，先创建头结点

        }

        QueueNode<T>* newNode = new QueueNode<T>(value); // 创建新节点

        rear->next = newNode; // 将新节点连接到队尾

        rear = newNode;      // 更新队尾指针

    }

    // 出队

    void LeaveQ() {

        if (front == nullptr || front == rear) {

            cout << "Queue is empty. Cannot dequeue." << endl;

            return;

        }

        QueueNode<T>* temp = front->next; // 暂存队头指针

        front->next = temp->next;         // 更新队头指针

        delete temp;                      // 释放原队头节点

        if (front->next == nullptr) {

            rear = front; // 如果队列为空，更新队尾指针

        }

    }

    // 遍历显示队列数据

    void ShowQ() {

        if (front == nullptr || front == rear) {

            cout << "Queue is empty." << endl;

            return;

        }

        QueueNode<T>* temp = front->next;

        while (temp != nullptr) {

            cout << temp->data << " ";

            temp = temp->next;

        }

        cout << endl;

    }

    // 清空队列

    void DeleteQ() {

        while (front != nullptr) {

            QueueNode<T>* temp = front;

            front = front->next;

            delete temp;

        }

        rear = nullptr;

    }

    // 析构函数释放队列内存

    ~LinkQueue() {

        DeleteQ();

    }

};

main.cpp文件

#include <iostream>

#include "temp1.h"

using namespace std;

int main()

{

    LinkQueue<int> intQueue; // 创建一个存储整数的队列

    intQueue.EnterQ(5);

    intQueue.EnterQ(1);

    intQueue.EnterQ(2);

    intQueue.EnterQ(3);

    intQueue.EnterQ(4);

    cout << "The queue contains: ";

    intQueue.ShowQ(); // 显示队列内容

    intQueue.LeaveQ(); // 出队一个元素

    cout << "After dequeue: ";

    intQueue.ShowQ();

    intQueue.DeleteQ(); // 清空队列

    cout << "After deletion: ";

    intQueue.ShowQ();

    return 0;

}

函数模版：是一个通用函数，没有类型的参数

模版函数：是函数模版的实例化对象，有类型的参数。