FP-14 继承——派生类

最新推荐文章于 2023-03-14 13:36:26 发布
最新推荐文章于 2023-03-14 13:36:26 发布
阅读量215 收藏
点赞数
分类专栏： FP(Further Programming) 文章标签： c++ oop inheritance
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51393126/article/details/115871782
版权

Lecture 14 继承——派生类

继承的基本概念

在开发一个新软件时，把现有软件或软件的一部分拿过来用称为软件复用。

目前，不加修改地直接复用已有软件比较困难。已有软件的功能与新软件所需要的功能总是有差别的。解决这个差别有下面的途径：

  • 修改已有软件的源代码，它的缺点是：

    • 需读懂源代码，可靠性差、易出错，有时源代码难以获得

  • 继承机制（Inheritance）：

    • 在定义一个新的类时，先把已有的一个或多个类的功能全部包含进来，然后在新的类中再给出新功能的定义或对已有类的某些功能重新定义。
    • 不需要已有软件的源代码，属于目标代码复用！

基类与派生类

在继承关系中存在两个类：基类（或称父类）和派生类（或称子类）。派生类拥有基类的所有成员，并可以

  • 定义新的成员，或

  • 对基类的一些成员（成员函数）进行重定义。

继承分为：单继承和多继承

  • 单继承：一个类只有一个直接基类。

  • 多继承：一个类有多个直接基类。

继承对程序设计的支持

继承机制除了支持软件复用外，它还具有下面的作用：

  • 对处理的对象按层次进行分类。

    • 有利于问题的描述和解决。

  • 对概念进行组合

    • 给新类的设计带来便利。

  • 支持软件的增量开发。（版本升级）

    • 这给软件开发和维护带来便利。

单继承

在定义单继承时，派生类只能有一个直接基类，其定义格式如下：

class <派生类名>：[<继承方式>] <基类名>
{ <成员说明表>
};

  • <派生类名>为派生类的名字。

  • <基类名>为直接基类的名字。

  • <成员说明表>是在派生类中新定义的成员，其中包括对基类成员的重定义。

  • <继承方式>用于指出从基类继承来的成员在派生类中对外的访问控制

class A //基类
{		int x,y;
	public:
		void f();
		void g();
};
class B: public A //派生类
{		int z; //新成员
	public:
		void h(); //新成员
};

派生类除了拥有新定义的成员外，还拥有基类的所有成员（基类的构造函数、析构函数和赋值操作符重载函数除外）。例如：

class A //基类
{		int x,y;
	public:
		void f();
		void g();
};
class B: public A //派生类
{		int z; //新成员
	public:
		void h(); //新成员
};

b.f();   //A类中的f
b.g();  //A类中的g
b.h();  //B类中的h

定义派生类时一定要见到基类的定义。

class A;  //声明
class B: public A  //Error
{  int z;
  public:
   void h() { g(); }  //Error，编译程序不知道基类中
				       //是否有函数g以及函数g的原型。
};
......
B b; //Error，编译无法确定b所需内存空间的大小。

如果在派生类中没有显式说明，基类的友元不是派生类的友元；如果基类是另一个类的友元，而该类没有显式说明，则派生类也不是该类的友元。

在派生类中访问基类成员

C++中，派生类不能直接访问基类的私有成员。

class A
{		int x,y;
	public:
		void f();
		void g() { ... x ，y ... }
};
class B: public A
{		int z;
	public:
		void h() 
		{	... x，y ...  //Error，x、y为基类的私有成员。
			f();  //OK
			g();  //OK，通过函数g访问基类的私有成员x和y。
		}
};

继承与封装的矛盾

在派生类中定义新的成员函数或对基类已有成员函数重定义时，往往需要直接访问基类的一些private成员（特别是private数据成员），否则新的功能无法实现。

类的private成员是不允许外界使用的（数据封装）！

这样就带来了继承与封装的矛盾。

实际上，有了继承机制以后，一个类的成员有两种被外界使用的场合：

  • 通过类的对象（实例）使用

  • 在派生类中使用

class A
{ ......
    m
};
class B: public A
{ ......
   f() { ... m ...} //通过派生类使用A的成员m
};
void g()
{ A a;
   ... a.m ... //通过A的对象（实例）使用A的成员m
}

在派生类中访问基类成员（protected访问控制）

在C++中，除了public和private，还提供了另外一种类成员访问控制：protected，

  • 用protected说明的成员不能通过对象使用，但可以在派生类中使用。

  • protected访问控制缓解了封装与继承的矛盾

C++类向外界提供两种接口：

  • public：对象的使用者（类的实例用户）

  • public+protected：派生类

class A
{	protected:
		int x,y;
	public:
		void f();
};
class B: public A
{		......
		void h()
		{	f();  //OK
			... x ...  //OK
			... y ...  //OK
		}
};
void g()
{	A a;
	a.f();  //OK
	... a.x ...  //Error
	... a.y ...  //Error
}

  • 引进protected成员访问控制后，基类的设计者必须要慎重地考虑应该把那些成员声明为protected。

  • 一般情况下，应该把今后不太可能发生变动的、有可能被派生类使用的、不宜对实例用户公开的成员声明为protected！

派生类成员标识符的作用域

派生类对基类成员的访问除了受到基类的访问控制的限制以外，还要受到标识符作用域的限制。

对基类而言，派生类成员标识符的作用域是嵌套在基类作用域中的。

class A
{  ......
    void f() { g(); } //Error!
    ......
}

class B:public A
{ ......
   void g() { f(); } //OK
}

如果派生类中定义了与基类同名的成员，则基类的成员名在派生类的作用域内不直接可见（被隐藏，Hidden）。访问基类同名成员时要用基类名受限。例如:

class A //基类
{		int x,y;
	public:
		void f();
		void g();
};

class B: public A
{		int z;
  public:
		void f();
		void h()
		{	f();  //B类中的f
			A::f();  //A类中的f
		}
};

即使派生类中定义了与基类同名但参数不同的成员函数，基类的同名函数在派生类的作用域中也是不直接可见的，可以用基类名受限方式来使用之：

class A //基类
{		int x,y;
	public:
		void f();
		void g();
};

class B: public A
{		int z;
	public:
		void f(int); //不是重载A的f！ 
		void h() 
		{	f(1);  //OK
			f();  //Error
			A::f();  //OK
		}
};

也可以在派生类中使用using声明把基类中某个的函数名对派生类开放：

class A //基类
{		int x,y;
	public:
		void f();
		void g();
};

class B: public A
{		int z;
	public:
		using A::f;
		void f(int); 
		void h() 
		{	f(1);  //OK
			f();  //OK，等价于A::f();
		}
};

基类成员在派生类中对外的访问控制（继承方式）

在C++中，派生类拥有基类的所有成员。问题是：

  • 基类的成员在派生类中对外的访问控制是什么？即，

  • 派生类的用户能访问基类的哪些成员？

上面的问题由基类的访问控制与继承方式共同决定。继承方式在定义派生类时指定：

class <派生类名>：[<继承方式>] <基类名>
{ <成员说明表>
};

  • 继承方式可以是：public、private和protected。

  • 默认的继承方式为：private。

继承方式的含义

基类成员 派生类 继承方式publicprivateprotected
publicpublic不可直接访问protected
privateprivate不可直接访问private
protectedprotected不可直接访问protected
class A
{	public:
		void f();
	protected:
		void g();
	private:
		void h();
};
class B: public A
{ //f为public
   //g为protected
   //h为不可直接访问
   public:
		void q() 
		{ f(); //?
		   g(); //?
		   h(); //?
		}
};

class C: public B
{	public:
		void r()
		{	f();  //OK
			g();  //OK
			h();  //Error
		     q();  //?
     }
};
void func()
{ B b;
   b.f();  //OK
   b.g(); //Error
   b.h(); //Error
   b.q(); //?
}

?跟B的继承方式无关！

继承方式的调整

class A
{  public:
	void f1();
	void f2();
	void f3();
  protected:
	void g1();
	void g2();
	void g3();
};
class B: private A
{ public:
	A::f1;  //把f1调整为public
	A::g1;  //把g1调整为public
		 //是否允许弱化基类的访问控制要视具体的实现而定
  protected:
	A::f2; //把f2调整为protected
	A::g2; //把g2调整为protected
   ......
};

子类型

对用类型T表达的所有程序P，当用类型S去替换程序P中的所有的类型T时，程序P的功能不变，则称类型S是类型T的子类型。

  • 类型T的操作也适合于类型S。

  • 在需要T类型数据的地方可以用S类型的数据去替代（类型S的值可以赋值或作为函数参数传给T类型变量）。

在C++中，把类看作类型，把以public方式继承的派生类看作是基类的子类型。

  • 对基类对象能实施的操作也能作用于派生类对象。

  • 在需要基类对象的地方可以用派生类对象去替代（派生类对象可以赋值或作为函数参数传给基类变量） 。

对于下面的两个类A和B

class A //基类
{	  int x,y;
	public:
	  void f() { x++; y++; }
	  ......
};
class B: public A //派生类
{	  int z;
	public:
	  void g() { z++; } 
     ......
};

下面的操作是合法的：

A a;
B b;
b.f(); //OK，基类的操作可以实施到派生类对象
a = b;  //OK，派生类对象可以赋值给基类对象，属于派生类
	      //但不属于基类的数据成员将被忽略
A *p = &b;  //OK，基类指针变量可以指向派生类对象
......
void func1(A *p); 
void func2(A &x);
void func3(A x);
func1(&b); func2(b); func3(b); //OK

下面的操作是不合法的：

A a;
B b;
a.g(); //Error，a没有g这个成员函数。
b = a;  //Error，它将导致b有不一致的成员数据
		//（a中没有这些数据）。
B *q = &a;  //Error，“q->g();”会修改不属于a的数据！
......
void func1(B *p); 
void func2(B &x);
void func3(B x);
func1(&a); func2(a); func3(a); //Error

派生类对象的初始化和消亡处理

派生类对象的初始化由基类和派生类共同完成：

  • 从基类继承的数据成员由基类的构造函数初始化；

  • 派生类的数据成员由派生类的构造函数初始化。

当创建派生类的对象时，

  • 先执行基类的构造函数，再执行派生类构造函数。

  • 默认情况下，调用基类的默认构造函数，如果要调用基类的非默认构造函数，则必须在派生类构造函数的成员初始化表中指出。

包含成员对象的对象消亡时，

  • 先调用本身类的析构函数，执行完后会自动去调用基类的析构函数。
class A
{		int x;
	public:
		A() { x = 0; }
		A(int i) { x = i; }
};
class B: public A
{		int y;
	public:
		B() { y = 0; }
		B(int i) { y = i; }
		B(int i, int j):A(i) { y = j; }
};
......
B b1;  //执行A::A()和B::B()，b1.x等于0，b1.y等于0。
B b2(1);  //执行A::A()和B::B(int)，b2.x等于0，b2.y等于1。
B b3(1,2);  //执行A::A(int)和B::B(int,int)，b3.x等于1，
			//b3.y等于2。

对未提供任何构造函数的派生类，编译程序会隐式地为之提供一个默认构造函数，其作用是负责调用基类的构造函数。

对未提供析构函数的派生类，编译程序也会隐式地为之提供一个析构函数，该析构函数的作用是负责调用基类的析构函数。

如果一个类D既有基类B、又有成员对象类M，则

  • 在创建D类对象时，构造函数的执行次序为：B->M->D

  • 当D类的对象消亡时，析构函数的执行次序为：D->M->B

派生类拷贝构造函数：

  • 派生类的隐式拷贝构造函数（由编译程序提供）将会调用基类的拷贝构造函数。

  • 派生类自定义的拷贝构造函数在默认情况下则调用基类的默认构造函数。需要时，可在派生类自定义拷贝构造函数的“成员初始化表”中显式地指出调用基类的拷贝构造函数。

class A {	...... };
class B: public A
{		......
	public:
B() { ...... }
		B(const B& b):A(b)  //调用A类的拷贝构造函数
		{	...... //用b对this的派生类成员进行初始化
			
		}
}; 
B b1;
B b2(b1);

派生类对象的赋值操作

派生类隐式的赋值操作除了对派生类成员进行赋值外，还将调用基类的赋值操作对基类成员进行赋值。

派生类自定义的赋值操作符重载函数不会自动调用基类的赋值操作，需要在自定义的赋值操作符重载函数中显式地指出。

class A {	...... };
class B: public A
{		......
	public:
		B& operator =(const B& b)
		{	if (&b == this) return *this;  //防止自身赋值。
			 *(A*)this = b; //调用基类的赋值操作符对基类成员
						          //进行赋值。也可写成： 
						          //this->A::operator =(b); 
			...... //对派生类的成员赋值
			return *this;
		}
}; 
......
B b1,b2;
b1 = b2;

实例：一个公司中的职员类和部门经理类的设计。

class Employee //普通职员类
{		String name; //String为字符串类。
		int salary;
	public:
		Employee(const char *s, int n=0):name(s) 
		{	salary = n; 
		}
		void set_salary(int n) { salary = n; }
		int get_salary() const { return salary; }
		String get_name() const { return name; }
};

const int MAX_NUM_OF_EMPS=20;
class Manager: public Employee //部门经理类
{		Employee *group[MAX_NUM_OF_EMPS];
		int num_of_emps;
	public:
		Manager(const char *s, int n=0): Employee(s,n) 
		{ num_of_emps = 0; 
		}
		bool add_employee(Employee *e);
		bool remove_employee(Employee *e); 
		int get_num_of_emps() { return num_of_emps; }
};

Manager m("Mark",4000); //创建一个经理对象Mark
cout << "Mark's salary is " << m.get_salary() << '.' << endl; //显示经理Mark的工资
Employee e1("Jack",1000),e2("Jane",2000); //创建职员对象Jack和Jane
m.add_employee(&e1); //把职员Jack纳入经理Mark的管理
m.add_employee(&e2); //把职员Jane纳入经理Mark的管理
cout<< "Number of employees managed by Mark is " << m.get_num_of_emps() << '.' << endl; //显示经理Mark的管理人数
m.remove_employee(&e1); //职员Jack脱离经理Mark的管理
......
Jacy_CSer
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 继承与派生（一）
yh的博客
03-25 2491
1. 继承与派生概述 1.1 继承与派生是同一过程从不同的角度看 保持已有类的特性而构造新类的过程称为继承 在已有类的基础上新增自己的特性而产生新类的过程称为派生 被继承的已有类称为基类（或者父类） 派生出的新类称为派生类（或子类） 直接参与派生出某类的基类称为直接基类 基类的基类甚至更高的基类称为间接基类 继承的目的：实现设计与代码的重用 派生的目的：当新的问题出现，原有程序无法...
15.7继承中的类作用域
weixin_44897707的博客
11-04 185
继承中的类作用域 ①派生类的作用域嵌套在基类作用域中 每个类定义自己的作用域，在这个作用域内我们定义类的成员。当存在继承关系时，派生类和基类的作用域会发生嵌套，派生类的作用域嵌套在基类的作用域之中。 如果一个名字再派生类的作用域中无法正确解析，则编译器将继续再外层的基类作用域中寻找改名字的定义。 如： //isbn在基类Quote中，DiscQuote是Quote的派生类，BulkQuote是DiscQoute派生类 BulkQuote bulk; cout << bulk.isbn(); 名
南京大学-高级程序设计复习总结
thdlrt的博客
03-14 524
南京大学高级程序设计期末复习总结，c++面向对象编程
C++基础——类继承时的作用域嵌套
一个小孩
05-29 1545
引言： 在继承情况下，派生类的作用域嵌套在基类作用域中：如果不能在派生类作用域中确定名字，就在外围基类作用域中查找该名字的定义。 正是这种类作用域的层次嵌套使我们能够直接访问基类的成员,就好像这些成员是派生类成员一样： Bulk_item bulk; cout << bulk.book() << endl; 名字book的使用将这样确定[先派生->后基类]： 1)bulk是Bulk_item类对象，在Bulk_item类中查找，找不到名字book。 2)因为从It
关于ILRunTime + FGUI 组合使用的补充
hongzj001的博客
04-14 339
ILRunTime+Fgui结合使用踩坑
继承与派生(Part Ⅰ)
Miss Z的博客
01-16 417
面向对象程序设计有4个主要特点：抽象、封装、继承和多态性 面向对象计算强调软件的可重用性。C++语言提供了类的继承机制，解决了软件重用问题。 在C++中可重用性是通过"继承"这一机制来实现的。因此，继承是C++的一个重要组成部分。 在C++中所谓"继承"就是在一个已存在的类的基础上建立一个新的类。已存在的类称为"基类"或"父类"。新建立的类称为"派生类"或"子类"。
FP-growth 算法（Python语言实现）
08-13
FP-growth算法是一种高效的数据挖掘方法，主要用于在大型数据库中发现频繁项集和关联规则。在Python环境中，我们可以使用各种库来实现FP-growth，其中最常见的是`mlxtend`和`apyori`库。本文将深入探讨FP-growth算法...
FP_fp_fp-growth_
10-04
FP-Growth算法是一种在数据挖掘领域广泛使用的关联规则学习算法，尤其在处理大规模交易数据库时，它的效率表现优秀。此算法由Han、Pei和Yin于2000年提出，主要目的是找出频繁项集并挖掘有趣的关联规则。Python语言...
fp-ts-remote-data：fp-ts的远程数据类型
02-15
RemoteData类型 安装 NPM： npm i fp-ts-remote-data 纱线： yarn add fp-ts-remote-data 对等依赖 图书馆 版本 p ^2.9.0 文献资料 上的文档
python-fp-growth-master.zip
08-02
Usage of the module is very simple. Assuming you have some iterable of ... from fp_growth import find_frequent_itemsets for itemset in find_frequent_itemsets(transactions, minsup): print itemset
QFP PQFP LQFP TQFP封装形式及PCB详解！
热门推荐
u014073301的博客
06-28 2万+
画PCB时，会发现很多的集成电路都是QFP封装，比如很多的单片机都有这种封装。各个器件商会在自己的数据手册中说明他的器件是QFP，LQFP或TQFP，然后，有的给出封装尺寸图，有的则不给。那么，同一种封装，引脚间距是固定的吗，这些QFP,LQFP,TQFP相互之间的封装尺寸一样吗，相同引脚个数的这些封装可不可以通用，他们之间到底有什么区别？我现在还不是很清楚，但是我找了些资料，现在就开始研究，呵呵
派生类继承时的作用域
Crossown的博客
03-19 211
可以这么理解：派生类的作用域嵌套在其继承的基类的作用域之中，类似于下图： 名字冲突与继承： 使用基类指针(或引用)时默认指向外层，如果遇到了加上virtual关键字的成员函数就会优先指向内层。 使用派生类的指针(或引用)时，默认指向内层，若内层内没有该成员则会向外层查找。 使用派生类对象来访问成员函数时，派生类成员函数会覆盖掉同名的基类函数。 ...
派生类成员的标识与访问
lzyoung004的博客
06-02 613
对派生类的成员按访问属性可以分为： 1）不可访问成员 从派生类基类的私有成员继承而来，派生类的对象模块没有办法访问。2）private成员 派生类内部可以访问，建立派生类对象模块无法访问，继续派生就变不可访问成员。3）protected成员 与2）相似 不同之处在于 继续派生就可以变成私有成员或保护成员。4）public成员 略一、作用域分辨符 1. 在不同的作用域声明的标识符存在
常见的IC封装形式大全
dayzo的博客
05-23 8137
常见的封装材料有：塑料、陶瓷、玻璃、金属等，现在基本采用塑料封装。 按封装形式分：普通双列直插式，普通单列直插式，小型双列扁平，小型四列扁平，圆形金属，体积较大的厚膜电路等。 按封装体积大小排列分：最大为厚膜电路，其次分别为双列直插式，单列直插式，金属封装，双列扁平，四列扁平为最小。 封装的历程变化：TO->DIP->PLCC->QFP->BGA->CSP 1、 DIP（Dual In-line Package）双列直插式封装 插装型封装之一，引脚从封装两侧引出 2、 SIP
c++ 默认继承_C++学习刷题13--继承的实现、继承的方式
weixin_39964819的博客
11-24 556
一、前言本部分为C++语言刷题系列中的第13节，主要讲解这几个知识点：继承的实现、继承的方式。欢迎大家提出意见、指出错误或提供更好的题目！二、知识点讲解知识点1：继承的实现，可以理解派生类拥有成员的组成· 类之间的继承关系反映的是一般与特殊的关系，"一般"对应的是基类，"特殊"对应的派生类。因此，派生类是基类的一种，基类的指针或引用可以指向派生类对象。· C++语言支持多继承，即一个基类可以具有多...
FP-01 数据抽象与封装概述
qq_51393126的博客
04-07 555
Lecture 01 数据抽象与封装概述 抽象与封装 抽象与封装是两个重要的程序设计手段，主要是用来驾驭程序的复杂度，便于大型程序的设计、理解与维护。 对于一个程序实体而言， 抽象是指该程序实体的外部可观察到的行为，不考虑该程序实体的内部是如何实现的。（控制复杂度） 封装是指把该程序实体内部的具体实现细节对使用者隐藏起来，只对外提供一个接口。（信息保护） 主要的程序抽象与封装机制包括： 过程抽象与封装 数据抽象与封装 过程抽象与封装 过程抽象 用一个名字来代表一段完成一定功能的程序代码，代码的使用
FP-22 输入/输出（面向对象途径）
qq_51393126的博客
05-27 518
Lecture 22 输入/输出（面向对象途径） 输入/输出（I/O）概述 输入/输出（简称I/O）是程序的一个重要组成部分： 程序运行所需要的数据往往要从外设（如：键盘、文件等）得到 程序的运行结果通常也要输出到外设（如：显示器、打印机、文件等）中去。 在C++中，输入/输出操作不是语言定义的成分，而是由具体的实现作为标准库的功能来提供。 在C++中，输入/输出是一种基于字节流的操作： 在进行输入操作时，可把输入的数据看成逐个字节地从外设流入到计算机内存。 在进行输出操作时，则把输出的
FP-19 泛型（类属）程序设计
qq_51393126的博客
05-27 343
Lecture 19 泛型（类属）程序设计 面临的问题 在程序设计中，经常需要用到一些功能完全相同的程序实体，但它们所涉及的数据的类型不同。 例如，对不同元素类型的数组进行排序的函数： void int_sort(int x[],int num); void double_sort(double x[],int num); void A_sort(A x[],int num); 这三个函数的实现是一样的（如都采用快速排序算法）。 再例如，元素类型不同的栈类： class IntStack { int
关联分析——FP-growth算法 C++带类实现及案例
最新发布
05-23
FP-growth算法是一种非常常用的关联分析算法，可以用于挖掘数据集中的频繁项集，进而发现数据集中不同项之间的关联关系。C++作为一种高效的编程语言，也可以用于实现FP-growth算法。 下面是一个基于C++类的FP-growth算法实现及案例示例： ```cpp #include <iostream> #include <fstream> #include <algorithm> #include <vector> #include <map> using namespace std; class Node { public: string name; int count; Node* parent; map<string, Node*> children; Node() { name = ""; count = 0; parent = NULL; } Node(string name, int count) { this->name = name; this->count = count; parent = NULL; } void inc(int num) { count += num; } }; class FPTree { public: Node* root; map<string, int> headerTable; FPTree() { root = new Node(); headerTable.clear(); } void insert(vector<string>& transaction) { Node* cur = root; for (int i = 0; i < transaction.size(); i++) { string item = transaction[i]; if (cur->children.count(item) == 0) { cur->children[item] = new Node(item, 1); cur->children[item]->parent = cur; if (headerTable.count(item) == 0) { headerTable[item] = 1; } else { headerTable[item]++; } } else { cur->children[item]->count++; } cur = cur->children[item]; } } }; class FPGrowth { public: FPTree* tree; map<string, int> items; vector<vector<string>> transactions; FPGrowth() { tree = NULL; } void loadTransactions(string filename) { ifstream fin(filename); if (!fin.is_open()) { return; } string line; while (getline(fin, line)) { vector<string> transaction; string item; for (int i = 0; i < line.size(); i++) { if (line[i] == ' ') { if (items.count(item) == 0) { items[item] = 1; } else { items[item]++; } transaction.push_back(item); item = ""; } else { item += line[i]; } } if (!item.empty()) { if (items.count(item) == 0) { items[item] = 1; } else { items[item]++; } transaction.push_back(item); } transactions.push_back(transaction); } fin.close(); } bool cmp(const pair<string, int>& a, const pair<string, int>& b) { return a.second > b.second; } void buildTree() { tree = new FPTree(); for (int i = 0; i < transactions.size(); i++) { vector<string>& transaction = transactions[i]; sort(transaction.begin(), transaction.end(), [&](string a, string b) { return items[a] > items[b]; }); tree->insert(transaction); } } void findPrefixPath(string item, Node* node, vector<Node*>& prefixPath) { while (node != tree->root) { if (node->name == item) { prefixPath.push_back(node); } node = node->parent; } } void mineFrequentItemsets(int minSup) { vector<pair<string, int>> freqItems; for (auto it = items.begin(); it != items.end(); it++) { if (it->second >= minSup) { freqItems.push_back(*it); } } sort(freqItems.begin(), freqItems.end(), cmp); for (int i = 0; i < freqItems.size(); i++) { vector<string> prefix; prefix.push_back(freqItems[i].first); int sup = freqItems[i].second; findPrefixPaths(prefix, tree->headerTable, sup); } } void findPrefixPaths(vector<string>& prefix, map<string, Node*> headerTable, int sup) { string item = prefix[prefix.size() - 1]; Node* node = headerTable[item]->parent; vector<Node*> prefixPath; while (node != tree->root) { prefixPath.clear(); findPrefixPath(item, node, prefixPath); vector<string> subPrefix; for (int i = 0; i < prefix.size() - 1; i++) { subPrefix.push_back(prefix[i]); } subPrefix.push_back(node->name); int count = node->count; for (int i = 0; i < prefixPath.size(); i++) { count = min(count, prefixPath[i]->count); } if (count >= sup) { cout << "{"; for (int i = 0; i < subPrefix.size(); i++) { cout << subPrefix[i] << " "; } cout << item << "} : " << count << endl; findPrefixPaths(subPrefix, node->children, sup); } node = node->parent; } } }; int main() { FPGrowth fpg; fpg.loadTransactions("transactions.txt"); fpg.buildTree(); fpg.mineFrequentItemsets(2); return 0; } ``` 上述代码实现了一个基于类的FP-growth算法，并且支持从文件中加载交易数据，并挖掘出频繁项集。其中，`Node`类表示FP树中的节点，`FPTree`类表示FP树，`FPGrowth`类表示FP-growth算法。具体实现细节可以参考代码注释。 需要注意的是，本示例中的实现仅支持从文件中加载交易数据，并不支持在线实时插入交易数据，如果需要支持在线插入数据，需要对代码进行一定的修改。另外，本示例中的实现也没有进行过多的优化，不适用于大型数据集的挖掘。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值