C++远征之多态篇（笔记）

最新推荐文章于 2022-02-25 20:00:37 发布
最新推荐文章于 2022-02-25 20:00:37 发布
阅读量244 收藏 1
点赞数
分类专栏： C++学习 文章标签： C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cj_who_knows/article/details/79154829
版权

注：每个章节的代码均是独立的,测试时将每一节的代码复制粘贴即可

2-2、虚函数代码示例

//Shape2_2.h

#ifndef SHAPE_H
#define SHAPE_H

#include<iostream>
using namespace std;

class Shape
{
public:
Shape();
~Shape();
virtual double calcArea();
};

#endif //SHAPE_H

//Rect2_2.h

#ifndef RECT_H
#define RECT_H

#include"Shape2_2.h"
class Rect:public Shape
{
public:
Rect(double width,double height);
~Rect();
double calcArea();
protected:
double m_dWidth;
double m_dHeight;
};
#endif   //RECT_H

//Circle2_2.h

#ifndef CIRCLE_H
#define CIRCLE_H

#include"Shape2_2.h"
class Circle:public Shape
{
public:
Circle(double r);
~Circle();
double calcArea();
protected:
double m_dR;
};

#endif   //CIRCLE_H

//Shape2_2.cpp

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

Shape::Shape()
{
cout<<"Shape()"<<endl;
}
Shape::~Shape()
{
cout<<"~Shape()"<<endl;
}
double Shape::calcArea()
{
cout<<"Shape--calcArea"<<endl;
return 0;
}

//Rect2_2.cpp

#include"Rect2_2.h"
#include<iostream>

#include<string>
using namespace std;

Rect::Rect(double width,double height)
{
cout<<"Rect()"<<endl;
m_dHeight = height;
m_dWidth = width;
}
Rect::~Rect()
{
cout<<"~Rect()"<<endl;
}
double Rect::calcArea()
{
cout<<"Rect--calcArea()"<<endl;
return m_dWidth*m_dHeight;
}

//Circle2_2.cpp

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

Circle::Circle(double r)
{
cout<<"Circle()"<<endl;
m_dR = r;
}
Circle::~Circle()
{
cout<<"~Circle()"<<endl;
}
double Circle::calcArea()
{
cout<<"Circle--calcArea()"<<endl;
return 3.14*m_dR*m_dR;
}

//main文件

//2-2虚函数代码示例#include<iostream>
#include<stdlib.h>
#include"Circle2_2.h"
#include"Rect2_2.h"
using namespace std;
/*********************************/
/*
动态多态、虚函数
要求:
1.定义Shape类，成员函数：calcArea(),构造函数，析构函数
2.定义Rect类，成员函数：calcArea(),构造函数，析构函数
 数据成员：m_dWidth,m_dHeight
3.定义Circle类，成员函数：calcArea(),构造函数，析构函数
    数据成员：m_dR
/*********************************/
int main(void)
{
Shape *shape1 = new Rect(3,6);
Shape *shape2 = new Circle(5);

shape1->calcArea();
shape2->calcArea();

delete shape1;
shape1 = NULL;
delete shape2;
shape2 = NULL;

system("pause");
return 0;
}

2-5、虚析构函数代码示例

//Shape2_5.h

#ifndef SHAPE_H
#define SHAPE_H

#include<iostream>
using namespace std;
class Shape
{
public:
//  virtual Shapr(); //错误，构造函数不能是虚函数
Shape();
/*
virtual static void test() //错误，virtual关键字不能加在静态成员函数前
{
}
*/
/* virtual inline void test() //无语法错误，但此时inline关键字则失效
{

}
*/

 virtual ~Shape();
virtual double calcArea();
};
#endif //SHAPE_H

//Rect2_5.h

#ifndef RECT_H
#define RECT_H

#include"Shape2_5.h"
class Rect:public Shape
{
public:
Rect(double width,double height);
virtual ~Rect();
double calcArea();
protected:
double m_dWidth;
double m_dHeight;
};

#endif   //RECT_H

//Circle2_5.h

ifndef CIRCLE_H
#define CIRCLE_H

#include"Shape2_5.h"
#include"Coordinate2_5.h"
class Circle:public Shape
{
public:
Circle(double r);
virtual ~Circle();
double calcArea();
protected:
double m_dR;
Coordinate *m_pCenter;
};

#endif   //CIRCLE_H

//Coordinate2_5.h

#ifndef COORDINATE_H
#define COORDINATE_H

class Coordinate
{
public:
Coordinate(int x,int y);
~Coordinate();
protected:
int m_iX;
int m_iY;
};

#endif  //COORDINATE_H

//Shape2_5.cpp

#include"Shape2_5.h"
#include<iostream>
using namespace std;
Shape::Shape()
{
cout<<"Shape()"<<endl;
}
Shape::~Shape()
{
cout<<"~Shape()"<<endl;
}
double Shape::calcArea()
{
cout<<"Shape--calcArea"<<endl;
return 0;
}

//Rect2_5.cpp

#include"Rect2_5.h"
#include<iostream>
#include<string>
using namespace std;
Rect::Rect(double width,double height)
{
cout<<"Rect()"<<endl;
m_dHeight = height;
m_dWidth = width;
}
Rect::~Rect()
{
cout<<"~Rect()"<<endl;
}
double Rect::calcArea()
{
cout<<"Rect--calcArea()"<<endl;
return m_dWidth*m_dHeight;
}

//Circle2_5.cpp

#include<iostream>
#include"Circle2_5.h"
using namespace std;
Circle::Circle(double r)
{
cout<<"Circle()"<<endl;
m_dR = r;
m_pCenter = new Coordinate(3,5);
}
Circle::~Circle()
{
cout<<"~Circle()"<<endl;
//释放内存
delete m_pCenter;
m_pCenter = NULL;
}
double Circle::calcArea()
{
cout<<"Circle--calcArea()"<<endl;
return 3.14*m_dR*m_dR;
}

//Coordinate2_5.cpp

#include"Coordinate2_5.h"
#include<iostream>
using namespace std;
Coordinate::Coordinate(int x,int y)
{
cout<<"Coordinate()"<<endl;
m_iX = x;
m_iY = y;
}
Coordinate::~Coordinate()
{
cout<<"~Coordinate()"<<endl;
}

//main文件

#include<iostream>
#include<stdlib.h>
#include"Circle2_5.h"
//2-5虚析构函数代码示例
/*
虚析构函数是为了防止内存泄露
*/
#include"Rect2_5.h"
using namespace std;
/*********************************/
/*
动态多态、虚函数
要求:
1.定义Shape类，成员函数：calcArea(),构造函数，析构函数
2.定义Rect类，成员函数：calcArea(),构造函数，析构函数
 数据成员：m_dWidth,m_dHeight
3.定义Circle类，成员函数：calcArea(),构造函数，析构函数
    数据成员：m_dR，m_pCenter
4.定义Coordinate类，成员函数：构造函数，析构函数
数据成员：m_iX,m_iY 
/*********************************/
/*
示例函数
//virtual void test() //错误，virtual关键字不能加在普通函数前
void test()
{

}
*/

int main(void)
{
Shape *shape1 = new Rect(3,6);
Shape *shape2 = new Circle(5);

shape1->calcArea();
shape2->calcArea();

delete shape1;
shape1 = NULL;
delete shape2;
shape2 = NULL;

system("pause");
return 0;
}

2-8~2-9、虚函数表示例

//Shape2_2.h

#ifndef SHAPE_H
#define SHAPE_H

#include<iostream>
using namespace std;
class Shape
{
public:
Shape();
//~Shape();
double calcArea();
virtual ~Shape();
//virtual double calcArea();
};

#endif //SHAPE_H

//Circle2_8.h

#ifndef CIRCLE_H
#define CIRCLE_H

#include"Shape2_8.h"
class Circle:public Shape
{
public:
Circle(int r);
~Circle();
// double calcArea();
protected:
int m_iR;
};

#endif   //CIRCLE_H

//Shape2_8.cpp

#include"Shape2_8.h"
#include<iostream>
using namespace std;
Shape::Shape()
{
// cout<<"Shape()"<<endl;
}
Shape::~Shape()
{
// cout<<"~Shape()"<<endl;
}
double Shape::calcArea()
{
cout<<"Shape--calcArea"<<endl;
return 0;
}

//Circle2_8.cpp

#include<iostream>
#include"Circle2_8.h"
using namespace std;
Circle::Circle(int r)
{
// cout<<"Circle()"<<endl;
m_iR = r;
}
Circle::~Circle()
{
// cout<<"~Circle()"<<endl;
}

//main文件

//2-8~2-9虚函数表示例
#include<iostream>
#include<stdlib.h>
#include"Circle2_8.h"
using namespace std;
/*********************************/
/*
虚函数表
要求:
1.定义Shape类，成员函数：calcArea(),构造函数，析构函数
3.定义Circle类，成员函数：构造函数，析构函数
    数据成员：m_iR
概念说明：
1.对象的大小
2.对象的地址
3.对象成员的地址
4.虚函数表指针

/*********************************/
int main(void)
{
Shape shape;
//cout<<sizeof(shape)<<endl; //没有数据成员的对象默认占用1个存储单元

int *p =(int *)&shape;
//cout<<p<<endl;
cout<<(unsigned int)(*p)<<endl;

Circle circle(100);
// cout<<sizeof(circle)<<endl;

int *q = (int *)&circle;
// cout<<q<<endl;
cout<<(unsigned int)(*q)<<endl;
q++;
cout<<(unsigned int)(*q)<<endl;

system("pause");
return 0;
}

3-2、抽象类代码示例

//Person3_2.h

#ifndef PERSON_H
#define PERSON_H

#include<string>
using namespace std;
class Person
{
public:
Person(string name);
virtual ~Person();
virtual void work() = 0; //纯虚函数，有纯虚函数的类不能实例化，必须实现该函数才能实例化
private:
string m_strName;
};

#endif   //PERSON_H

//Worker3_2.h

#ifndef WORKER_H
#define WORKER_H

#include"Person3_2.h"
#include<string>
class Worker:public Person
{
public:
Worker(string name,int age);
// virtual void work();
private:
int m_iAge;
};

#endif   //WORK_H

//Dustman3_2.h

#ifndef DUSTMAN_H
#define DUSTMAN_H

#include"Work3_2.h"
#include<iostream>
using namespace std;
class Dustman:public Worker
{
public:
Dustman(string name,int age);
virtual void work();
};

#endif //DUSTMAN_H

//Person3_2.cpp

#include"Person3_2.h"
#include<iostream>
#include<string>
using namespace std;
Person::Person(string name)
{
m_strName = name;
// cout<<"Person()"<<endl;
}
Person::~Person()
{
// cout<<"~Rect()"<<endl;
}

//Worker3_2.cpp

#include"Work3_2.h"
#include<iostream>
#include<string>
using namespace std;
Worker::Worker(string name,int age):Person(name)
{
m_iAge = age;
cout<<"Worker()"<<endl;
}
/*void Worker::work()
{
cout<<"Worker--work()"<<endl;
}*/

//Dustman3_2.cpp

#include"Dustman3_2.h"
#include<iostream>
using namespace std;
Dustman::Dustman(string name,int age):Worker(name,age)
{
cout<<"Dustman()"<<endl;
}
void Dustman::work()
{
cout<<"Dustman--work()"<<endl;
}

//main文件

//3-2抽象类代码示例
#include<iostream>
#include<stdlib.h>
#include"Dustman3_2.h"
#include"Person3_2.h"
#include"Work3_2.h"
using namespace std;
/*********************************/
/*
纯虚函数抽象类：
要求:
1.定义Person类，成员函数：构造函数，虚析构函数，纯虚函数work(),数据成员：名字m_strName
2.定义Worker类，成员函数：构造函数，work(),数据成员：年龄m_iAge
2.定义Dustman类，成员函数：构造函数，work(),
/*********************************/
int main(void)
{
// Person person("CJ"); //错误，Person是含有纯虚函数的抽象类，不能实例化
// Worker worker("Merry",20); //若Worker类继承了Person类并且Worker类中没有实现继承自Person中的纯虚函数时，//此时Worker类也是抽象类，不能实例化

Dustman dustman("Merry",20);

system("pause");
return 0;
}

3-6、接口类代码示例

//Flyable3_6.h

//3_6接口类代码示例
#ifndef FLYABLE_H
#define FLYABLE_H
//只有纯虚函数的类不需要.cpp文件
class Flyable
{
public:
virtual void takeoff() = 0;
virtual void land() = 0;
};

#endif   //FLYABLE_H

//Plane3_6.h

#ifndef PLANE_H
#define PLANE_H

#include"Flyable3_6.h"
#include<string>
using namespace std;
//class Plane:public Flyable
class Plane
{
public:
Plane(string code);
// virtual void takeoff();
// virtual void land();
void printCode();
protected:
string m_strCode;
};

#endif   //PLANE_H

//FighterPlane3_6.h

#ifndef FIGHTERPLANE_H
#define FIGHTERPLANE_H
#include"Plane3_6.h"
#include<string>
using namespace std;
//class FighterPlane:public Plane
class FighterPlane:public Plane,public Flyable
{
public:
FighterPlane(string code);
virtual void takeoff();
virtual void land();
};

#endif   //FIGHTERPLANE_H

//Flyable3_6.cpp(此文件可不写)

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

//Plane3_6.cpp

#include<iostream>
#include"Plane3_6.h"
using namespace std;
Plane::Plane(string code)
{
m_strCode = code;
// cout<<"Plane()"<<endl;
}

/*
void Plane::takeoff()
{
cout<<"Plane--takeoff"<<endl;
}
void Plane::land()
{
cout<<"Plane--land()"<<endl;
}
*/
void Plane::printCode()
{
cout<<m_strCode<<endl; 
}

//FighterPlane3_6.cpp

#include<iostream>
#include"FighterPlane3_6.h"
using namespace std;
FighterPlane::FighterPlane(string code):Plane(code)
{

}
void FighterPlane::takeoff()
{
cout<<"FighterPlane()--takeoff()"<<endl;
}
void FighterPlane::land()
{
cout<<"FightPlane--land()"<<endl;
}

//main文件

//3-6接口类代码示例
#include<iostream>
#include<stdlib.h>
#include"FighterPlane3_6.h"
using namespace std;
/*********************************/
/*
接口类：
要求:
1.定义Flyable类，成员函数：takeoff(),land()
2.定义Plane类，成员函数：构造函数，takeoff(),land(),printCode(),数据成员：m_strCode
3.定义FighterPlane类，成员函数：构造函数，takeoff(),land(),
4.全局函数flyMatch(Flyable *f1,Flyable *f2)
/*********************************/
void flyMatch(Flyable *f1,Flyable *f2)
{
f1->takeoff();
f1->land();
f2->takeoff();
f2->land();
}
int main(void)
{
FighterPlane p1("001");
FighterPlane p2("002");
p1.printCode();
p2.printCode();

flyMatch(&p1,&p2);

system("pause");
return 0;
}

4-2、RTTI代码示例(未能成功运行)

//Flyable4_2.h

//4-2RTTI
#ifndef FLYABLE_H
#define FLYABLE_H
//只有纯虚函数的类不需要.cpp文件
class Flyable
{
public:
virtual void takeoff() = 0;
virtual void land() = 0;
};

#endif   //FLYABLE_H

//Plane4_2.h

#ifndef PLANE_H
#define PLANE_H

#include"Flyable4_2.h"
#include<string>
using namespace std;
class Plane:public Flyable
{
public:
virtual void takeoff();
virtual void land();
void carry();
};

#endif   //PLANE_H

//Bird4_2.h

#ifndef BIRD_H
#define BIRD_H

#include<iostream>
#include<string>
#include"Flyable4_2.h"
using namespace std;
class Bird:public Flyable
{
public:
virtual void takeoff();
virtual void land();
void foraging();
};

#endif //BIRD_H

//Flyable4_2.cpp(此文件可不写)

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

//Plane4_2.cpp

#include<iostream>
#include"Plane4_2.h"
using namespace std;
void Plane::takeoff()
{
cout<<"Plane--takeoff"<<endl;
}
void Plane::land()
{
cout<<"Plane--land()"<<endl;
}
void Plane::carry()
{
cout<<"Plane--carry()"<<endl;
}

//Bird4_2.cpp

#include"Bird4_2.h"
#include<iostream>
using namespace std;
void Bird::takeoff()
{
cout<<"Bird--takeoff()"<<endl;
}
void Bird::land()
{
cout<<"Bird~land()"<<endl;
}
void Bird::foraging()
{
cout<<"Bird--foraging"<<endl;
}

//main文件

//4-2RTTI代码示例(未能成功运行)
#include<iostream>
#include<stdlib.h>
#include"Bird4_2.h"
#include"Plane4_2.h"
#include<typeinfo>
using namespace std;
/*********************************/
/*
RTTI：
要求:
1.定义Flyable类，成员函数：takeoff(),land()
2.定义Plane类，成员函数：takeoff(),land(),carry()
3.定义Bird类，成员函数：takeoff(),land(),foraging()
4.全局函数doSomething(Flyable *obj)
/*********************************/
void doSomething(Flyable *obj)
{
cout<<typeid(*obj).name()<<endl; //打印obj的数据 类型
obj->takeoff();
if(typeid(*obj)==typeid(Bird)) //如果当前指针指向的obj的类型为Bird
{
Bird *bird = dynamic_cast<Bird *>(obj); //若obj为Bird类型的指针，
//则将obj转化为Bird的指针并赋值给Bird类型的bird
bird->foraging();
}
if(typeid(*obj) == typeid(Plane))
{
Plane *plane = dynamic_cast<Plane *>(obj);
plane->carry();
}
obj->land();
}

int main(void)
{
int i = 0;
cout<<typeid(i).name()<<endl;

system("pause");
return 0;
}

5-2、异常处理(未成功运行)

//Exception5_2.h

#ifndef EXCEPTION_H
#define EXCEPTION_H

class Exception
{
public:
virtual ~Exception();
virtual void printException();
};

#endif  //EXCEPTION_H

//IndexException5_2.h

#ifndef INDEXECEPTION_H
#define INDEXECEPTION_H

#include"Exception5_2.h"
class IndexException:public Exception
{
public:
virtual void printException();
};

#endif //INDEXECEPTION_H

//Exception5_2.cpp

#include"Exception5_2.h"
#include<iostream>
#include<string>
using namespace std;
Exception::~Exception()
{

}
void Exception::printException()
{
cout<<"Exception--printException"<<endl;
}

//IndexException5_2.cpp

#include"IndexException5_2.h"
#include<iostream>
#include<string>
using namespace std;
void IndexException::printException()
{
cout<<"提示：下标越界。"<<endl;
}

//main文件

#include<iostream>
#include<string>
#include<stdlib.h>
#include"IndexException5_2.h"
using namespace std;
/*************************************/
/*异常处理：
1.定义一个Exception类，成员函数：printException,析构函数
2.定义一个IndexException类，成员函数：printException()
/*************************************/
void test()
{
throw 10;
}

int main(void)
{
try
{
test();
}
catch(int)
{
cout<<"Exception"<<endl;
}
/* catch(CMemoryException* e)
{


}
catch(CFileException* e)
{

}
catch(CException* e)
{

} */


system("pause");
return 0;
}

cj_who_knows
关注
专栏目录
C++面向对象笔记（5）：多态篇
Stone Ocean
06-30 865
文章目录C++多态篇1.什么是多态1.多态分类-静态多态和动态多态（早绑定和晚绑定）3.普通虚函数-实现动态多态（晚绑定）4.虚析构函数-解决动态多态中存在的问题5.虚函数的实现原理-多态的实现原理6.函数的覆盖与隐藏7.虚析构函数的实现原理8.虚函数小结9.纯虚函数10.抽象类11.接口类12.RTTI-运行时内存识别(Run-Time Type Identification)13.异常处理 ...
C++之多态详解
be_a_struggler的博客
11-15 2842
C++多态，多态的概念，多态的定义及实现，虚函数，虚函数的重写，抽象类，多态的原理，单继承和多继承关系中的虚函数表 多态常见的面试题
c++远征之多态篇（虚函数）
CjhLoveAndroid的博客
03-25 479
一：多态概念 指相同对象收到不同消息或者不同对象收到相同消息时产生不同的动作。 多态又分为：静态多态（早绑定）和动态多态（晚绑定） 二：虚函数及其原理 /**********************************************************************************************/ 动态多态、虚函数        
9-C++远征之多态篇-学习笔记
天涯明月笙的编程之旅
07-29 1405
C++远征之多态篇 面向对象三大特征：封装，继承，多态 多态: 发出一条命令时，不同的对象接收到同样的命令做出的动作不同 多态篇会学习到的目录： 普通虚函数 &amp; 虚析构函数 纯虚函数：抽象类 &amp; 接口类 RTTI (运行时类型识别) 异常处理 概念区分: 隐藏 &amp; 覆盖 | 早绑定与晚绑定 虚函数表(核心部分) 多态的内容很多，概念也听起来有点变态 ...
慕课网-C++远征之多态篇（上）-学习笔记
weixin_34387468的博客
08-30 164
C++远征之多态篇 面向对象三大特征：封装，继承，多态 多态：发出一条命令时，不同的对象接收到同样的命令做出的动作不同 目录： 普通虚函数 & 虚析构函数 纯虚函数：抽象类 & 接口类 RTTI（运行时类型识别） 异常处理 概念：隐藏 & 覆盖 | 早绑定与晚绑定 虚函数表 多...
慕课网-C++远征之多态篇（中）-学习笔记
weixin_33738982的博客
08-31 225
c++远征之多态篇 纯虚函数 & 抽象类 例子： class Shape { public: virtual double calcArea()//虚函数 {return 0;} virtual double calcPerimeter() = 0;//纯虚函数 } 纯虚函数...
慕课网-C++远征之多态篇（下）-学习笔记
weixin_34018169的博客
08-31 113
RTTI（运行时类型识别） Run-Time Type Identification typeid < - > dynamic_cast 例子： class Flyable { public: virtual void takeoff() = 0;//起飞 virtual vo...
java多态天涯明月笙_6-C++远征之封装篇[上]-学习笔记
weixin_39819152的博客
03-08 140
C++远征之封装篇(上)课程简介类(抽象概念)，对象(真实具体)配角: 数据成员和成员函数(构成了精彩而完整的类)构造函数 & 析构函数(描述了对象的生生死死)对象复制和对象赋值 (使类的定义充满艺术)对象数组和对象指针 (将应用型态发挥到淋漓尽致)this指针(影子,贯穿大戏始终，却很少崭露头角)大家的思维模式会从面向过程到面向对象。处理更复杂程序。学完之后，搞一个迷宫的寻路程序。类和对...
C++远征之离港篇-学习笔记
天涯明月笙的编程之旅
07-24 1527
C++远征离港篇 离港总动员 C++远征计划的学习者肯定是冲着封装，继承，多态来的。 知识点: 指针 VS 引用 #define VS const(更强数据控制力) 函数默认值 &amp; 函数重载 内存管理(头疼): 堆中的内存管理几乎完全由程序员操心[出来混总是要还的] 封装 继承 多态 c++语言引用 引用类型: 什么是引用？ 引用就是变量的别名 ...
C++ 多态(1): 虚函数及实现原理
TechArtisan6的博客
07-09 1276
C++远征之多态篇视频教程 笔记 方便自己查阅和复习，温故而知新。 目录 1虚函数及实现原理 2 代码示例1 3 代码示例2 参考资料 多态 多态指相同对象接收到不同消息或不同对象收到相同消息时产生不同的动作。 多态分为静态多态和动态多态。 (1) 静态多态也称为早绑定。 (2) 动态多态也称为晚绑定，必须以封装和继承为基础。 1虚函数及实现原理 (1...
C++开发基于多态的职工管理系统源码.zip
05-31
C++开发基于多态的职工管理系统源码C++开发基于多态的职工管理系统源码C++开发基于多态的职工管理系统源码C++开发基于多态的职工管理系统源码C++开发基于多态的职工管理系统源码C++开发基于多态的职工管理系统源码...
P135~142C++类和对象多态学习笔记.docx
最新发布
04-13
C++ 类和对象多态学习笔记 本节笔记主要介绍了 C++ 中的多态概念，包括静态多态和动态多态，及其使用条件和优点。 多态是 C++ 面向对象三大特性之一，分为两类：静态多态和动态多态。静态多态是指函数重载和运算符...
C++多继承多态的实例详解
01-01
C++多继承多态的实现 如果一个类中存在虚函数，在声明类的对象时，编译器就会给该对象生成一个虚函数指针，该虚函数指针指向该类对应的虚函数表。 多态的实现是因为使用了一种动态绑定的机制，在编译期间不确定...
Unity 【Content Size Fitter】- 聊天气泡自动适配Text文本框大小
当代野生程序猿
02-25 5899
通常在展示人物对话的时候文本的长度是不定的，因此会需要动态的调整对话内容文本框的背景图片的大小，这里以如下这种气泡框的对话为例： 实现该需求涉及到的内容包括Content Size Fitter组件的使用、2D Sprite工具包的使用。 Content Size Fitter组件用于Text文本框，如图所示，我们将Horzontal Fit设为Preferred Size，当我们调整Text文本框中的内容时，其大小会自动进行调整。 注意Rect Transform中Pivot轴心点的设置
新唐NUC972 Linux（一）：USB烧写linux出厂镜像
小破孩的博客
02-20 3440
USB烧写出厂镜像 文章目录USB烧写出厂镜像前言一、硬件连接二、安装驱动三、烧写linux程序四、运行程序 前言 今天开始进军linux，学了那么久单片机，也摸得七七八八，至少点个灯还是会的。本人之所以买酷客的linux开发板主要是便宜，资料也算齐全，虽然没有原子那么好，不过也够了，找那么多借口，其实就是qiong。今天先从USB烧录官方提供的linux相关程序到芯片开始吧。 一、硬件连接 1、连接电源线 2、RS232转USB，需要安装CH340驱动，用于在电脑串口超级终端中查看调试信息。 3、U
WeChall CTF Writeup（一）
weixin_43211186的博客
02-25 1582
以下题目标题组成： [Score] [Title] [Author] 文章目录0x01 1 Training: Get Sourced by Gizmore0x02 1 Training: Stegano I by Gizmore0x03 1 Training: Crypto - Caesar I by Gizmore0x04 1 Training: WWW-Robots by Gizmore0x05 1 Training: ASCII by Gizmore 0x01 1 Training: Get Sou
C语言每日一练——第126天：佩奇借书问题
热门推荐
Edison's 小宇宙
02-25 2万+
史上最强借书方案问题讲解（代码详解+思路分析+动图演示+特性总结）
CS5261与CS5265功能应用|CS5261替代RTD2171|CS5265替代RTD2172
qq1659747718的博客
02-25 1345
CS5261可以完全替代兼容停产RTD2171,CS5265可以完全替代兼容RTD2172，芯片单价低，整体方案设计简单，整体BOM成本较RTD2171、RTD2172低。
C++与Java多态实现的深度解析
"本文主要探讨了C++和Java两种编程语言中多态的实现机制及其差异，帮助读者理解这两种语言如何支持多态性，并在实际编程中更好地利用这一特性。作者刘冠群是一名软件工程师，文章发布于2011年12月22日，适合中级读者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值