05 类和对象 3

news2024/11/5 18:51:18

目录

  1. 再谈构造函数
  2. static成员
  3. 友元
  4. 内部类
  5. 匿名对象
  6. 拷贝对象时一些编译器优化
  7. 再次理解封装

1. 再谈构造函数

1.1 构造函数赋值

在创建对象时,编译器调用构造函数,给对象中各个成员变量一个合适的初始值

class Date
{
public:
Date(int year, int month, int day)
 {
     _year = year;
     _month = month;
     _day = day;
 }
private:
int _year;
int _month;
int _day;
};

虽然上述函数调用后,对象有了初始值,但是不能将其称为初始化,构造函数体中的雨具只是为其赋值,而不是初始化。因为初始化只能初始化一次,构造函数内可以多次赋值

函数内赋值并不能应付所有情况
1.如果类成员时const常量,必须在定义的时候初始化,除过默认值之外不能随参数初始化
2.类成员是引用类型,必须在定义的时候初始化
3.类成员是类类型,想用某个参数去初始化该类

class A
{
public:
	A(int b)
	{

	}
};
class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
	const int _sun; //常量
	int& _test1;    //引用
	A _aa;          //类类型
};

运行后3个类型都会报错
在这里插入图片描述

1.2 初始化列表

初始化列表:以一个冒号开始,接着以一个逗号分隔的数据成员列表,每个“成员变量”后面跟一个放在括号中的初始值或表达值

编译器在创建对象的时候,首先会执行初始化列表,然后再走函数内的赋值

上面的用初始化列表就可以完成

class A
{
public:
	A(int b)
	{

	}
};
class Date
{
public:
	Date(int year, int month, int day, int aa)
		:_sun(5),
		_test1(_year),
		_aa(aa)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
	const int _sun; //常量
	int& _test1;    //引用
	A _aa;          //类类型
};

int main()
{
	Date t1(2022,4,5,10);
	return 0;
}

【注意】
1.每个成员变量在初始化列表只能出现一次(初始化一次)
2.类中包含引用、const、自定义类型(且没有默认构造函数时)成员必须在初始化列表初始化
3.尽量使用初始化列表,不管是否使用初始化列表,对于自定义类型变量,一定会先试用初始化列表初始化
4.成员变量在类中声明次序就是初始化列表的初始化顺序,和初始化列表中先后次序无关

class A
{
public:
    A(int a)
       :_a1(a)
       ,_a2(_a1)
   {}
    
    void Print() {
        cout<<_a1<<" "<<_a2<<endl;
   }
private:
    int _a2;
    int _a1;
};
int main() {
    A aa(1);
    aa.Print();
}
A. 输出1  1
B.程序崩溃
C.编译不通过
D.输出1  随机值

上面的根据声明顺序,先初始化_a2,由于_a1是默认值,所以初始化_a2为默认值,_a1初始化为传入值1,选D

1.3 explicit关键字

构造函数不仅可以构造与初始化对象,对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数还有类型转换的作用

class Date
{
public:

 // 1. 单参构造函数,没有使用explicit修饰,具有类型转换作用
 // explicit修饰构造函数,禁止类型转换---explicit去掉之后,代码可以通过编译
explicit Date(int year)
	:_year(year)
{}

/*
// 2. 虽然有多个参数,但是创建对象时后两个参数可以不传递,没有使用explicit修饰,具
有类型转换作用
 // explicit修饰构造函数,禁止类型转换
 explicit Date(int year, int month = 1, int day = 1)
 : _year(year)
 , _month(month)
 , _day(day)
 {}
 */
Date& operator=(const Date& d)
{
	if (this != &d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	return *this;
}
private:
	int _year;
	int _month;
	int _day;
};
void Test()
{
	Date d1(2022);
	// 用一个整形变量给日期类型对象赋值
	// 实际编译器背后会用2023构造一个无名对象,最后用无名对象给d1对象进行赋值
	d1 = 2023;
	// 将1屏蔽掉,2放开时则编译失败,因为explicit修饰构造函数,禁止了单参构造函数类型转
	//换的作用
}

用explicit修饰,禁止隐式转换,增加可读性

2. static成员

2.1 概念

声明为static的类成员称为类的静态成员,用static修饰的成员变量,称之为静态成员变量,用static修饰的成员函数,称之为静态成员函数。静态成员变量一定要在类外进行初始化

如果要用一个类,统计创建了多少个类对象

可以使用一个全局变量,每次调用构造函数时将变量增加1,但全局变量可以在任何地方进行修改,不够安全

所以使用上面的静态成员变量,在类外初始化为0

class A
{
public:
	A() {
		++_scount; 
	}
	A(const A & t) {
		++_scount; 
	}
	~A() { 
		--_scount;
	}
	int GetACount() { 
		return _scount;
	}
private:
	static int _scount;
};
//类外初始化
int A::_scount = 0;

int main()
{
	A a1;
	A a2;
	A a3;
	A a4;
	cout<<a4.GetACount();
	return 0;
}

因为是私有的,不能直接访问静态成员变量,所以调用函数来求变量。但实际上,并不知道最后一个类对象时a4,如果用新的类来调用返回个数,会多构建一次,次数必须减一,那么有什么办法直接返回数量

可以用静态成员函数返回数量,静态成员函数可以在类外加作用域限定符直接访问

class A
{
public:
	A() {
		++_scount; 
	}
	A(const A & t) {
		++_scount; 
	}
	~A() { 
		--_scount;
	}
	static int GetACount() { 
		return _scount;
	}
private:
	static int _scount;
};
//类外初始化
int A::_scount = 0;

int main()
{
	A a1;
	A a2;
	A a3;
	A a4;
	cout<<A::GetACount();
	return 0;
}

2.2 特性

1.静态成员为所有类对象共享,不属于某个具体对象,存放在静态区
2.静态成员变量必须在类外定义,定义时不能添加static关键字,类中只是声明
3.类静态成员可用类名::静态成员或者对象.静态成员访问
4.静态成员函数没有隐藏的this指针,不能访问任何非静态成员
5.静态成员也是类的成员,受public等限定符限制

同样遵循规则不能放大的特性,静态成员函数不能访问非静态成员函数,非静态成员函数可以调用类的静态成员函数

3. 友元

友元提供了一种突破封装的方式,有时提供了便利。会增加耦合度,破坏封装,所以不宜多用
友元分为:友元函数和友元类

3.1 友元函数

在类中重载<<操作符发现无法重载,因为cout输出流对象的隐含this指针抢占在第一个参数的位置.this指针默认是第一个参数也是左操作数,但是实际cout需要是第一个形参对象才能使用。如果将<<重载成全局函数,又会导致类外无法访问成员,这时用友元来解决

class Date
{
public:
Date(int year, int month, int day)
     : _year(year)
     , _month(month)
     , _day(day)
 {}
 // d1 << cout; -> d1.operator<<(&d1, cout); 不符合常规调用
// 因为成员函数第一个参数一定是隐藏的this,所以d1必须放在<<的左侧
ostream& operator<<(ostream& _cout)
 {
     _cout << _year << "-" << _month << "-" << _day << endl;
     return _cout;
 }
private:
int _year;
int _month;
int _day;
};

友元函数可以直接访问类的私有成员,定义在类外部的普通函数,不属于任何类,但需要在类的内部声明,声明时加friend关键字

class Date
{
 friend ostream& operator<<(ostream& _cout, const Date& d);
 friend istream& operator>>(istream& _cin, Date& d);
public:
 Date(int year = 1900, int month = 1, int day = 1)
 : _year(year)
 , _month(month)
 , _day(day)
 {}
private:
 int _year;
 int _month;
 int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
 _cout << d._year << "-" << d._month << "-" << d._day;
 return _cout; 
}
istream& operator>>(istream& _cin, Date& d)
{
 _cin >> d._year;
 _cin >> d._month;
 _cin >> d._day;
 return _cin;
}
int main()
{
 Date d;
 cin >> d;
 cout << d << endl;
 return 0;
}

说明:

  • 友元函数可以访问类的私有和保护成员,但不是类的成员函数
  • 友元函数不能用const修饰
  • 友元函数可以在类定义的任何地方声明,不受类访问限定符限制
  • 一个函数可以是多个类的友元函数
  • 友元函数的调用和普通函数的调用原理相同

3.2 友元类

友元类的所有成员函数都可以是另一个类的友元函数,都可以访问领一个类中的非公有成员

  • 友元关系是单向的,不具有交换性
    比如上述Time类和Date类,在TIme类声明Date为友元类,Date类可以访问Time类的私有成员,但Time不能访问Date类的私有成员

  • 友元关系不能传递
    C是B的友元,B是A的友元,不能说C是A的友元

  • 友元关系不能继承

class Time
{
   friend class Date;   // 声明日期类为时间类的友元类,则在日期类中就直接访问Time类
中的私有成员变量
public:
 Time(int hour = 0, int minute = 0, int second = 0)
 : _hour(hour)
 , _minute(minute)
 , _second(second)
 {}
   
private:
   int _hour;
   int _minute;
   int _second;
};
class Date
{
public:
   Date(int year = 1900, int month = 1, int day = 1)
       : _year(year)
       , _month(month)
       , _day(day)
   {}
   
   void SetTimeOfDate(int hour, int minute, int second)
   {
       // 直接访问时间类私有的成员变量
       _t._hour = hour;
       _t._minute = minute;
       _t._second = second;
   }
   
private:
   int _year;
   int _month;
   int _day;
      Time _t;
};

4. 内部类

概念:如果一个类定义在另一个类的内部,这个叫内部类。是一个独立的类,不属于外部类,更不能通过外部类的对象去访问内部类的成员

内部类是外部类的友元类,内部类可以通过外部类的对象参数来访问外部类的所有成员,但外部类不是内部类的友元

特性:
1.内部类可以定义在外部类的public等所有限定符内
2.注意内部类可以直接访问外部类中的static成员,不需要外部类的对象/类名
3.sizeof(外部类)=外部类,和内部类没有任何关系

class A
{
private:
 static int k;
 int h;
public:
 class B // B天生就是A的友元
 {
 public:
 void foo(const A& a)
 {
 cout << k << endl;//OK
 cout << a.h << endl;//OK
 }
 };
};
int A::k = 1;
int main()
{
    A::B b;
    b.foo(A());
    
    return 0;
}

5. 匿名对象

class A
{
public:
 A(int a = 0)
 :_a(a)
 {
 cout << "A(int a)" << endl;
 }
 ~A()
 {
 cout << "~A()" << endl;
 }
private:
 int _a;
};
class Solution {
public:
 int Sum_Solution(int n) {
 //...
 return n;
 }
};
int main()
{
 A aa1;
 // 不能这么定义对象,因为编译器无法识别下面是一个函数声明,还是对象定义
 //A aa1();
 // 但是我们可以这么定义匿名对象,匿名对象的特点不用取名字,
 // 但是他的生命周期只有这一行,我们可以看到下一行他就会自动调用析构函数
 A();
 A aa2(2);
 // 匿名对象在这样场景下就很好用,当然还有一些其他使用场景,这个我们以后遇到了再说
 Solution().Sum_Solution(10);
 return 0;
}

6. 拷贝对象时的一些编译器优化

在传参和川返回值的过程中,一般编译器会做一些优化,减少对象的拷贝,在一些场景下是非常有用的

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "构造" << endl;
	}
	A(const A& aa)
		:_a(aa._a)
	{
		cout << "拷贝构造" << endl;
	}
	A& operator=(const A& aa)
	{
		cout << "赋值重载" << endl;
		if (this != &aa)
		{
			_a = aa._a;
		}
		return *this;
	}
	~A()
	{
		cout << "析构" << endl;
	}
private:
	int _a;
};
void f1(A aa)
{}
A f2()
{
	A aa;
	return aa;
}


int main()
{
	// 传值传参
	/*A aa1;
	f1(aa1);
	cout << endl;*/
	// 传值返回
	f2();
	//cout << endl;
	 隐式类型,连续构造+拷贝构造->优化为直接构造
	//f1(1);
	 一个表达式中,连续构造+拷贝构造->优化为一个构造
	//f1(A(2));
	//cout << endl;
	 一个表达式中,连续拷贝构造+拷贝构造->优化一个拷贝构造
	//A aa2 = f2();
	//cout << endl;
	 一个表达式中,连续拷贝构造+赋值重载->无法优化
	//aa1 = f2();
	//cout << endl;
	return 0;
}

1.定义类对象时,会调用对应的构造和析构
在这里插入图片描述

2.对象初始化用整数=,整数需要转类型构造为对象类型,会将构造+拷贝构造优化为构造
在这里插入图片描述

3.分为两个语句,无优化,先构造再拷贝构造
在这里插入图片描述

4.在函数传参传值时,实参为整数类型,会将构造和拷贝构造优化为一次构造
在这里插入图片描述在这里插入图片描述

5.用引用作为参数传递,第3点会不需要拷贝构造,直接传递。后面两个结果相同,传引用不需要优化
在这里插入图片描述

6.f2函数返回局部类值,构造对象,返回时拷贝构造一份临时对象,会优化为一次构造
在这里插入图片描述
7.类初始化为f2返回值,原为1次构造两次拷贝构造,会直接优化为一次构造
在这里插入图片描述
8.第7条返回匿名对象,也会直接优化为一次构造
在这里插入图片描述
9.先初始化对象,再赋值为f2函数返回对象,调用2次构造1次拷贝构造1次赋值重载,优化为两次构造1次赋值重载
在这里插入图片描述
以上基于vs2022,不同的编译器会做不同的优化,具体根据编译器和版本决定

总结
1.接收返回值对象,尽量拷贝构造方式接收,不要赋值接收
2.函数中返回对象时,尽量返回匿名对象
3.尽量使用引用传参

6. 再次理解类和对象

现实生活中的实体计算机并不认识,计算机只认识二进制格式的数据。如果想要让计算机认识现实生活中的实体,用户必须通过某种面向对象的语言,对实体进行描述,然后通过编写程序,创建对象后计算机才可以认识。比如想要让计算机认识洗衣机,就需要:

  1. 用户先要对现实中洗衣机实体进行抽象—即在人为思想层面对洗衣机进行认识,洗衣机有什么属性,有那些功能,即对洗衣机进行抽象认知的一个过程
  2. 经过1之后,在人的头脑中已经对洗衣机有了一个清醒的认识,只不过此时计算机还不清楚,想要让计算机识别人想象中的洗衣机,就需要人通过某种面相对象的语言(比如:C++、Java、Python等)将洗衣机用类来进行描述,并输入到计算机中
  3. 经过2之后,在计算机中就有了一个洗衣机类,但是洗衣机类只是站在计算机的角度对洗衣机对象进行描述的,通过洗衣机类,可以实例化出一个个具体的洗衣机对象,此时计算机才能洗衣机是什么东西。
  4. 用户就可以借助计算机中洗衣机对象,来模拟现实中的洗衣机实体了。

在类和对象阶段,大家一定要体会到,类是对某一类实体(对象)来进行描述的,描述该对象具有那些属性,那些方法,描述完成后就形成了一种新的自定义类型,才用该自定义类型就可以实例化具体的对象

8. 习题

求和
https://www.nowcoder.com/practice/7a0da8fc483247ff8800059e12d7caf1?tpId=13&tqId=11200&tPage=3&rp=3&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking
在这里插入图片描述

思路:
利用静态成员变量全局属性的特点,一个记录和,一个记录当前值。构造函数中赋值。另一个类求几的和就申请几个该类

class Solution {
	class sum {
	public:
		sum()
		{
			_sum += i;
			i++;
		}
		int getsum()
		{
			return _sum;
		}
	};
public:
	int Sum_Solution(int n) {
		sum* s = new sum[n];
		return s[n - 1].getsum();
	}
private:
	static int _sum;
	static int i;
};

int Solution::_sum = 0;
int Solution::i = 1;

计算日期到天数转换
https://www.nowcoder.com/practice/769d45d455fe40b385ba32f97e7bcded?tpId=37&&tqId=21296&rp=1&ru=/activity/oj&qru=/ta/huawei/question-ranking

在这里插入图片描述
思路:
用一个数组记录每个月最多是多少天,判断是润年且月份大于2月就多一天,否则就返回前一个月的天数加当前月的天数

#include <iostream>
using namespace std;

int main() {
    int year;
    int month;
    int day;
    cin >> year >> month >> day;
    int ary[13] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365};
    if (month > 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)) {
        cout << ary[month - 1] + day + 1;
    } else {
        {
            cout << ary[month - 1] + day;
        }
    }
}

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

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

相关文章

前端基础自学整理|DOM树

DOM&#xff0c;文档对象模型&#xff08;Document Object Model&#xff09;&#xff0c;简单的说&#xff0c;DOM是一种理念&#xff0c;一种思想&#xff0c;一个与系统平台和编程语言无关的接口&#xff0c;一种方法, 使 Web开发人员可以访问HTML元素&#xff01;不是具体方…

MySQL语句大全

MySQL语句大全 数据库操作数据表操作往表中插入数据修改表中数据删除表中数据查询表中数据用户管理函数约束 (限制表中的字段值)多表查询事务 数据库操作 -- 显示数据库 show databases;-- 创建一个数据库 demo create database demo;-- 若不存在数据库 demo 则创建一个数据库…

软件测试基础篇(完整版)

&#x1f345; 视频学习&#xff1a;文末有免费的配套视频可观看 &#x1f345; 点击文末小卡片&#xff0c;免费获取软件测试全套资料&#xff0c;资料在手&#xff0c;涨薪更快 “尽早的介入测试&#xff0c;遇到问题的解决成本就越低” 随着软件测试技术的发展&#xff0c…

Flutter NestedScrollView 内嵌视图滚动行为一致

Flutter NestedScrollView 内嵌视图滚动行为一致 视频 https://youtu.be/_h7CkzXY3aM https://www.bilibili.com/video/BV1Gh4y1571p/ 前言 上一节讲了 CustomScrollView &#xff0c;可以发现有的地方滚动并不是很连贯。 这时候就需要 NestedScrollView 来处理了。 今天会写…

Promise中的链式流

如果阅读有疑问的话&#xff0c;欢迎评论或私信&#xff01;&#xff01; 本人会很热心的阐述自己的想法&#xff01;谢谢&#xff01;&#xff01;&#xff01; 携手共进&#xff01; 文章目录 前言深入Promise链式流 前言 在探索Promise链式流之前我们要知道两个Promise固有…

js设计模式:依赖注入模式

作用: 在对象外部完成两个对象的注入绑定等操作 这样可以将代码解耦,方便维护和扩展 vue中使用use注册其他插件就是在外部创建依赖关系的 示例: class App{constructor(appName,appFun){this.appName appNamethis.appFun appFun}}class Phone{constructor(app) {this.nam…

【鸿蒙 HarmonyOS 4.0】网络请求

一、介绍 资料来自官网&#xff1a;文档中心 网络管理模块主要提供以下功能&#xff1a; HTTP数据请求&#xff1a;通过HTTP发起一个数据请求。WebSocket连接&#xff1a;使用WebSocket建立服务器与客户端的双向连接。Socket连接&#xff1a;通过Socket进行数据传输。 日常…

车载测试,检测项目标准

检测项目&#xff1a; 二.GB/T 31486-2015电动汽车用动力蓄电池电性能要求及试验方法 说明&#xff1a;本标准规定了电动汽车用动力蓄电池(以下简称蓄电池)的 电性能要求、试验方法、检验规则。本标准适用于装载在电动汽车 上的锂离子蓄电池和金属氢化 物镍蓄电池单体和模块&a…

设计模式-创建型模式-抽象工厂模式

抽象工厂模式&#xff08;Abstract Factory Pattern&#xff09;&#xff1a;提供一个创建一系列相关或相互依赖对象的接口&#xff0c;而无须指定它们具体的类。抽象工厂模式又称为Kit模式&#xff0c;它是一种对象创建型模式。 由于工厂方法模式中的每个工厂只生产一类产品&…

JS基础之JSON对象

JS基础之JSON对象 目录 JS基础之JSON对象对象转JSON字符串JSON转JS对象 对象转JSON字符串 JSON.stringify(value,replacer,space) value:要转换的JS对象 replacer:(可选)用于过滤和转换结果的函数或数组 space:(可选)指定缩进量 // 创建JS对象 let date {name:"张三…

如何利用内网穿透工具在企业微信开发者中心实现本地接口服务回调

文章目录 1. Windows安装Cpolar2. 创建Cpolar域名3. 创建企业微信应用4. 定义回调本地接口5. 回调和可信域名接口校验6. 设置固定Cpolar域名7. 使用固定域名校验 企业微信开发者在应用的开发测试阶段&#xff0c;应用服务通常是部署在开发环境&#xff0c;在有数据回调的开发场…

时序数据库TimescaleDB,实战部署全攻略

&#x1f4e2;&#x1f4e2;&#x1f4e2;&#x1f4e3;&#x1f4e3;&#x1f4e3; 哈喽&#xff01;大家好&#xff0c;我是【IT邦德】&#xff0c;江湖人称jeames007&#xff0c;10余年DBA及大数据工作经验 一位上进心十足的【大数据领域博主】&#xff01;&#x1f61c;&am…

2024华北医院信息网络大会第二轮更新通知

大会背景 近年来&#xff0c;我国医疗行业信息化取得了飞跃式的发展&#xff0c;医疗信息化对医疗行业有着重要的支撑作用。2021年国家卫健委、中医药管理局联合印发《公立医院高质量发展促进行动&#xff08;2021-2025年&#xff09;》&#xff0c;提出重点建设“三位一体”智…

Linux定时任务调度

Linux定时任务调度 crond 任务调度 crontab 进行定时任务的设置 介绍 任务调度&#xff1a;是指系统在某个时间执行的特定的命令或程序。 任务调度分类&#xff1a;系统工作&#xff1a;有些重要的工作必须周而复始地执行。如病毒扫描等 个别用户工作&#xff1a;个别用户可能…

SpringBoot指定外部环境配置

nohup java -Xms256m -Xmx512m -Dfile.encodingUTF-8 -jar /usr/local/xxxx.jar --spring.profiles.activeprod > system.log 2>&1 & --spring.profiles.activeprod修改的是多环境配置中内部application.properties里的spring.profiles.active值 -Dspring.config…

SOC电源管理系统简介

1. 概况 随着SOC越来越复杂&#xff0c;包含的IP越来越多&#xff0c;单个SOC上实现了CPU, 射频模块&#xff0c;相机模块&#xff0c;DDR控制模块&#xff0c;外设等等功能。多种功能&#xff0c;多种IP也带来了多档电源的需求。同时为了满足低功耗的挑战&#xff0c;SOC通常被…

代码随想录算法训练营第二十五天|Leetcode216 组合总和III、Leetcode17 电话号码的字母组合

代码随想录算法训练营第二十五天|Leetcode216 组合总和III、Leetcode17 电话号码的字母组合 ● Leetcode216.组合总和III● 解题思路● 代码实现 ● Leetcode17 电话号码的字母组合● 解题思路● 代码实现 ● Leetcode216.组合总和III 题目链接&#xff1a;Leetcode216.组合总和…

计算机网络-局域网和城域网(二)

1.局域网互联设备&#xff1a; 2层网桥&#xff08;生成树、源路由&#xff09;、3层交换机、路由器。网桥要求3层以上协议相同&#xff0c;1、2层协议不同可互联。 2.生成树网桥&#xff1a; 又叫透明网桥&#xff0c;IEEE802.1d&#xff0c;生成树算法。基本思想是在网桥之…

2024.2.22

将互斥机制的代码实现 #include<myhead.h> int num7; pthread_mutex_t mutex;//创建互斥锁变量 void *task1(void *arg) {printf("task1:\n");//获取锁资源pthread_mutex_lock(&mutex);num77777;sleep(2); printf("task1:num%d\n",num); //释放…

分享WebGL物体三维建模

界面效果 代码结构 模型素材类似CT (Computed Tomography)&#xff0c;即电子计算机断层扫描&#xff0c;它是利用精确准直的X线束、γ射线、超声波等&#xff0c;与灵敏度极高的探测器一同围绕物体的某一部位作一个接一个的断面扫描。 坐标系统 渲染流程 渲染流程是个将之前准…