【C++】继承

原创 已于 2024-12-20 21:21:26 修改 · 1.1k 阅读 · 32 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #开发语言

于 2024-06-02 23:53:50 首次发布

文章目录

继承的概念及定义

继承的概念

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。

class Person
{
public:
	void Print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	}
//protected:
private:
	string _name = "Mesar";// 姓名
	int _age = 18;
};
// 继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。这里体现出了
//Student和Teacher复用了Person的成员。下面我们使用监视窗口查看Student和Teacher对象，可
//以看到变量的复用。调用Print可以看到成员函数的复用。

class Student : public Person
{
public:
	void Test()
	{
		//子类可调用父类成员（父类访问类型为protected的情况下）
		//（父类访问类型为private时不可见的情况下）,会继承，但是不可见（大小会继承）
		//cout << "Student：" << _name << endl;
		cout << sizeof(Student)<<endl;

	}

protected:
//public:
	int _stuid; // 学号
};

class Teacher : public Person
{
protected:
//public:
	int _jobid; // 工号
};
  • 如人：每个人都是独立的个体，都有自己的姓名，年龄，但每个人的身份可能是不一样，有学生，老师。身份的不同就有不同的信息，学生有自己的学号，老师有自己的工号。对于大家都有的姓名年龄我们就可以作为一个基类供给学生老师这些类。这就是继承，是代码复用的一种手段。

继承格式

  • 下面我们看到Person是父类，也称作基类。Student是子类，也叫作派生类。
    继承的格式
    继承关系和访问限定
    继承关系和访问限定

继承基类成员访问方式的变化

类成员/继承方式public继承protected继承private继承
基类的public成员派生类的public成员派生类的protected成员派生类的private
基类的protected成员派生类的protected成员派生类的protected成员派生类的private成员
基类的private成员在派生类中不可见在派生类中不可见在派生类中不可见

总结：

  1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私
    有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面
    都不能去访问它。
  2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在
    派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
  3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他
    成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。
  4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过
    最好显示的写出继承方式。
  5. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡
    使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里
    面使用，实际中扩展维护性不强。
  • 看着吓人实际也没啥，实际使用中要被继承的成员变量一般为protected，继承方式为public。

下面提供一些使用演示

// 实例演示三种继承关系下基类成员的各类型成员访问关系的变化  
class Person
{
public:
	void Print()
	{
		cout << _name << endl;
	}
public:
	int _grade = 1;
protected://为继承而生，一般使用时和private类似，以public继承时可以给子类内部使用，外部依旧不可使用。
	string _name="Mesar"; // 姓名
private:
	int _age=18; // 年龄
};



class Student : protected Person
//class Student : private Person
//class Student : public Person
{
public:
	void Print_Student()
	{
		cout << _name << endl;
		cout << _grade << endl;
		//cout << _age << endl;父类为private访问，无法访问
	}

protected:
	int _stunum; // 学号
};

//所以一般都public继承
class Test : public Student
{
public:
	void Print_Test()
	{
		//最初父类（Person）为protected或private，（Student）以private继承，导致访问类型protected和private变成private
		//再去继承（Student）类以无法访问
		cout << _name << endl;
		cout << _grade << endl;
	}
protected:
	int _test = 1;

};

//建议使用public继承
int main()
{
	//public继承时，父类public函数都可使用
	Person p;
	p.Print();

	//改为protected继承后，父类public无法访问
	//Student t;
	//t.Print();

	//Test t1;
	//t1.Print();
	return 0;
}

基类和派生类对象赋值转换

  • 派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。
    赋值转化
  • 基类对象不能赋值给派生类对象。
  • 基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类
    的指针是指向派生类对象时才是安全的。(否则会出现父类指针指向子类成员甚至改变子类成员的操作)

越界情况

  • 注意，派生类赋值基类是不会进行类型转化的（编译器不会进行类型转化返回一个临时变量），这种行为可以理解为天然的。
	Student s;
	Person& sr = s;//说明不会产生临时变量

	double d = 1.99;
	//int& dr = d;//err，不能引用常量
	const int& dr = d;

以上代码就可以对此进行解释。

继承中的作用域

练习代码：

//子类成员将屏蔽父类对同名成员的直接访问
// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是非常容易混淆
class Person
{
public:
	void Print()
	{
		cout << "姓名：" << _name << endl;
		cout << "身份证：" << _num << endl;
	}

protected:
	string _name = "Mesar"; // 姓名
	int _num = 111;//身份证
};

class Student : public Person
{
public:
	void Print()
	{
		cout << " 姓名:" << _name << endl;
		cout << "Student类:" << " 学号:" << _num << endl;
		//可以到类中指定，不推荐写同名成员或函数
		cout << "Person类：" << " 身份证号:" << Person::_num << endl;
		//cout << " 身份证号:" << _num << endl;
	}
protected:
	//与基类的成员同名就构成隐藏
	int _num = 999; // 学号
};

void Test()
{
	Student s1;
	s1.Print();
	s1.Person::Print();
}

int main()
{
	Test();
	return 0;
}
  1. 在继承体系中基类和派生类都有独立的作用域。
  • 父类和子类中都有_num成员，通过调试可以发现他们都有自己对应的值，也就是都有自己独立的作用域
  • 成员函数同理。

独立作用域

  1. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
  • 在父类子类都有_num成员时：在打印_num成员，默认是打印子类的_num，要想打印父类的_num可以指定类域。
  • 成员函数同理
    隐藏

  1. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
    对比

  2. 注意在实际中在继承体系里面最好不要定义同名的成员。

派生类的默认成员函数

6个默认成员函数，“默认”的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类
中，这几个成员函数是如何生成的呢？
下面用Person类作为基类，Student类作为子类进行演示

基类的常用成员函数如下：也就是平常写那套。

class Person
{
public:
	Person(const char* name = "peter")
	//Person(const char* name)
		: _name(name)
	{
		cout << "Person()" << endl;
	}

	Person(const Person& p)
		: _name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}

	Person& operator=(const Person & p)
	{
		cout << "Person operator=(const Person& p)" << endl;
		if (this != &p)
			_name = p._name;

		return *this;
	}

	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name; // 姓名
};
  1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认
    的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
	Student(const char* name="Mesar", int num = 211)
		: Person(name)//必须走初始化列表
		, _num(num)
	{
		cout << "Student()" << endl;
	}
  • 子类的构造函数必须先初始化继承下来的父类那部分，所以需要先调用父类的构造函数，再初始化自己那部分。
  • 如果父类有默认构造，那就可以不用显示去调用，如果没有默认构造，则必须显示调用，否则编译器报错。
    默认构造
    这时只能在子类的构造函数显示调用。
  1. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
	Student(const Student& s)
		: Person(s)//子类可以传给父类（切片）,调用父类的拷贝构造函数来初始化
		, _num(s._num)//处理子类独特有的部分
	{
		cout << "Student(const Student& s)" << endl;
	}
  1. 派生类的operator=必须要调用基类的operator=完成基类的复制。
	Student& operator = (const Student& s)
	{
		cout << "Student& operator= (const Student& s)" << endl;
		if (this != &s)
		{
		    //调用父类的operator =()
		    //这里需要指定类域，因为父子类中的operator =()构成隐藏
			Person::operator =(s); //切片
			_num = s._num;//子类独有部分
		}
		return *this;
	}
  1. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
  • 这里的顺序要与构造函数顺序反一下，先清理子类的资源再清理父类的，而且子类的析构会自动调用父类的析构，不需要自己调用。
  • 父类与子类中的析构函数构成隐藏，在语法上调用需要指定类域调用（实际不需要自己调用）。
    • 因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同。编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。
  1. 派生类对象初始化先调用基类构造再调派生类构造。
  2. 派生类对象析构清理先调用派生类析构再调基类的析构。

派生类的默认成员函数
派生类（Student）常用默认函数：

class Student : public Person
{
public:
	Student(const char* name="Mesar", int num = 211)
		//: Person(name)//必须走初始化列表
		//, _num(num)//处理子类独特有的部分
		:_num(num)
	{
		cout << "Student()" << endl;
	}

	//Student(const char* name, int num)
	//{
	//	Person(name);
	//	_num = num;
	//	cout << "Student()" << endl;
	//}


	Student(const Student& s)
		: Person(s)//子类可以传给父类（切片）,调用父类的构造函数来初始化
		, _num(s._num)
	{
		cout << "Student(const Student& s)" << endl;
	}

	Student& operator = (const Student& s)
	{
		cout << "Student& operator= (const Student& s)" << endl;
		if (this != &s)
		{
		    //调用父类的operator =()
		    //这里需要指定类域，因为父子类中的operator =()构成隐藏
			Person::operator =(s); //切片
			_num = s._num;
		}
		return *this;
	}

	~Student()//先子后父
	{
		//父子类析构函数经编译器处理会变为destrutor，与子类为隐藏函数，需要指定类名
		//Person::~Person();无需自己调用
		cout << "~Student()" << endl;
	}

protected:
	int _num; //学号
};

继承与友元

友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员

class Student;

class Person
{
public:
	friend void Display(const Person& p, const Student& s);
protected:
	string _name; // 姓名
};

class Student : public Person
{
protected:
	int _stuNum; // 学号
};

void Display(const Person& p, const Student& s)
{
	cout << p._name << endl;
	//cout << s._stuNum << endl;//基类友元不能访问子类私有和保护成员
}

int main()
{
	Person p;
	Student s;
	Display(p, s);

	return 0;
}

继承与静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例 。

  • 静态成员并不在类中，也就不会独立继承。按正常方法使用即可。
class Person
{
public:
	Person() { ++_count; }
protected:
	string _name; // 姓名
public:
	static int _count; // 统计人的个数。
};

int Person::_count = 0;


class Student : public Person
{
protected:
	int _stuNum; // 学号
};


class Graduate : public Student
{
protected:
	string _seminarCourse; // 研究科目
};

void TestPerson()
{
	Student s1;
	Student s2;
	Student s3;
	Graduate s4;
	cout << " 人数 :" << Person::_count << endl;
	cout << " 人数 :" << &s1._count << endl;
	Student::_count = 0;
	cout << " 人数 :" << Person::_count << endl;
	cout << " 人数 :" << &s2._count << endl;
	Graduate::_count = 0;
	cout << " 人数 :" << Graduate::_count << endl;
	cout << " 人数 :" << &s4._count << endl;
	//都指向同一个_count，无论派生出多少个子类，都只有一个static成员实例
}

int main()
{
	TestPerson();
	return 0;
}
  • 通过打印各个对象里面的_count的地址发现都是一样的。

复杂的菱形继承及菱形虚拟继承

以上介绍的都是简单的单继承。
单继承
下面介绍多继承：
多继承:

一个子类有两个或以上直接父类时称这个继承关系为多继承

多继承
菱形继承：

菱形继承是多继承的一种特殊情况。

  • 菱形继承是在多继承上演变出来的，是多继承的一种特殊情况。
    菱形继承
//菱形继承
class Person
{
public:
	string _name; // 姓名
};

class Student : public Person
{
protected:
	int _num; //学号
};

class Teacher : public Person
{
protected:
	int _id; // 职工编号
};

class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse; // 主修课程
};

建议：
不要使用菱形继承，原因如下：
菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。在Assistant的对象中Person成员会有两份。

  • 数据冗余：是指Assistant对象中有两份Person的成员。
  • 二义性：是指在Assistant对象中直接无法确定是访问的是哪个父类的成员。

菱形继承
应对以上问题，二义性可以指定类域来确认是谁的成员，但数据冗余无法的问题无法解决。二义性
虚继承：
虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在Student和Teacher的继承Person时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地方去使用。
虚继承

  • 虚拟继承时关键字virtual加在腰部，也就是B，C类。

虚拟继承使用

//菱形虚拟继承
class Person
{
public:
	string _name; // 姓名
};

//在腰部加关键字virtual
class Student : virtual public Person
{
protected:
	int _num; //学号
};

class Teacher : virtual public Person
{
protected:
	int _id; // 职工编号
};

class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse; // 主修课程
};

通过虚继承可以解决菱形继承的二义性和数据冗余的问题，此时
虚继承

  • 观察上面的虚拟菱形继承，发现对象a里面的_name都是指向同一块地址,说明s，t对象中的_name是同一个数据，解决了数据冗余。
  • 而我们修改了s对象的_name,发现a对象中的_name并没有改变，而s对象的_name被改变了，说明a对象中两个虚拟继承了的类中的_a都指向Person类的_name，解决了二义性。

虚继承原理图

菱形虚拟继承的原理

为了更好理解，换了一个简单的菱形继承：A,B,C,D四个类，其成员变量分别为：_a,_b,_c,_d

class A
{
public:
	int _a;
};
// class B : public A
class B : virtual public A
{
public:
	int _b;
};
// class C : public A
class C : virtual public A
{
public:
	int _c;
};
class D : public B, public C
{
public:
	int _d;
};

int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;


	return 0;
}

监视窗口不好观察，所以我们去内存窗口查看
注意

  • VS下数据是按小端存储的，也就是数据倒过来存放如在内存窗口看到的如： 40 21 7b 00
  • 实际为：00 7b 21 40
    菱形继承：
    菱形继承
    菱形虚拟继承：
    菱形虚拟继承
    这里可以分析出d对象中将_a放到的了对象组成的最下面，这个A同时属于B和C(解决了数据冗余)，这里看到B，C类中原本用于存放_a的值的位置不再存放_a的值，而是存放一个虚基表指针，该指针指向该类是虚基表，虚基表中存放了一个偏移量，通过这个偏移量找到_a。
    虚基表和指针
  • 虚基表第一行存放的是与多态相关的内容，先不管他，第二行才是我们需要的偏移量。
  • 内存中的值为十六进制。
  • 一个类共用一张虚基表
    一个类共用一张虚基表

总之，别碰菱形继承，水太深了，把握不住。

C++继承
Wzs040810的博客
02-03 1928
C++继承
C++ 继承
m0_73900674的博客
03-23 2019
C++继承、虚拟继承、组合
C++ 继承详解
热门推荐
TABE_的博客
02-21 1万+
C++ 继承继承语法继承方式改变访问权限名字遮蔽继承时的对象模型无变量遮蔽有变量遮蔽 继承语法 继承的一般语法为： class 派生类名:［继承方式］ 基类名{ 派生类新增加的成员 }; 继承方式 继承方式包括 public（公有的）、private（私有的）和 protected（受保护的），此项是可选的，如果不写，那么默认为 private。不同的继承方式会影响基类成员在派生类中的访问权限。 （1）public继承方式 基类中所有 public 成员在派生类中为 public 属性； 基类中
C++继承详解
DR5200的博客
10-14 2928
文章目录一.继承的概念和定义二.基类和派生类对象赋值转换三.继承中的作用域四.派生类的默认成员函数五.继承和友元六.继承与静态成员七.菱形继承及菱形虚拟继承八.C++编译器如何通过虚继承解决数据冗余和二义性 一.继承的概念和定义 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的
C++继承的使用
JayceSun的博客
04-17 2140
定义 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。 ...
C++ 继承详解及实例代码
09-01
C++继承是面向对象编程中的一个核心概念，它允许创建一个新的类（子类或派生类）基于已存在的类（基类或父类）。通过继承，子类不仅可以获得基类的所有成员（包括数据成员和成员函数），还可以添加新的功能或者重写...
【读书笔记】Effective C++ 条款3：尽可能使用const
最新发布
m0_68617924的博客
12-29 696
同时，对于缓存，我们可能需要微小改动里面的值，即使改变了也依旧认为是const。的重载，const函数和非const函数绝大多数代码都是一样的，因此能否复用呢？在上面的代码中，const仅仅为保证str1指向的字符不被改变，但是我们可以将str1指向的内容改变。（注意：由于书本是比较老的，现在即便是c++98编译也会报错，但是由于是书中的例子，就讲究看一下吧）在这过程中，将const作为让编译器维护常量的口令，将编译器当作你的朋友。理论可以，但是调用非const就意味着需要冒着被改变的风险。
MS-F155_C（CAN 转光纤点对点模块）特点与功能介绍
2401_89785827的博客
12-26 1007
MS-F155_C 是工业级 CAN 总线转光纤传输模块，核心功能是实现 CAN 总线电信号与光纤光信号的双向透明转换，解决 CAN 总线远距离传输衰减、电磁干扰等问题。设备采用点对点通信模式，无需复杂配置，即插即用，支持 CAN1.0/CAN2.0 协议，符合 ISO/DIS 11898 规范，可将 CAN 总线通信距离延长至多模 2000 米、单模 20~40 公里，适配工业现场 CAN 设备远距离组网、数据采集与控制场景，尤其适用于恶劣工矿环境。
Android C++ 学习笔记 2
zhuguanlin121的博客
12-28 767
template.cpp template2.cpp exception.cpp exception2.cpp exception3.cpp exception4.cpp exception5.cpp exception6.cpp exception7.cpp exception8.cpp 19th_smartpointer person.cpp person2.cpp person3.cpp person4.cpp person5.cpp person6.cpp person7.cpp person8.c
【C++转GO】文件操作+协程和管道
saber_andlibert的博客
12-28 1041
协程比线程更加轻量级，因为协程只运行在用户态，表现上只是不同的函数相互转换，不是线程来回转换。另外，C++20也更新了协程，不同的是C++20的协程是无栈协程，相比GO的有栈协程更快。如果使用闭包，协程获取i不通过传参，而是通过捕获，那么当协程执行的时候，i的值可能已经是5了，所以打印结果与预期不符。Go协程是Go语言中的轻量级线程，由Go运行时管理。与传统线程相比，协程更加轻量，创建和销毁的开销更小。我们要知道，切换线程需要更换寄存器的内容，需要进行现场保护和CPU调度，需要由用户态到内核态的转换。
c++ 语言教程——17面向对象设计模式（六）
mwl0223的博客
12-25 879
本文介绍了三种行为型设计模式：访问者模式、中介者模式和解释器模式。访问者模式通过分离数据结构与操作，支持在不修改元素类的情况下添加新操作，适用于操作频繁变化的场景，但会破坏封装性。中介者模式通过引入中介对象来协调多个对象间的交互，降低耦合度，适用于需要集中管理复杂交互的系统。文章通过C++代码示例分别展示了访问者模式在商品计价场景的应用，以及中介者模式在聊天室系统中的实现，分析了各自的优缺点和适用场景。
csp信奥赛C++标准模板库STL案例应用9
王老师青少年编程
12-25 914
csp信奥赛C++标准模板库STL案例应用9
LeetCode 面试经典 150_回溯_单词搜索（104_79_C++_中等）
huayimenghan的博客
12-25 902
LeetCode 面试经典 150_回溯_单词搜索（104_79_C++_中等） 题目描述： 给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。 单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。
Design Patterns In Modern C++ 中文版翻译 第八章 组合
weixin_42603425的博客
12-26 980
复合设计模式允许我们为单个对象和对象集合提供相同的接口。这可以通过显式使用接口成员来完成，也可以通过duck typing（在程序设计中是动态类型的一种风格。在这种风格中，一个对象有效的语义，不是由继承自特定的类或实现特定的接口，而是由"当前方法和属性的集合"决定）来完成。例如基于范围的for循环并不需要您继承任何东西，而是通过实现begin()和end()。正是这些begin()/end()成员允许标量类型伪装成“集合”。
C++ 文件操作详解
即刻启程：订阅博客，解锁嵌入式开发的第一行代码——点亮LED不只是开始，更是通向智能世界的钥匙！
12-27 1016
C++文件操作详解摘要 C++通过<fstream>头文件提供文件操作功能，包含ofstream（写）、ifstream（读）和fstream（读写）三类。文件操作流程包括：1）通过构造函数或open()打开文件并指定模式（如ios::in/out/app/binary等）；2）使用is_open()检查状态；3）文本文件使用<<>>运算符读写，二进制文件使用read()/write()；4）通过seekg()/seekp()定位指针；5）显式或自动关闭文件。注意二进制操
C++ 标准提供的 thread (线程)之 detach() 函数示例(windows平台)
ComputerInBook的专栏
12-24 211
c++线程之 detach() 函数
深度解构 Catlass：昇腾高性能算子开发的 C++ 模板编程范式
嵌入式阿齐Archie
12-26 9262
华为推出的Catlass是昇腾NPU的高性能算子模板库，采用"配置即代码"理念替代传统手写指令的开发模式。该库通过五层抽象模型（Device、Kernel、Block、Tile、Basic）实现硬件透明化，开发者只需配置GemmShape和DispatchPolicy即可生成优化算子。核心特性包括形状驱动的数据切分、双缓冲调度策略，支持自定义数据搬运和访存优化，显著提升缓存利用率和计算效率。虽然模板编程带来编译时间长、调试复杂等挑战，但Catlass通过分层设计平衡了性能与开发效率
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值