类模板的使用方法

news2025/1/15 8:59:54

目录

类模板的使用方法

1.类模板语法

2.类模板和函数模板区别

3.类模板中成员函数创建时机

4.类函数对象做函数参数

5.类模板和继承

6.类模板成员函数类外实现

7.类模板分文件编写

person.hpp

实现cpp文件：

8.类模板与友元

9.类模板案例

MyArray.hpp

在Cpp文件中展示方式：

类模板的使用方法

1.类模板语法

类模板作用：

建立一个通用类，类中的成员 数据类型可以不具体制定，用一个虚拟的类型来代表。语法:

template<typename T>
类


解释:

template - 声明创建模板

typename - 表面其后面的符号是一种数据类型，可以用class代替

T - 通用的数据类型，名称可以替换，通常为大写字母

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

template<class NameType,class AgeType>
class Person
{
public:
    Person(NameType name,AgeType age)
    {
        this->m_name = name;
        this->m_age = age;
    }

    void ShowPerson()
    {
        cout << "name:" << m_name << ",age:" << m_age << endl;
    }
    NameType m_name;
    AgeType m_age;
};

void test01()
{
    Person<string, int> p1("猴子", 500);
    p1.ShowPerson();
}

//类模板和函数模板相似，在声明模板template后面加类，此类称为类模板

int main()
{
    test01();

    system("pause");

    return 0;
}

2.类模板和函数模板区别

类模板与函数模板区别主要有两点:

1.类模板没有自动类型推导的使用方式

2.类模板在模板参数列表中可以有默认参数

#include <iostream>
using namespace std;
#include<string>
template<class NameType,class AgeType = int>
class Person
{
public:
    Person(NameType name, AgeType age)
    {
        this->m_name = name;
        this->m_age = age;
    }
    void PrintPeson()
    {
        cout << "name:" << m_name << ",age:" << m_age << endl;
    }
    NameType m_name;
    AgeType m_age;
};

//1、类模板没有自动类型推导使用方式
void test01()
{
    //Person p("八戒", 900); 错误，无法用自动类型推导
    Person<string, int> p1("八戒", 900);
    p1.PrintPeson();
}
//2、类模板在模板参数列表中可以有默认参数
void test02()
{
    Person<string> p1("八戒", 900);
    p1.PrintPeson();
}
int main()
{
    test02();
    return 0;
}

3.类模板中成员函数创建时机

类模板中成员函数和普通类中成员函数创建时机是有区别的

普通类中的成员函数一开始就可以创建

类模板中的成员函数在调用时才创建

#include <iostream>
using namespace std;

class Person1
{
public:
    Person1()
    {
        
    }
    void showPerson1()
    {
        cout << "调用的Person1" << endl;
    }
};

class Person2
{
public:
    void showPerson2()
    {
        cout << "调用的Persona2" << endl;
    }
};

template<class T>
class MyClass
{
public:
    T obj;

    void fun1() { obj.showPerson1(); }
    void fun2() { obj.showPerson2(); }
};
//类模板中的成员函数并不是一开始就创建的，在调用时才会去创建
void Test01()
{
    MyClass<Person1> m;
    m.fun1();
   // m.fun2();
    //编译会出错，说明函数调用才会去创建成员函数
}
int main()
{
    Test01();
}

4.类函数对象做函数参数

类模板实例化出的对象，向函数传参的方式

一共有三种传入方式:

1.指定传入的类型!——直接显示对象的数据类型

2.参数模板化——将对象中的参数变为模板进行传递

3.整个类模板化——将这个对象类型 模板化进行传递

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

template<class T1,class T2>
class Person
{
public:
    Person(T1 name,T2 age)
    {
        this->m_name = name;
        this->m_age = age;
    }
    void ShowPerson()
    {
        cout << "姓名：" << this->m_name << " 年龄：" << this->m_age << endl;
    }
    T1 m_name;
    T2 m_age;
};

//1、指定传入类型
void printPerson1(Person<string,int>&p)
{
    p.ShowPerson();
}

void test01()
{
    Person<string, int> p1("高手", 2);
    printPerson1(p1);
}

//2、参数模板化
template<class T1,class T2>
void printPerson2(Person<T1, T2> &p)
{
    p.ShowPerson();

    cout << "T1 的类型为" << typeid(T1).name() << endl;
    cout << "T2 的类型为" << typeid(T2).name() << endl;
}

void test02()
{
    Person<string, int> p2("高高手", 2);
    printPerson2(p2);
}

//3、整个类模板化
template<class T>
void printPerson3(T& p)
{
    p.ShowPerson();
    cout << "T的数据类型为：" << typeid(T).name() << endl;
}

void test03()
{
    Person<string, int> p3("高高高手", 5);
    printPerson3(p3);
}

//通过类模板创建的对象，向函数中进行传参，使用比较广泛的是第一种：指定传入的类型
int main()
{
    test03();
}

5.类模板和继承

当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型

如果不指定，编译器无法给子类分配内存

如果想灵活指定出父类中T的类型，子类也需变为类模板

#include <iostream>
using namespace std;

//类模板与继承
template<class T>
class Base
{
    T m;
};

//class Son1 :Base  错误，必须知道父类中的T类型，才能继承给子类
class Son:Base<int>
{

};

void test01()
{
   // Son S1;
}

//如果想灵活指定父类中T类型，子类也需要变类模板
template<class T1,class T2>
class Son2 :public Base<T2>
{
public:
    Son2()
    {
		cout << "T1的类型为：" << typeid(T1).name() << endl;
		cout << "T2的类型为：" << typeid(T2).name() << endl;
    }
    T1 obj;
};

void test02()
{
    Son2<int,char>S2;
   
}
//总结：如果父类是类模板，子类需要指定出父类中T的数据类型
int main()
{
    test02();
}

6.类模板成员函数类外实现

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


//类模板成员函数类外实现
template<class T1,class T2>
class Person
{
public:
    Person(T1 name, T2 age);
  /*  {
        this->m_name = name;
        this->m_age = age;
    }*/

    void showPerson();
   /* {
        cout << "姓名： " << this.m_name << ",年龄： " << this.m_age << endl;
    }*/
    T1 m_name;
    T2 m_age;
};

//构造函数类外实现
template<class T1,class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
    this->m_name = name;
    this->m_age = age;
}

//模板成员函数类外实现
template<class T1,class T2>
void Person<T1,T2>::showPerson()
{
    cout << "姓名：" << this->m_name << ",年龄：" << this->m_age << endl;
}

void test01()
{
    Person<string,int>p1("猴子",200);
    p1.showPerson();
}

//总结：类模板中成员函数类外实现时，需要加上模板参数列表
int main()
{
    test01();
}

7.类模板分文件编写

类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到

解决方式1：直接包含.cpp源文件

解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制

person.hpp

#pragma once
#include<iostream>
#include<string>
using namespace std;
template<class T1, class T2>
class Person
{
public:
	Person(T1 name, T2 age);
	void showPerson();
	T1 m_name;
	T2 m_age;
};

template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
	this->m_name = name;
	this->m_age = age;
}

template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
	cout << "姓名：" << this->m_name << ",年龄：" << this->m_age << endl;
}

实现cpp文件：

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

//类模板分文件编写问题以及解决

//第一种解决方法,直接包含源文件
//#include"person.cpp"

//第二种解决方法，将.h和.cpp中的内容写到一起，将后缀名改为.hpp文件
#include"person.hpp"


void test01()
{
    Person<string, int> p1("沙僧", 200);
    p1.showPerson();
}
// 总结：主流的解决方式是第二种，将类模板成员函数写到一起，并将后缀名改为.hpp
int main()
{
    test01();
}

8.类模板与友元

全局函数类内实现——直接在类内声明友元即可

全局函数类外实现——需要提前让编译器知道全局函数的存在

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

template<class T1,class T2>
class Person;
//全局函数类外实现
template<class t1, class t2>
void printPerson2(Person<t1, t2> p)
{
	cout << "类外实现——姓名： " << p.m_Name << "类外实现——年龄：" << p.m_Age << endl;
}

template<class T1,class T2>
class Person
{
    //全局函数 类内实现
    friend void printPerson(Person<T1, T2> p)
    {
        cout << "姓名： " << p.m_Name << "年龄：" << p.m_Age << endl;
    }

	//全局函数 类外实现
    //加空模板参数列表
    //如果全局函数 是类外实现，需要让编译器提前知道这个函数的存在
    friend void printPerson2<>(Person<T1, T2>);

public:
    Person(T1 name, T2 age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
private:
    T1 m_Name;
    T2 m_Age;
};


//1.全局函数在类内实现
void test01()
{
    Person<string, int>p("僧人", 21);

    printPerson(p);
}
//2.全局函数类外实现
void test02()
{
	Person<string, int>p("僧人2", 22);

	printPerson2(p);
}
//总结：建议全局函数做类内实现，用法简单，而且编译器可以直接识别

int main()
{
    test02();
}

9.类模板案例

具体实现功能：

1.可以对内置数据类型以及自定义数据类型的数据进行存储
2.将数组中的数据存储到堆区
3.构造函数中可以传入数组的容量
4.提供对应的拷贝构造函数以及operator = 防止浅拷贝问题
5.提供尾插法和尾删法对数组中的数据进行增加和删除
6.可以通过下标的方式访问数组中的元素
7.可以获取数组中当前元素个数和数组的容量

MyArray.hpp

//自己的通用的数组类
#pragma once
#include<iostream>
using namespace std;

/*1.可以对内置数据类型以及自定义数据类型的数据进行存储
2.将数组中的数据存储到堆区
3.构造函数中可以传入数组的容量
4.提供对应的拷贝构造函数以及operator = 防止浅拷贝问题
5.提供尾插法和尾删法对数组中的数据进行增加和删除
6.可以通过下标的方式访问数组中的元素
7.可以获取数组中当前元素个数和数组的容量*/
template<class T>
class MyArray
{
public:
	//有参构造 参数 容量
	MyArray(int capacity)
	{
		//cout << "MyArray的有参构造调用" << endl;
		this->m_Capacity = capacity;
		this->m_Size = 0;
		this->pAddress = new T[this->m_Capacity];
	}
	//拷贝构造
	MyArray(const MyArray& arr)
	{
		//cout << "MyArray的拷贝构造调用" << endl;
		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;
		//this->pAddress = arr.pAddress;  浅拷贝会导致堆区的值冲突

		//深拷贝
		this->pAddress = new T[m_Capacity];

		//将arr中的数据都拷贝过来
		for (int i = 0; i < arr.m_Size; i++)
		{
			this->pAddress[i] = arr.pAddress[i];
		}
	}

	//operator= 防止浅拷贝问题 a=b=c
	MyArray& operator=(const MyArray& arr)
	{
		//cout << "MyArray的 operator= 函数调用" << endl;
		//先判断原来堆区是否有数据，如果有先释放
		if (this->pAddress!=NULL)
		{
			delete[] this->pAddress;
			this->pAddress = NULL;
			this->m_Capacity = 0;
			this->m_Size = 0;
		}

		//深拷贝
		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;
		this->pAddress = new T[arr.m_Capacity];
		for (int i=0;i<arr.m_Size;i++)
		{
			this->pAddress[i] = arr.pAddress[i];
		}
		return *this;
	}

	//尾插法
	void Push_Back(const T& val)
	{
		//判断容量是否等于大小
		if (this->m_Capacity==this->m_Size)
		{
			return;
		}
		this->pAddress[this->m_Size] = val;//在数组末尾插入数据
		this->m_Size++;//更新数组大小
	}

	//尾删法
	void Pop_Back()
	{
		//让用户访问不到最后一个元素，即为尾删，逻辑删除
		if (this->m_Size == 0)
		{
			return;
		}
		this->m_Size--;
	}

	//通过下标方式来访问数组中的元素 arr[0]=100
	T& operator[](int index)
	{
		return this->pAddress[index];
	}

	//返回数组容量
	int getCapacity()
	{
		return this->m_Capacity;
	}
	//返回数组大小
	int getSize()
	{
		return this->m_Size;
	}

	//析构函数
	~MyArray()
	{
		if (this->pAddress!=NULL)
		{
			//cout << "MyArray的析构函数调用" << endl;
			delete[] this->pAddress;
			this->pAddress = NULL;
		}
	}



private:
	T* pAddress;//指针指向堆区开辟的真实数组

	int m_Capacity;//数组容量

	int m_Size;//数组大小
};

在Cpp文件中展示方式：

#include <iostream>
using namespace std;
#include"MyArray.hpp"
#include<string>
void printArray(MyArray<int> &arr)
{
    for (int i = 0; i < arr.getSize(); i++)
    {
        cout << arr[i] << endl;
    }
}

void Test01()
{
    MyArray<int> arr1(5);//有参构造
   
    for (int i = 0; i < 5; i++)
    {
        //利用尾插法向数组中插入数据
        arr1.Push_Back(i);
    }
    cout << "arr1的打印输出为:" << endl;
    printArray(arr1);

    cout << "arr1的容量为:" << arr1.getCapacity() << endl;
    cout << "arr1的大小为:" << arr1.getSize() << endl;
    MyArray<int> arr2(arr1);  //深拷贝

	cout << "arr2的打印输出为:" << endl;
	printArray(arr2);
    arr2.Pop_Back();
    cout << "arr2尾删后:" << endl;
	cout << "arr2的容量为:" << arr2.getCapacity() << endl;
	cout << "arr2的大小为:" << arr2.getSize() << endl;
    // MyArray<int>arr3(100);//有参构造
    // arr3 = arr1; //operator= 调用
}



class Person
{
public:
    Person(){};
    Person(string name, int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    string m_Name;
    int m_Age;
};
void PrintPersonArray(MyArray<Person> &arr)
{
    for (int i = 0; i < arr.getSize(); i++)
    {
        cout << "姓名：" << arr[i].m_Name << ",年龄:" << arr[i].m_Age << endl;
    }
}
void Test02()
{
    MyArray<Person> arr(10);
    Person p1("开天", 1);
    Person p2("裂地", 2);
	Person p3("劈天", 3);
	Person p4("裂天", 4);
	Person p5("封天", 5);
	Person p6("震地", 6);

    //将数据插入到数组中
    arr.Push_Back(p1);
    arr.Push_Back(p2);
    arr.Push_Back(p3);
    arr.Push_Back(p4);
    arr.Push_Back(p5);
    arr.Push_Back(p6);

    PrintPersonArray(arr);
    //输出容量
    cout <<"arr容量为：" << arr.getCapacity() << endl;
    //输出大小
    cout << "arr大小为：" << arr.getSize() << endl;

}
int main()
{
    Test02();
}

//总结：能够利用所学知识点实现通用的数组

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2276922.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

python 轮廓 获取环形区域

python 轮廓 获取环形区域

目录 效果图&#xff1a; 代码&#xff1a; 效果图&#xff1a; 代码&#xff1a; import cv2 import numpy as np# 读取图像 image cv2.imread(rE:\project\jijia\tools_jijia\img_tools\ground_mask.jpg, cv2.IMREAD_GRAYSCALE) # 二值化图像 # 二值化图像 _, binary cv…
阅读更多...
使用 WPF 和 C# 将纹理应用于三角形

使用 WPF 和 C# 将纹理应用于三角形

此示例展示了如何将纹理应用于三角形，以使场景比覆盖纯色的场景更逼真。以下是为三角形添加纹理的基本步骤。 创建一个MeshGeometry3D对象。像往常一样定义三角形的点和法线。通过向网格的TextureCoordinates集合添加值来设置三角形的纹理坐标。创建一个使用想要显示的纹理的 …
阅读更多...
算法妙妙屋-------2..回溯的奇妙律动

算法妙妙屋-------2..回溯的奇妙律动

回溯算法是一种用于系统性地搜索和解决问题的算法&#xff0c;它以深度优先搜索&#xff08;DFS&#xff09;为基础&#xff0c;用来探索所有可能的解决方案。通过递归地尝试候选解并在必要时回退&#xff08;即“回溯”&#xff09;&#xff0c;它能够高效地解决许多涉及组合、…
阅读更多...
如何在Jupyter中快速切换Anaconda里不同的虚拟环境

如何在Jupyter中快速切换Anaconda里不同的虚拟环境

目录 介绍 操作步骤 1. 选择环境&#xff0c;安装内核 2. 注册内核 3. 完工。 视频教程 介绍 很多网友在使用Jupyter的时候会遇到各种各样的问题&#xff0c;其中一个比较麻烦的问题就是我在Anaconda有多个Python的环境里面&#xff0c;如何让jupyter快速切换不同的Pyt…
阅读更多...
《自动驾驶与机器人中的SLAM技术》ch9：自动驾驶车辆的离线地图构建

《自动驾驶与机器人中的SLAM技术》ch9：自动驾驶车辆的离线地图构建

目录 1 点云建图的流程 2 前端实现 2.1 前端流程 2.2 前端结果 3 后端位姿图优化与异常值剔除 3.1 两阶段优化流程 3.2 优化结果 ① 第一阶段优化结果 ② 第二阶段优化结果 4 回环检测 4.1 回环检测流程 ① 遍历第一阶段优化轨迹中的关键帧。 ② 并发计算候选回环对…
阅读更多...
2025/1/12 复习JS

2025/1/12 复习JS

我乞求你别再虚度光阴 ▶ 空心 --------------------------------------------------------------------------------------------------------------------------------- 摘自哔哩哔哩听课笔记。 01 上篇&#xff1a;核心语法 1.基于页面效果的操作 <!DOCTYPE html>…
阅读更多...
初学stm32 --- II2C_AT24C02，向EEPROM中读写数据

初学stm32 --- II2C_AT24C02，向EEPROM中读写数据

目录 IIC总线协议介绍 IIC总线结构图 IIC协议时序 1. ACK&#xff08;Acknowledge&#xff09; 2. NACK&#xff08;Not Acknowledge&#xff09; IO口模拟II2C协议 发送起始信号&#xff1a; 发送停止信号&#xff1a; 检测应答信号&#xff1a; 发送应答信号&#x…
阅读更多...
Angular-生命周期及钩子函数

Angular-生命周期及钩子函数

什么是生命周期 Angular 创建和渲染组件及其子组件&#xff0c;当它们绑定的属性发生变化时检查它们&#xff0c;并在从 DOM 中移除它之前销毁它们。生命周期函数通俗的讲就是组件创建、组件更新、组件销毁的时候会触发的一系列的方法。当 Angular 使用构造函数新建一个组件或…
阅读更多...
vue（五）基础语法--循环遍历指令

vue（五）基础语法--循环遍历指令

目录 简单数据的处理&#xff08;常用&#xff09; 复杂数据&#xff08;json数据&#xff09; v-for 与对象 通过key管理状态 Key的来源 这一节类同于vue&#xff08;四&#xff09;基础语法--条件渲染-CSDN博客 &#xff0c;本质都是那些基础语句语法的实现。 简单介绍 …
阅读更多...
【全套】基于分类算法的学业警示预测信息管理系统

【全套】基于分类算法的学业警示预测信息管理系统

【全套】基于分类算法的学业警示预测信息管理系统 【摘 要】 随着网络技术的发展基于分类算法的学业警示预测信息管理系统是一种新的管理方式&#xff0c;同时也是现代学业预测信息管理的基础&#xff0c;利用互联网的时代与实际情况相结合来改变过去传统的学业预测信息管理中…
阅读更多...
解决线程安全问题，Lock锁，死锁以及如何避免，线程的通信和线程池

解决线程安全问题，Lock锁，死锁以及如何避免，线程的通信和线程池

如何解决线程安全问题 当多个线程共享一个资源时&#xff0c;则可能出现线程安全问题。 java中解决线程安全的方式有三种 第一种: 同步代码块 第二种: 同步方法 第三种: Lock 同步代码块 synchronized(锁对象){ 需要同步的代码。 } synchronized 同步的意思 锁对象可以是任…
阅读更多...
源码编译安装httpd 2.4，提供系统服务管理脚本并测试（两种方法实现）

源码编译安装httpd 2.4，提供系统服务管理脚本并测试（两种方法实现）

方法一&#xff1a;使用 systemd 服务文件 sudo yum install gcc make autoconf apr-devel apr-util-devel pcre-devel 1.下载源码 wget https://archive.apache.org/dist/httpd/httpd-2.4.46.tar.gz 2.解压源码 tar -xzf httpd-2.4.46.tar.gz 如果没有安装tar 记得先安装…
阅读更多...
基于微信小程序的智能停车场管理系统设计与实现（LW+源码+讲解）

基于微信小程序的智能停车场管理系统设计与实现（LW+源码+讲解）

专注于大学生项目实战开发,讲解,毕业答疑辅导&#xff0c;欢迎高校老师/同行前辈交流合作✌。 技术范围&#xff1a;SpringBoot、Vue、SSM、HLMT、小程序、Jsp、PHP、Nodejs、Python、爬虫、数据可视化、安卓app、大数据、物联网、机器学习等设计与开发。 主要内容&#xff1a;…
阅读更多...
LabVIEW驱动电机实现样品自动搜索

LabVIEW驱动电机实现样品自动搜索

利用LabVIEW控制电机驱动相机在XY平面上进行扫描&#xff0c;以检测样品位置。样品最初可能位于相机视野范围之外&#xff0c;需要实现自动搜索样品位置并完成精确定位扫描的功能。该系统需具有以下特点&#xff1a; 高效搜索&#xff1a;能够快速确定样品位置&#xff0c;缩短…
阅读更多...
excel 整理表格，分割一列变成多列数据

excel 整理表格，分割一列变成多列数据

数据准备 对于很多系统页面的数据是没有办法下载的。 这里用表格数据来举例。随便做数据的准备。想要看excel部分的可以把这里跳过&#xff0c;从数据准备完成开始看。 需要一点前端基础知识&#xff0c;但不多&#xff08;不会也行&#xff09;。 把鼠标放在你想要拿到本地的…
阅读更多...
MAC AndroidStudio模拟器无网络

MAC AndroidStudio模拟器无网络

先确认PC端是正常访问网络的&#xff1b; 模拟器端修改Wifi设置&#xff1a;设置 - 网络和互联网 - WALN设置 按照上图修改&#xff1b; IP设置&#xff1a;从DHCP修改为静态&#xff0c;IP地址&#xff1a;10.0.2.16 &#xff0c;网关&#xff1a;10.0.2.2 &#xff0c; DNS…
阅读更多...
【Linux系统】Ext系列磁盘文件系统一

【Linux系统】Ext系列磁盘文件系统一

0. 从快递系统引入文件系统 理解文件系统&#xff1a;菜鸟驿站的类比 在日常生活中&#xff0c;我们常常会使用到快递服务来寄送和接收包裹。这个过程虽然看似简单&#xff0c;但背后却有着一套复杂而有序的管理系统在支撑。今天&#xff0c;我们将通过一个类比——将文件系统…
阅读更多...
1Hive概览

1Hive概览

1Hive概览 1hive简介2hive架构3hive与Hadoop的关系4hive与传统数据库对比5hive的数据存储 1hive简介 Hive是基于Hadoop的一个数据仓库工具&#xff0c;可以将结构化的数据文件映射为一张数据库表&#xff0c;并提供类SQL查询功能。 其本质是将SQL转换为MapReduce/Spark的任务进…
阅读更多...
Elasticsearch入门学习

Elasticsearch入门学习

Elasticsearch是什么 Elasticsearch 是一个基于 Apache Lucene 构建的分布式搜索和分析引擎、可扩展的数据存储和矢量数据库。 它针对生产规模工作负载的速度和相关性进行了优化。 使用 Elasticsearch 近乎实时地搜索、索引、存储和分析各种形状和大小的数据。 特点 分布式&a…
阅读更多...
[读书日志]8051软核处理器设计实战（基于FPGA）第七篇：8051软核处理器的测试（verilog+C）

[读书日志]8051软核处理器设计实战（基于FPGA）第七篇：8051软核处理器的测试（verilog+C）

6. 8051软核处理器的验证和使用 为了充分测试8051的性能&#xff0c;我们需要测试每一条指令。在HELLO文件夹中存放了整个测试的C语言工程文件。主函数存放在指令被分为五大类&#xff0c;和上面一样。 打开后是这样的文件结构。HELLO.c是主文件&#xff0c;这是里面的代码&am…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023