CPP 核心编程6-多态

news2024/11/17 3:43:12

 

#include "iostream"
using namespace std;

//多态
class Animal
{
public:
    void speak()
    {
        cout << "动物在说话" << endl;
    }
};

class Cat : public Animal
{
public:
    void speak()
    {
        cout << "cat在说话" << endl;
    }
};

//地址早绑定  在编辑阶段确定函数地址
//如果想执行让猫说话,那么这个函数地址就不能提前绑定,需要在运行阶段进行绑定,地址晚绑定
void speak(Animal &animal) // Animal & animal = cat;
{
    animal.speak();
}
int main()
{
    Cat cat;
    speak(cat); //输出的是动物在说话
    return 0;
}
动物在说话

想要让猫说话就需要将Animal 的speak方法定义为虚函数

#include "iostream"
using namespace std;

//多态
class Animal
{
public:
    //虚函数
    virtual void speak()
    {
        cout << "动物在说话" << endl;
    }
};

class Cat : public Animal
{
public:
    void speak()
    {
        cout << "cat在说话" << endl;
    }
};

//地址早绑定  在编辑阶段确定函数地址
//如果想执行让猫说话,那么这个函数地址就不能提前绑定,需要在运行阶段进行绑定,地址晚绑定
void speak(Animal &animal) // Animal & animal = cat;
{
    animal.speak();
}
int main()
{
    Cat cat;
    speak(cat); //输出的cat在说话
    return 0;
}
cat在说话

多态满足条件

1 有继承关系

2 子类要重写父类的虚函数

动态多态的使用

父类的指针或引用指向子类对象

 多态的原理：

#include "iostream"

using namespace std;
class Animal {
public:
     virtual void speak(){
        cout << "动物在说话" << endl;
    }
};
class Animal2 {
public:
    void speak(){
        cout << "动物在说话" << endl;
    }
};
void test1(){
    //空对象的大小为1
    cout << "sizeof Animal2:"<<sizeof(Animal2) << endl;
    //64位系统下，虚函数占8个字节，也就是一个指针的大小
    cout << "sizeof Animal:"<<sizeof(Animal) << endl;
}
int main() {
    test1();
    return 0;
}
sizeof Animal:8
sizeof Animal2:1

空对象内存分布：

 

 

#include "iostream"

using namespace std;
class Animal {
public:
     virtual void speak(){
        cout << "动物在说话" << endl;
    }
};
class Cat: public Animal {
public:
    virtual void speak(){
        cout << "小猫在说话" << endl;
    }
};
void speak(Animal & animal){
    animal.speak();
}
void test1(){
    Cat cat;
    speak(cat);
}
int main() {
    test1();
    return 0;
}
小猫在说话

原理：

由于Animal些了个虚函数，类结构发生了改变，多了一个指针，这个指针叫做虚函数表指针，虚函数表的内部记录了虚函数的入口地址，当子类重写了这个虚函数的时候，会把自身虚函数表中的函数给替换掉，替换为子类的函数，所以当你用父类的引用指向子类对象的时候，由于你本身是一个子类对象，所以当你去调用speak时，会在子类去找真正的函数地址。

Cat没发生重写时Cat的内存分布：

 

多态案例：

开闭原则：对修改进行关闭，对扩展进行开放

#include "iostream"

using namespace std;

class AbstractCalculator {
public:
    virtual int getResult() = 0;

    int m_Num1;
    int m_Num2;
};

class AddCalculator : public AbstractCalculator {
public:
    virtual int getResult() {
        return m_Num1 + m_Num2;
    }
};

class SubCalculator : public AbstractCalculator {
public:
    virtual int getResult() {
        return m_Num1 - m_Num2;
    }
};

class MulCalculator : public AbstractCalculator {
public:
    virtual int getResult() {
        return m_Num1 * m_Num2;
    }
};

void test() {
//多态使用：父类指针或者引用指向子类对象
    AbstractCalculator *ac = new MulCalculator;
    ac->m_Num1 = 10;
    ac->m_Num2 = 20;
    cout << ac->getResult() << endl;
    //开辟在堆区，用完记得销毁
    delete ac;
}

int main() {
    test();
    return 0;
}

总结：多态的优点：

代码组织结构清晰

可读性强

利于前期和后期的扩展以及维护

#include "iostream"

using namespace std;

//纯虚函数和抽象类
class Base {
public:
    //纯虚函数
    //只要有一个纯虚函数，这个类就称为抽象类
    //抽象类特点：
    //1 无法实例化对象
    //2 抽象类的子类，必须重写父类中的纯虚函数，否则也属于抽象类
    virtual void func() = 0;
};

class Son : public Base {
public:
    void func() {
        cout << "son func函数调用" << endl;
    }
};

class Son2 : public Base {
public:
    void func() {
        cout << "son2 func函数调用" << endl;
    }
};

void test() {
//    Base b;//抽象类时无法实例化对象
//    new Base;//抽象类时无法实例化对象

//Son s;//子类必须重写父类中的纯虚函数，否则无法实例化对象

    Base *base = new Son;
    base->func();
    Base *base2 = new Son2;
    base2->func();
}

int main() {
    test();
    return 0;
}
son func函数调用
son2 func函数调用

 

#include "iostream"

using namespace std;

//多态案例2 制作饮品
class AbstractDrink {
public:
    //煮水
    virtual void Boil() = 0;

    //冲泡
    virtual void Brew() = 0;

    //倒入杯中
    virtual void PourInCup() = 0;

    //加入辅料
    virtual void PutSomething() = 0;

    //制作饮品
    void makeDrink() {
        Boil();
        Brew();
        PourInCup();
        PutSomething();
    }
};

class Coffee : public AbstractDrink {
public:
    //煮水
    virtual void Boil() {
        cout << "咖啡煮水" << endl;
    }

    //冲泡
    virtual void Brew() {
        cout << "咖啡冲泡" << endl;
    }

    //倒入杯中
    virtual void PourInCup() {
        cout << "咖啡倒入杯中" << endl;
    };

    //加入辅料
    virtual void PutSomething() {
        cout << "咖啡加入辅料" << endl;
    }
};

class Tea : public AbstractDrink {
public:
    //煮水
    virtual void Boil() {
        cout << "茶叶煮水" << endl;
    }

    //冲泡
    virtual void Brew() {
        cout << "茶叶冲泡" << endl;
    }

    //倒入杯中
    virtual void PourInCup() {
        cout << "茶叶倒入杯中" << endl;
    };

    //加入辅料
    virtual void PutSomething() {
        cout << "茶叶加入辅料" << endl;
    }
};

void doWork(AbstractDrink *ad) {
    ad->makeDrink();
    delete ad;//释放
}

int main() {
    doWork(new Coffee);
    cout << "------------------------" << endl;
    doWork(new Tea);
    return 0;
}
咖啡煮水
咖啡冲泡
咖啡倒入杯中
咖啡加入辅料
------------------------
茶叶煮水
茶叶冲泡
茶叶倒入杯中
茶叶加入辅料

 

虚析构和纯虚析构

下面有问题的代码：

#include "iostream"

using namespace std;

//虚析构和纯虚析构
class Animal {
public:
    Animal() {
        cout << "Animal构造函数调用" << endl;
    }

    ~Animal() {
        cout << "Animal的析构函数调用" << endl;
    }

    //纯虚函数
    virtual void speak() = 0;
};

class Cat : public Animal {
public:
    Cat(string name) {
        cout << "Cat的构造函数调用" << endl;
        m_Name = new string(name);
    }

    ~Cat() {
        if (m_Name != nullptr) {
            cout << "Cat析构函数调用" << endl;
            delete m_Name;
            m_Name = nullptr;
        }
    }

    virtual void speak() {
        cout << *m_Name << "小猫在说话" << endl;
    }

    string *m_Name;
};

void test1() {
    Animal *animal = new Cat("Tom");
    animal->speak();
    //父类指针在析构的时候，不会调用子类中析构函数，
    //导致子类如果有堆区的属性，会出现内存泄漏
    delete animal;
}

int main() {
    test1();
    return 0;
}
Animal构造函数调用
Cat的构造函数调用
Tom小猫在说话
Animal的析构函数调用

上面没有输出Cat的析构函数

解决上面的办法也很简单，就是把父类Animal的析构函数改为虚析构函数

代码如下：

#include "iostream"

using namespace std;

//虚析构和纯虚析构
class Animal {
public:
    Animal() {
        cout << "Animal构造函数调用" << endl;
    }

    //利用虚析构可以解决 父类指针释放子类对象时不干净的问题
    virtual ~Animal() {
        cout << "Animal的析构函数调用" << endl;
    }

    //纯虚函数
    virtual void speak() = 0;
};

class Cat : public Animal {
public:
    Cat(string name) {
        cout << "Cat的构造函数调用" << endl;
        m_Name = new string(name);
    }

    ~Cat() {
        if (m_Name != nullptr) {
            cout << "Cat析构函数调用" << endl;
            delete m_Name;
            m_Name = nullptr;
        }
    }

    virtual void speak() {
        cout << *m_Name << "小猫在说话" << endl;
    }

    string *m_Name;
};

void test1() {
    Animal *animal = new Cat("Tom");
    animal->speak();
    //父类指针在析构的时候，不会调用子类中析构函数，
    // 导致子类如果有堆区的属性，会出现内存泄漏
    delete animal;
}

int main() {
    test1();
    return 0;
}
Animal构造函数调用
Cat的构造函数调用
Tom小猫在说话
Cat析构函数调用
Animal的析构函数调用

纯虚析构，直接执行会报错，大概提示就是无法解析的外部命令

#include "iostream"

using namespace std;

//虚析构和纯虚析构
class Animal {
public:
    Animal() {
        cout << "Animal构造函数调用" << endl;
    }

    //利用虚析构可以解决 父类指针释放子类对象时不干净的问题
//    virtual ~Animal() {
//        cout << "Animal的析构函数调用" << endl;
//    }
    //纯虚析构
    virtual  ~Animal() = 0;

    //纯虚函数
    virtual void speak() = 0;
};

class Cat : public Animal {
public:
    Cat(string name) {
        cout << "Cat的构造函数调用" << endl;
        m_Name = new string(name);
    }

    ~Cat() {
        if (m_Name != nullptr) {
            cout << "Cat析构函数调用" << endl;
            delete m_Name;
            m_Name = nullptr;
        }
    }

    virtual void speak() {
        cout << *m_Name << "小猫在说话" << endl;
    }

    string *m_Name;
};

void test1() {
    Animal *animal = new Cat("Tom");
    animal->speak();
    //父类指针在析构的时候，不会调用子类中析构函数，
    // 导致子类如果有堆区的属性，会出现内存泄漏
    delete animal;
}

int main() {
    test1();
    return 0;
}

虚析构的时候，是有函数的实现的，

但是上面的纯虚析构没有实现，比如父类中也有一些数据开辟到了堆区，析构函数实现就有用了，父类堆区实现在父类析构函数中实现。

解决方案，在类外实现析构函数

Animal::~Animal() {
    cout << "Animal纯虚析构函数调用" << endl;
}
#include "iostream"

using namespace std;

//虚析构和纯虚析构
class Animal {
public:
    Animal() {
        cout << "Animal构造函数调用" << endl;
    }

    //利用虚析构可以解决 父类指针释放子类对象时不干净的问题
//    virtual ~Animal() {
//        cout << "Animal的析构函数调用" << endl;
//    }
    //纯虚析构 需要声明，也需要实现（类外实现）
    //有了纯虚析构之后，这个类属于抽象类，无法实例化
    virtual  ~Animal() = 0;

    //纯虚函数
    virtual void speak() = 0;
};

Animal::~Animal() {
    cout << "Animal纯虚析构函数调用" << endl;
}

class Cat : public Animal {
public:
    Cat(string name) {
        cout << "Cat的构造函数调用" << endl;
        m_Name = new string(name);
    }

    ~Cat() {
        if (m_Name != nullptr) {
            cout << "Cat析构函数调用" << endl;
            delete m_Name;
            m_Name = nullptr;
        }
    }

    virtual void speak() {
        cout << *m_Name << "小猫在说话" << endl;
    }

    string *m_Name;
};

void test1() {
    Animal *animal = new Cat("Tom");
    animal->speak();
    //父类指针在析构的时候，不会调用子类中析构函数，
    // 导致子类如果有堆区的属性，会出现内存泄漏
    delete animal;
}

int main() {
    test1();
    return 0;
}
Animal构造函数调用
Cat的构造函数调用
Tom小猫在说话
Cat析构函数调用
Animal纯虚析构函数调用

多态案例3 电脑组装

#include "iostream"

using namespace std;

class CPU {
public:
    virtual void calculator() = 0;
};

class VideoCard {
public:
    virtual void display() = 0;
};

class Memory {
public:
    virtual void storage() = 0;
};

class Computer {
public:
    Computer(CPU *cpu, VideoCard *vCard, Memory *mem) {
        m_cpu = cpu;
        m_vCard = vCard;
        m_mem = mem;
    }

    void work() {
        m_cpu->calculator();
        m_vCard->display();
        m_mem->storage();
    }

    //提供析构函数来释放3个零件
    ~Computer() {
        if (m_cpu != nullptr) {
            delete m_cpu;
            m_cpu = nullptr;
        }
        if (m_vCard != nullptr) {
            delete m_vCard;
            m_vCard = nullptr;
        }
        if (m_mem != nullptr) {
            delete m_mem;
            m_mem = nullptr;
        }
    }

private:
    CPU *m_cpu;
    VideoCard *m_vCard;
    Memory *m_mem;
};

//具体厂商 Intel
class IntelCPU : public CPU {
public:
    virtual void calculator() {
        cout << "Intel CPU" << endl;
    }
};

class IntelVideoCard : public VideoCard {
public:
    virtual void display() {
        cout << "Intel VideoCard" << endl;
    }

};

class IntelMemory : public Memory {
public:
    virtual void storage() {
        cout << "Intel Memory" << endl;
    }
};

//具体厂商 Lenovo
class LenovoCPU : public CPU {
public:
    virtual void calculator() {
        cout << "Lenovo CPU" << endl;
    }
};

class LenovoVideoCard : public VideoCard {
public:
    virtual void display() {
        cout << "Lenovo VideoCard" << endl;
    }

};

class LenovoMemory : public Memory {
public:
    virtual void storage() {
        cout << "Lenovo Memory" << endl;
    }
};

void test() {
    //创建第一台电脑
    Computer *computer = new Computer(new LenovoCPU, new IntelVideoCard, new IntelMemory);
    computer->work();
    cout << "------------------" << endl;
    //创建第二台电脑
    CPU *cpu2 = new IntelCPU;
    VideoCard *vc2 = new IntelVideoCard;
    Memory *mem2 = new LenovoMemory;
    Computer *computer2 = new Computer(cpu2, vc2, mem2);
    computer2->work();
}

int main() {
    test();
    return 0;
}

Lenovo CPU
Intel VideoCard
Intel Memory
------------------
Intel CPU
Intel VideoCard
Lenovo Memory

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

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

相关文章

【C语言航路】第七站:结构体初阶

【C语言航路】第七站:结构体初阶

目录 一、结构体的声明 1.结构的基础知识 2.结构的声明 3.结构体成员的类型 4.结构体变量的定义和初始化 二、结构体成员的访问 三、结构体传参 总结 一、结构体的声明 1.结构的基础知识 结构是一些值的集合&#xff0c;这些值称为成员变量&#xff0c;结构的每个成员可…
阅读更多...
《少有人走的路：心智成熟的旅程》笔记

《少有人走的路：心智成熟的旅程》笔记

几乎人人都有心理问题&#xff0c;只是程度不同而已。 几乎人人都有横渡不同的心里疾病&#xff0c;只是得病的时间不同而已。 ps : 许多人都没有付出足够的时间和精力&#xff0c;去解决知识、社交、心理方面的问题 作者序言&#xff1a; 目录 一、痛苦的价值 二、对待痛苦…
阅读更多...
Linux操作系统粘滞位（解决上篇文章提出的问题）

Linux操作系统粘滞位（解决上篇文章提出的问题）

前言 &#xff1a; 在上一篇Linux操作系统的博客中提出了&#xff0c;一个问题就是在一个公共目录里&#xff0c;假如我们有了对目录写的权限&#xff0c;我们就能进行创建属于我们自己的文件&#xff0c;并且给这个文件进行设置他的权限&#xff0c;我们发现虽然是我的文件&am…
阅读更多...
抗疫行动题材网页设计 大学生最美逆行者感动人物网页代码 众志成城万众一心抗击疫情HTML网页设计

抗疫行动题材网页设计 大学生最美逆行者感动人物网页代码 众志成城万众一心抗击疫情HTML网页设计

&#x1f389;精彩专栏推荐 &#x1f4ad;文末获取联系 ✍️ 作者简介: 一个热爱把逻辑思维转变为代码的技术博主 &#x1f482; 作者主页: 【主页——&#x1f680;获取更多优质源码】 &#x1f393; web前端期末大作业&#xff1a; 【&#x1f4da;毕设项目精品实战案例 (10…
阅读更多...
【GD32F427开发板试用】+DHT11温湿度监测

【GD32F427开发板试用】+DHT11温湿度监测

本篇文章来自极术社区与兆易创新组织的GD32F427开发板评测活动&#xff0c;更多开发板试用活动请关注极术社区网站。作者&#xff1a;四季的温度 在完成所有项目后会开源&#xff0c;本次依旧是想做一个通过DHT11采集信息&#xff0c;OLED显示&#xff0c;ESP8266上传&#xff…
阅读更多...
第二十四章《学生信息管理系统》第1节：学生信息管理系统简介

第二十四章《学生信息管理系统》第1节：学生信息管理系统简介

学生信息管理系统用于管理学生基本信息，该系统除能够大大的帮助学籍管理人员提高工作效率。本小节将从软件功能、数据库系统设计和项目结构几个方面介绍该软件系统的设计方案。 24.1.1系统功能简介 学生信息管理系统集信息展示、查询、增删和修改多种功能为一体，该系统的主…
阅读更多...
1552_AURIX_TC275_时钟分发

1552_AURIX_TC275_时钟分发

全部学习汇总&#xff1a; GreyZhang/g_TC275: happy hacking for TC275! (github.com) 这一页文件我没写什么批注&#xff0c;但是还是留下来了。从这个图中能够看到各个模块的时钟源是可以来自于什么地方。 1. CCU的输入主要是来自于两个PLL、备份时钟以及晶振。 2. 对大多数…
阅读更多...
SpringBoot引入外部jar包，项目打包成war包发布(亲测有效) - 第453篇

SpringBoot引入外部jar包，项目打包成war包发布(亲测有效) - 第453篇

历史文章&#xff08;文章累计450&#xff09; 《国内最全的Spring Boot系列之一》 《国内最全的Spring Boot系列之二》 《国内最全的Spring Boot系列之三》 《国内最全的Spring Boot系列之四》 《国内最全的Spring Boot系列之五》 利用Spring扩展点对敏感信息加密解密&a…
阅读更多...
【小f的刷题笔记】（JS）数组 - 前缀和 LeetCode303 LeetCode34

【小f的刷题笔记】（JS）数组 - 前缀和 LeetCode303 LeetCode34

【数组】 前缀和&#xff1a; &#x1f31f; 原始数组不会被修改的情况下&#xff0c;频繁查询某个区间的累加和 ✔ 一次把所有从一开始到本数的累加值计算出来存在一个新数组里&#xff0c;区间的累加值通过减法得出 LeetCode303 链接&#xff1a; 303.区域和检索 - 数组…
阅读更多...
刷爆力扣之至少是其它数字两倍的最大数

刷爆力扣之至少是其它数字两倍的最大数

刷爆力扣之至少是其它数字两倍的最大数 HELLO&#xff0c;各位看官大大好&#xff0c;我是阿呆 &#x1f648;&#x1f648;&#x1f648; 今天阿呆继续记录下力扣刷题过程&#xff0c;收录在专栏算法中 &#x1f61c;&#x1f61c;&#x1f61c; 该专栏按照不同类别标签进行刷…
阅读更多...
一文带你了解【深度学习】中CNN、RNN、LSTM、DBN等神经网络（图文解释 包括各种激活函数）

一文带你了解【深度学习】中CNN、RNN、LSTM、DBN等神经网络（图文解释 包括各种激活函数）

觉得有帮助请点赞关注收藏~~~ 一、深度学习概述 深度学习算法属于机器学习算法的范畴&#xff0c;深度学习一般具有自主学习能力 基于深度学习的自然语言处理基本操作步骤包括&#xff1a; 将原始信息输入神经网络模型&#xff0c;通过自主学习算法识别输入特征&#xff1b;…
阅读更多...
Redis 发布订阅

Redis 发布订阅

Redis 发布订阅 Redis 发布/订阅 (publish/subscribe) 是一种消息通信模式&#xff1a;发送者 (publish) 发送消息&#xff0c;订阅者 (subscribe) 接收消息。 Redis 客户端可以订阅任意数量的频道。 下图展示了频道 channel1&#xff0c;以及订阅这个频道的三个客户端 ——…
阅读更多...
李沐论文精度系列之八：视频理解论文串讲

李沐论文精度系列之八：视频理解论文串讲

文章目录一 、前言二、 DeepVideo&#xff08;IEEE 2014&#xff09;2.1 模型结构2.2 实验结果2.3 总结三、双流网络及其变体3.1 Two-Stream&#xff08;NeurIPS 2014&#xff09;3.1.1 简介3.1.2 改进工作3.2 Two stream LSTM&#xff08;CVPR 2015 &#xff09;3.2.1 模型结构…
阅读更多...
Django的学习笔记

Django的学习笔记

Django初笔记一、认识Django1.基本原理2.框架二、建立一个简单的项目1.建立一个HelloWord&#xff08;1&#xff09;进入虚拟环境&#xff08;2&#xff09;建立项目三、基本应用结构&#xff08;1&#xff09;配置文件setting&#xff08;2&#xff09;URL&#xff08;路由系统…
阅读更多...
【C语言进阶(NEW)】一、数据储存详解|数据类型介绍|整形在内存中的存储|浮点型在内存中的存储

【C语言进阶(NEW)】一、数据储存详解|数据类型介绍|整形在内存中的存储|浮点型在内存中的存储

目录 一、数据类型介绍 1.1 基本内置类型 1.2 类型的基本归类 1.3 有符号&#xff08;signed&#xff09;与无符号&#xff08;unsigned&#xff09;的区别 二、整形在内存中的存储 2.1 原码、反码、补码 2.2 大小端 2.2.1 什么是大小端 2.2.2 为什么有大端和小端 2.…
阅读更多...
Dubbo(分布式框架·上)

Dubbo(分布式框架·上)

Dubbo上一、导入1、基础知识1.1、什么是分布式系统1.2、发展演变1.2.1 单一应用架构1.2.2分布式应用架构1.2.3 流动计算架构1.3 RPC1.3.1 什么是RPC1.3.2 RPC核心模块二、Dubbo概念三、设计架构四、环境搭建4.1 Zookeeper注册中心4.2 测试Zookeeper4.1 监控中心五、测试5.1 需求…
阅读更多...
论文阅读-ATLAS: A Sequence-based Learning Approach for Attack Investigation

论文阅读-ATLAS: A Sequence-based Learning Approach for Attack Investigation

论文代码&#xff1a; https://github.com/purseclab/ATLAS 代码预处理写的太乱了&#xff0c;很多预处理过程都不是特别合理。不过这篇论文思想还是挺合理的&#xff0c;相比其实溯源图工作在路径上的处理更加合理一些。 背景简介 高级可持续威胁攻击&#xff08;Advanced P…
阅读更多...
AXI VDMA回环测试

AXI VDMA回环测试

Block Design 搭建如下图所示的硬件系统&#xff1a; 该硬件系统的数据流向为&#xff1a; DDR–>AXI VDMA–>AXI DATA FIFO–>AXI VDMA–>DDR 即将一幅图像由一段地址空间搬运至另一段地址空间。 其中&#xff0c;AXI VDMA配置如下&#xff1a; 地址位宽32&…
阅读更多...
[附源码]Python计算机毕业设计SSM健身房管理系统 （程序+LW)

[附源码]Python计算机毕业设计SSM健身房管理系统 （程序+LW)

项目运行 环境配置&#xff1a; Jdk1.8 Tomcat7.0 Mysql HBuilderX&#xff08;Webstorm也行&#xff09; Eclispe&#xff08;IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持&#xff09;。 项目技术&#xff1a; SSM mybatis Maven Vue 等等组成&#xff0c;B/S模式 M…
阅读更多...
认识3dmax 轴心

认识3dmax 轴心

轴心&#xff0c;pivot&#xff1b; 资料对轴心的说明如下&#xff0c; 物体轴心 每个物体有且仅有一个轴心&#xff0c; 轴心位置确定了物体的位置&#xff0c; 物体旋转是围绕轴心旋转的; 轴心&#xff0c;我没看到说是一个点或一条线&#xff1b;在三维空间应…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023