C++学习笔记7——继承篇

最新推荐文章于 2020-05-07 20:37:51 发布
最新推荐文章于 2020-05-07 20:37:51 发布
阅读量156 收藏
点赞数
分类专栏： # C++学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45550460/article/details/104126870
版权

教程：https://www.imooc.com/learn/426

继承

举例：
在这里插入图片描述
在这里插入图片描述
上例优化：

在这里插入图片描述

关系：
在这里插入图片描述
对应使用，不能交叉

编码示例：
Person.h

#include <string>
using namespace std;

class Person
{
public:
	Person();  
	~Person();
	void eat();

public:
	string m_strName;
	int m_iAge;
};

Person.cpp

#include <iostream>
#include "Person.h"
using namespace std;

Person::Person()
{
	cout << "Person()" << endl;
}

Person::~Person()
{
	cout << "~Person()" << endl;
}

void Person::eat()
{
	cout << "eat()" << endl;
}

Worker.h

#include "Person.h"

class Worker : public Person
{
public:
	Worker();
	~Worker();
	void work();
	
public:
	int m_iSalary;
};

Worker.cpp

#include <iostream>
#include "Worker.h"
using namespace std;

Worker::Worker()
{
	cout << "Worker()" << endl;
}

Worker::~Worker()
{
	cout << "~Worker()" << endl;
}

void Worker::work()
{
	cout << "work()" << endl;
}

demo.cpp

include <iostream>
#include "Worker.h"
using namespace std;

int main()
{
	Worker *p = new Worker();  //从堆中实例化对象
	p->m_strName = "zhang";  //检验是否能使用父类的数据成员及成员函数
	p->m_iAge = 10;
	p->eat();
	p->m_iSalary = 100; //检验是否能使用自身的数据成员及成员函数
	p->work();

	delete p;
	p = NULL;

	/*
	Worker worker;  //从栈中实例化对象
	worker.m_strName = "zhang";  //检验是否能使用父类的数据成员及成员函数
	worker.m_iAge = 10;
	worker.eat();
	worker.m_iSalary = 100; //检验是否能使用自身的数据成员及成员函数
	worker.work();

	//结合上例可知，无论是从堆中还是从栈中实例化对象，在公共继承中，父类的public访问限定符下的数据成员和成员函数都被继承到了子类的public访问限定符下

	*/
	return 0;
}

在这里插入图片描述
由运行结果知，要实例化一个子类（派生类），要先实例化父类（基类）。销毁时逆序

继承方式

在这里插入图片描述

公有继承：

public访问限定符下：
在这里插入图片描述
在使用时，Worker实例化的对象可以调用Person的数据成员和成员函数

protected访问限定符下：
在这里插入图片描述
实例化的对象可以调用类中在public下的eat()，但不能访问在protected下的m_iAge和在private下的m_strName
在这里插入图片描述
在实现成员函数时，可以访问在protected下的m_iAge和在private下的m_strName

在公有继承中：
在这里插入图片描述

private访问限定符下：
在这里插入图片描述
父类的private下的被子类继承到不可见位置，不是子类的private下，所以不可访问m_iAge
在这里插入图片描述
private成员会继承到派生类中，但无法通过派生类直接访问

举例证明：
Person.h

#include <string>
using namespace std;

class Person
{
public:
	Person();  
	~Person();
	void eat();

protected:
	string m_strName;
	int born;
private:
	int m_iAge;
	string tel;
};

Person.cpp

#include <iostream>
#include "Person.h"
using namespace std;

Person::Person()
{
	cout << "Person()" << endl;
}

Person::~Person()
{
	cout << "~Person()" << endl;
}

void Person::eat()
{
	m_strName = "zhang";
	m_iAge = 20;
	cout << "eat()" << endl;
}

Worker.h

#include "Person.h"

class Worker : public Person
{
public:
	Worker();
	~Worker();
	void work();
	void mas();
	
public:
	int m_iSalary;
};

Worker.cpp

#include <iostream>
#include "Worker.h"
using namespace std;

Worker::Worker()
{
	cout << "Worker()" << endl;
}

Worker::~Worker()
{
	cout << "~Worker()" << endl;
}

void Worker::work()
{
	m_strName = "wang";
	born = 2000;
	cout << "work()" << endl;
}

void Worker::mas()
{
	m_iAge = 10;
	tel = "12345";
	cout << "mas()" << endl;
}

demo.cpp

#include <iostream>
#include "Worker.h"
#include "Person.h"
using namespace std;

int main()
{
	Person person;
	person.eat();
	//程序能正常运行，说明在protected和private访问限定符下定义的数据成员，在其成员函数中是可以访问的

	//person.m_strName = "li";  //该句会报错，说明通过外部对象无法访问。m_iAge也一样

	Worker worker;
	worker.work();  //能正常运行，说明Person中protected的数据成员被继承到Worker中的protected下，可访问

	//worker.mas();  //不能运行，//通过公有继承方式，父类的private下的数据成员继承到子类中，所以也就无法访问
	return 0;
}

保护继承

在这里插入图片描述
private成员会继承到派生类中，但无法通过派生类直接访问

私有继承

在这里插入图片描述
private成员会继承到派生类中，但无法通过派生类直接访问

包含关系，父类包含在子类中

编码示例：

公有继承复习：
Person.h

#include <string>
using namespace std;

class Person
{
public:
	Person();  
	void play();
protected:
	string m_strName;
};

Person.cpp

#include <iostream>
#include "Person.h"
using namespace std;

Person::Person()
{
	m_strName = "zhang";
}


void Person::play ()
{
	cout << "Person::play ()" << endl;
	cout << m_strName << endl;
}

Soldier.h

#include "Person.h"

class Soldier :public Person
{
public:
	Soldier();
	void work();
protected:
	int m_iAge;

};

Soldier.cpp

#include <iostream>
#include "Soldier.h"
using namespace std;

Soldier::Soldier()
{

}

void Soldier::work()
{
	m_strName = "wang";  //Person类的protected成员
	m_iAge = 20;  //Soldier类的protected成员
	cout << m_strName << endl;  
	cout << m_iAge << endl;  
	cout << "Soldier::work()" << endl;
}

Infantry.h

//步兵类
#include "Soldier.h"

class Infantry :public Soldier
{
public :
	void attack();
};

Infantry.cpp

#include <iostream>
#include "Infantry.h"
using namespace std;

void Infantry::attack()
{
	cout << "Infantry::attack()" << endl;
}

demo.cpp

#include <iostream>
#include "Soldier.h"
using namespace std;

int main()
{
	Soldier soldier;
	soldier.work();  //调用Soldier类（相对Person类来说是子类）的成员函数，间接调用了父类的protected成员m_strName
	soldier.play();  //调用父类的public成员函数
	return 0;
}

在这里插入图片描述
能正常运行

保护继承：
修改：
Soldier.h

#include "Person.h"

class Soldier :protected Person  //保护继承，父类的public和protected成员都会继承到子类的protected下
{  //通过子类的对象，只能访问到子类的public下的数据和函数，不能访问到父类public下的数据和函数
public:
	Soldier();
	void work();
protected:
	int m_iAge;

};

Infantry.cpp

#include <iostream>
#include "Infantry.h"
using namespace std;

void Infantry::attack()
{
	m_strName = "li";  //访问Person类的protected数据成员（被继承到Soldier类的protected下）
	cout << m_strName << endl;
	cout << "Infantry::attack()" << endl;
}

demo.cpp

#include <iostream>
#include "Soldier.h"
#include "Infantry.h"
using namespace std;

int main()
{
	Soldier soldier;
	soldier.work();  //调用Soldier类（相对Person类来说是子类）的成员函数，间接调用了父类的protected成员m_strName
	//soldier.play();  //调用父类的public成员函数，此时此句报错，因为现在是protected继承，不能访问父类public的成员函数

	Infantry infantry;
	infantry.attack();  

	return 0;
}

infantry.attack();能正常运行，说明Soldier类保护继承Person类，Person类的public和protected成员被继承到Soldier类的protected下，Infantry类公有继承Soldier类（可以访问Soldier类的public和protected成员），所以Infantry类的attack()函数中可以访问Person类的protected成员m_strName

私有继承：
修改：
Soldier.h

#include "Person.h"

class Soldier :private Person  //私有继承，父类的public和protected成员都会继承到子类的private下
{  //理论上，可以在Soldier中直接访问Person的相关数据，但Infantry类公有继承Soldier类后，Infantry类无法直接访问Person类的数据成员和成员函数
public:
	Soldier();
	void work();
protected:
	int m_iAge;
private:

};

Infantry.cpp

#include <iostream>
#include "Infantry.h"
using namespace std;

void Infantry::attack()
{
	m_strName = "li";  //运行demo，出错
	cout << m_strName << endl;
	cout << "Infantry::attack()" << endl;
}

demo.cpp

#include <iostream>
#include "Soldier.h"
#include "Infantry.h"
using namespace std;

int main()
{
	Infantry infantry;
	infantry.attack();  

	return 0;
}

B类从A类公共派生，那么A类的私有成员函数不能被B类继承并使用。（√）

B类从A类公共派生，那么A类的私有成员函数成为B类的私有成员函数。（×）

隐藏

在这里插入图片描述
B公有继承A，此时B中自己有函数ABC()，又从A中继承到了函数ABC()，A、B中都有函数ABC()，当B的对象直接调用ABC()时，调用到的是B的ABC()无法访问到A的ABC()。这样子叫做同名隐藏。同名隐藏不仅局限于函数，数据成员也有，但少见。

在这里插入图片描述
在这里插入图片描述
第一个调用的是Soldier的play()
第二个调用的是Person的play()

在这里插入图片描述
在这里插入图片描述
编码示例：

隐藏的使用：

Person.h

#include <string>
using namespace std;

class Person
{
public:
	Person();  
	void play();
protected:
	string m_strName;

};

Person.cpp

#include <iostream>
#include "Person.h"  //" " 搜索的是同目录下的头文件，< > 搜索的是系统的默认库
using namespace std;

Person::Person()
{
	m_strName = "zhang";
}


void Person::play ()
{
	cout << "Person::play ()" << endl;
	cout << m_strName << endl;
}

Soldier.h

#include "Person.h"

class Soldier :public Person  
{ 
public:
	Soldier();
	void play();
	void work();
protected:
	
private:

};

Soldier.cpp

#include <iostream>
#include "Soldier.h"
using namespace std;

Soldier::Soldier()
{

}

void Soldier::play()
{
	cout << "Soldier::play()" << endl;
}

void Soldier::work()
{
	cout << "Soldier::work()" << endl;
}

demo.cpp

#include <iostream>
#include "Soldier.h"
using namespace std;

int main()
{
	Soldier soldier;
	soldier.play();
	soldier.work();
	soldier.Person::play();
	return 0;
}

当同名函数的参数不同时：
修改：
soldier.h

#include "Person.h"

class Soldier :public Person  
{ 
public:
	Soldier();
	void play(int x);
	void work();
protected:
	
private:

};

Soldier.cpp

#include <iostream>
#include "Soldier.h"
using namespace std;

Soldier::Soldier()
{

}

void Soldier::play(int x)
{
	cout << "Soldier::play()" << endl;
}

void Soldier::work()
{
	cout << "Soldier::work()" << endl;
}

demo.cpp

#include <iostream>
#include "Soldier.h"
using namespace std;

int main()
{
	Soldier soldier;
	soldier.play(7);
	soldier.work();
	//soldier.play(); //此句错误，不能通过这个调用Person类的play()，系统只会提示不符合Soldier类的play(int x)的格式，缺少参数
	return 0;
}

所以就算同名函数的参数不同，也不能直接调用，父类的还是会被隐藏

修改：同名数据成员
Soldier.cpp

#include <iostream>
#include "Soldier.h"
using namespace std;

Soldier::Soldier()
{

}

void Soldier::play(int x)
{
	cout << "Soldier::play()" << endl;
	cout << m_strName << endl;  //打印出来的是在Soldier类中定义的m_strName
	cout << Person::m_strName << endl; //Person类定义的m_strName
}

void Soldier::work()
{
	m_strName = "Jack";  //给赋值的是Soldier类中定义的m_strName，不是Person类中定义的m_strName
	Person::m_strName = "Jackson";  //Person类定义的m_strName
	cout << "Soldier::work()" << endl;
}

demo.cpp

#include <iostream>
#include "Soldier.h"
using namespace std;

int main()
{
	Soldier soldier;
	soldier.work();
	soldier.play(7);
	return 0;
}

isA

在这里插入图片描述
Person p1 = s1; //用s1实例化p1

派生类的对象可以赋值给基类，可以用基类的指针指向派生类的对象

在这里插入图片描述
可以将基类的指针或基类的对象或基类的引用作为函数的参数，使函数可以接收传入的派生类的对象，并且也可以传入基类的对象

存储结构：

1、将子类的对象赋值给父类的对象（用子类的对象初始化父类的变量）

在这里插入图片描述
赋值时，父类没有的数据成员会丢失

2、父类的指针指向一个子类对象
在这里插入图片描述
父类的指针只能访问到父类原有的数据成员，无法访问到其他子类独有的数据成员

编码示例：
Person.h

#include <string>
using namespace std;

class Person
{
public:
	Person(string name = "Jim");  
	~Person();
	void play();
protected:
	string m_strName;

};

Person.cpp

#include <iostream>
#include "Person.h" 
using namespace std;

Person::Person(string name)
{
	m_strName = name;
	cout << "Person::Person(string name)" << endl;
}

Person::~Person()
{
	cout << "Person::~Person()" << endl;
}


void Person::play ()
{
	cout << "Person::play ()" << endl;
	cout << m_strName << endl;
}

Soldier.h

#include "Person.h"

class Soldier :public Person  
{ 
public:
	Soldier(string name = "Jack", int age = 20);
	~Soldier();
	void work();
protected:
	int m_iAge;
private:

};

Soldier.cpp

#include <iostream>
#include "Soldier.h"
using namespace std;

Soldier::Soldier(string name, int age)
{
	m_strName = name;
	m_iAge = age;
	cout << "Soldier::Soldier(string name, int age)" << endl;
}

Soldier::~Soldier()
{
	cout << "Soldier::~Soldier()" << endl;
}

void Soldier::work()
{
	cout << m_strName << endl;
	cout << m_iAge << endl;
	cout << "Soldier::work()" << endl;
}

demo.cpp

#include <iostream>
#include "Soldier.h"
using namespace std;

int main()
{
	Soldier soldier;
	Person p = soldier;  //或： Person p;  p = soldier;  第一个是用soldier初始化Person的对象，第二个是将soldier赋值给Person的对象。两个取得的结果一样
	p.play();

	return 0;
}

在这里插入图片描述
用Soldier实例化Person的对象时，Soldier本身是要执行构造函数的，因为Soldier是子类，所以执行Soldier的构造函数前，会先执行父类Person的构造函数。接下来调用的函数是Person 类的，原来在Person初始化的m_strName = “Jim”，在Soldier类初始化的m_strName = “Jack”,由结果可知，用Soldier初始化Person类后，Soldier中的m_strName的值赋给了Person中的m_strName

修改demo.cpp

#include <iostream>
#include "Soldier.h"
using namespace std;

int main()
{
	Soldier soldier;
	Person p;
	p.play();

	return 0;
}

在这里插入图片描述
可对比结果

修改（改用指针）：
demo.cpp

#include <iostream>
#include "Soldier.h"
using namespace std;

int main()
{
	Soldier soldier;
	Person *p = &soldier;
	p->play();
	//p->work();  //报错，说明使用Person的对象或指针，只能调用Person自有的数据成员和成员函数，无法调用子类的数据成员和成员函数
	return 0;
}

在这里插入图片描述
所以，无论是用对象赋值的方式，还是用指针指向的方式，如果用父类接收子类对象的值或指向子类对象，打印出来的都是子类对象的值

修改：
demp.cpp

#include <iostream>
#include "Soldier.h"
using namespace std;

int main()
{
	Person *p = new Soldier;
	p->play();

	delete p;
	p = NULL;

	return 0;
}

在这里插入图片描述
用父类的指针指向子类的对象时，子类的对象会进行实例化，实例化的过程会先调用父类的构造函数，再调用子类的构造函数。当delete销毁时，只执行父类了的析构函数，这样子类没有析构，可能造成内存泄露，要修改，用虚析构函数。

虚析构函数：当存在继承关系时，使用父类的指针指向堆中的子类的对象（用new实例化，用->调用的），还想使用父类的指针去释放内存，这时就需要虚析构函数

virtual ~Person();  //虚析构函数，virtual是可以被继承的，所以即便在Soldier类的析构函数不写virtual,该析构函数也是虚析构函数

修改：
Person.h

#include <string>
using namespace std;

class Person
{
public:
	Person(string name = "Jim");  
	virtual ~Person();
	void play();
protected:
	string m_strName;

};

Soldier.h

#include "Person.h"

class Soldier :public Person  
{ 
public:
	Soldier(string name = "Jack", int age = 20);
	virtual ~Soldier();
	void work();
protected:
	int m_iAge;
private:

};

在这里插入图片描述
可见虽然demo.cpp中并没有delete Soldier类的对象，但是Soldier类的析构函数还是被调用了

编码举例2（体现函数参数传递关系）
demo.cpp

#include <iostream>
#include "Soldier.h"
using namespace std;

void test1(Person p)
{
	p.play();
}

void test2(Person &p)
{
	p.play();
}

void test3(Person *p)
{
	p->play();
}


int main()
{
	Person p;
	Soldier s;

	test1(p);  //传入的是Person的对象，输出结果是Jim
	test1(s);  //传入的是Soldier的对象，输出结果是Jack
	//可见，如果函数参数是基类的对象，基类的对象和派生类的对象都可以作为实参传递进来，并能够正常使用

	return 0;
}

在这里插入图片描述
结果可见，先调用了Person的构造函数两次，再调用Soldier的构造函数，这是因为先实例化一个Person的对象，调用一次Person的构造函数，然后实例化一个Soldier的对象（Soldier继承Person），所以先后调用一次Person的构造函数和Soldier的构造函数。

test1定义的参数是一个对象，所以传值时会先实例化一个临时对象p，通过临时对象p调用play()，在test1这个函数执行完毕时，临时对象p会自动销毁，这就是为什么在两次调用play()时，都会分别执行一次Person的析构函数。

修改（把两个test1改为test2）
在这里插入图片描述
实例化Person对象（第一行），实例化Soldier对象（2、3行），调用test2，是引用，所以在传入参数时，会给参数起别名p，通过别名p调用play()，在test2执行过程中，没有实例化临时对象，所以没有销毁临时对象，其他输出结果与test1输出结果一致。说明使用基类的引用也可以接收基类的对象和派生类的对象

修改为：

test3(&p);
test3(&s);

在这里插入图片描述
输出结果与test2一致，因为test3的参数是基类的指针，当使用基类或派生类的对象地址传入后，会使用指针p分别调用基类或派生类的play()

对比test1、test2、test3，使用2、3不会产生新的临时对象，效率更高。

等等waiting_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
课堂练习11 面向对象编程
Junds0的博客
11-11 1125
任务描述本关任务：编写一个简单的类。相关知识为了完成本关任务，你需要掌握：类的定义类的定义Python中定义类的语法格式如下：class 类名：[类变量][definit[def 函数名(self,…)]编程要求根据提示，在右侧编辑器补充代码，完成如下操作：1、定义类Student2、定义一个类变量count，初始化为03、定义一个方法printnum，输出count的值。4、在类外定义一个对象s1并初始化5、利用s1对象直接访问count并输出其值。
设计和实现回合制战斗系统Combat（C++）（Soldier战士类，Wizard巫师类，Master巫师类，WarSystem战斗系统类）
m0_59746992的博客
03-17 4970
回合制为什么会大受欢迎？因为这个世界历来就是得轻度用户者（light users）得天下，以这个为出发点上，它比即时制有自己独到的优势。慢节奏、易操作、收集养成、聊天交友给回合制带来了众多即时制所带不来的用户群。同时，回合制的社区也让玩家的粘着度大增。回合制为什么会大受欢迎？因为这个世界历来就是得轻度用户者（light users）得天下，以这个为出发点上，它比即时制有自己独到的优势。慢节奏、易操作、收集养成、聊天交友给回合制带来了众多即时制所带不来的用户群。同时，回合制的社区也让玩家的粘着度大增。回合制为
C++速成（2）
相国大人
11-07 2298
转载自： http://www.cnblogs.com/kkdd-2013/p/5370094.htmlC继承25h 1 为什么要继承 2 内存中的对象 3 继承代码实践 4 继承方式 公有继承 基类成员访问属性 继承方式 派生类成员访问属性 private成员 public 无法访问 protected成员 protected public成员 publ
正确使用#include和前置声明(forward declaration)
热门推荐
SpriteLW的专栏
07-23 3万+
差不多一年时间没用过C++写过程序了,由于工作的需要,我又回到了C++的阵形。在工作的过程中遇到了很多麻烦，当我往工程里加一个类，而且那个类又与工程里的类相关，如有那个类型的成员变量。情况如下//////A.h///////////class A{.......};////////B.h//////////class B:A{....A member;}
Soldier
10-28
Soldier
C++学习笔记－－继承
wangrl的博客
10-09 412
When a program constructs a derived-class object, it first constructs the base-class object. 在初始化子类的对象时，应该先初始化父类的对象，实现如下： RatedPlayer::RatedPlayer(unsigned int r, const string & fn, const string & l
C++学习笔记－－多继承
wangrl的博客
10-15 477
这个例子中，Worker是基类，Singer和Waiter继承Worker类，SingingWaiter同时继承Singer类和Waiter类。 If you want to use something other than the default constructor for a virtual base class, you need to invoke the appropriate
C++整理笔记word版——01 C++学习笔记
12-05
C++是一种强大的面向对象编程语言，它源自C语言并扩展了其...学习这些概念是成为C++程序员的第一步。在实际编程中，还需要理解类、对象、继承、多态等面向对象编程的概念，以及函数、模板、文件操作等更高级的主题。
C++学习笔记——继承和组合
06-06
根据给定的文件标题、描述、标签以及部分内容，本文将深入探讨C++中的两个核心概念：继承与组合。这两种机制都是面向对象编程中用于实现代码重用的重要手段，但它们在设计模式、实现细节以及适用场景上存在显著差异...
cpp代码-c++学习笔记——类与对象
07-16
本学习笔记将深入探讨这两个概念以及如何在实际编程中应用它们。 首先，类是C++中的一种用户自定义数据类型，它允许我们将相关的数据和函数封装在一起。类可以看作是一个蓝图或模板，定义了具有特定属性（数据成员...
C++小白慕课网4
白崽啦啦啦的博客
10-20 226
继承篇 work.h#include"person.h"class Worker :public Person { public: Worker(); ~Worker(); void work(); int m_iSalary; }; worker.cpp#include<iostream> #include"worker.h" using namespace st
C++链表类模板
zilisen的博客
06-05 2461
记录自己写的一个链表类模板，两个头文件：一个是节点头文件Node.h，一个是链表头文件LinkList.h。
编写Java程序，定义士兵类（Soldiers）并初始化5个士兵对象。
杨明金的博客
05-07 6565
需求说明： 创建士兵类（Soldiers），定义有一个String类型参数name，代表士兵的姓名，两个int类型变量x和y，分别表示士兵所在的坐标位置，x代表横坐标，y代表纵坐标。在士兵类中定义一个带3个参数的构造方法，它们分别对应士兵的姓名、横坐标和纵坐标。在主方法中利用for循环创建5个士兵对象，每个士兵对象的姓名以及x，y坐标均通过控制台输入。 实现思路： 创建士兵类（Soldier...
方案-基于云架构的校园信息化建设方案.pdf
最新发布
07-29
方案-基于云架构的校园信息化建设方案.pdf
【创新未发表】Matlab实现蛇群优化算法SO-Kmean-Transformer-LSTM负荷预测算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
【创新未发表】Matlab实现北方苍鹰优化算法NGO-Kmean-Transformer-LSTM组合状态识别算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
C++面向对象编程：继承与学习指南
"这篇文档是关于C++编程中面向对象编程的继承概念的学习笔记，主要介绍了C++中的继承机制以及面向对象程序设计的基本思想。同时，文档提到了C++的发展历史，行业地位以及其在不同领域的应用。" 在面向对象编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值