Unreal Engine 游戏开发学习笔记 20181109


本篇博文实为在”系统”学习 Unreal Engine 4 游戏开发后整理的学习笔记。笔记按照每天的学习内容进行整理记录备忘。

本文为 Week3 Class5! 其中 表示上午的学习内容, 表示下午的学习内容。从本周开始连续三周学习 C++ 基础。同时强烈推荐像我一样的初学者看下”菜鸟教程”的 C++ 部分,本周的笔记绝大部分整理的内容均来自菜鸟笔记,只是内容按照上课老师所讲并在笔记中穿插了一些老师上课所讲实例,感谢菜鸟笔记网站管理员的无私分享。

今日内容摘要(知识点梳理):

今天全天都是做着两个周以来的C++ 学习内容梳理,老师的梳理方式同样是根据菜鸟笔记的网站进行查漏补缺!



知识点梳理

  1. 语句块中声明的变量叫局部变量,只在块内有效。
    (1)局部变量有形参,for循环内,语句块内的变量
    (2)全局变量 在所有函数外部定义的变量

  2. 关键字 变量名 类型名 各种名不能写关键字 关键字表需要看看

  3. 注释: // 及 段落注释 还有 #if 0 …. #endif的方法

  4. #预编译指令 编译器在编译之前准备工作会执行的。编译器会把源码变异成二进制语言

  5. 数据: 程序的本身就是在创建处理和编辑数据, 数据有数据类型 为什么有数据类型? 节约内存的目的:比如:高中就几天人使用short int即可只需要占用2个字节,如果使用int 就浪费了2个字节
    // 数据类型 中unsigned 表示非负数

  6. 强类型语言与弱类型语言
    (1)强类型 C++,C# 任何一个数据必须有一个确定的数据类型 一般不允许随意转换,但可以强制类型转换
    // 强制类型转换后 高精度转低精度会造成数据的丢失
    (2)弱类型 变量数据类型不确定 根据赋值类型确定

  7. typedef 定义个新类型 typedef int feet 给int类型起了个别名 size_t 其实就是 unsidned int

  8. 枚举变量的声明

  9. 32位系统 64位系统 一个字节=8位

  10. 变量定义个和初始化

  11. 左值和右值 // 10 “A” “Hello” 3.5 这些都是字变量都只能做右值 变量既可以放左边又可以放右边(左值可以放在右边 右值不能放在左边)


知识点梳理

  1. 不在任何函数内部声明的变量叫全局变量,一般写在程序头部,在函数内部,局部变量会覆盖全部变量

  2. 没有初始化(全局变量)的情况下,系统自动初始化 int 0 char’\0’ float 0 double 0 pointer NULL 局部变量必须手动初始化

  3. 定义变量 int a = 1; 先声明变量在调用

  4. 常量是固定值 不可修改 const int IntB = 100; 以后100不可更改,定义的时候可以更改以后不可修改
    字符串字面量是常量不可修改 string str = “Hello”; str = “Helll”,并没有改Hello是新的东西 以前指向“Hello”现在指向“Helll” str叫做字符串变量是可以更改的!!!
    #dedine 预处理指定常量 或在函数里使用 const 定义

  5. 修饰符 数据类型修饰符 类型限定符 普通变量会把变量放在寄存器中以加快速度 volatile(想得到地址(指针)并不需要得到他的cpu地址也得不到)

  6. 储存类 auto类型 自动判断 不确定自动根据右值判断
    register 把变量声明在寄存器中不能用&取地址符 取内存地址了
    static 普通的局部变量在函数调用完成后就会把内存中的变量删除,static 加上后 会一直存在到关闭程序(执行完main 函数)
    普通的局部变量在普通的函数调用结束后,就会从内存中删除,静态变量只会初始化一次,在程序声明周期中会一直存在.

  7. 运算符 算术运算符 + - * / ++ – 关系运算符 < > >= <= == 逻辑运算符 || & !

  8. 循环 for,while,do while || break 终止循坏(不在继续循环) continue 跳过当前循环(继续下次循环)

  1. 判断 if else ifelse 三目运算符 switch 及判断嵌套

  2. 函数 函数命名(第一个词是动词) 函数完整体 返回值类型 返回值 函数名 函数参数列表
    匿名函数可以写在函数体中,没有函数名,可以将匿名函数存储给一个变量
    -> int {return a + b; }; //匿名函数没有函数名

  3. 数学运算 cos sin tan log pow sqrt …

  4. 数组 二维数组 二位数组中行数可不写列数必须写 字符串数组 字符串的拼接

  5. 指针 NULL表示空指针 传递指针给函数(参数是指针) C++ 引用 vs 指针

  6. 单例类的创建 创建出来的类是实例化对象的复制品


可能想问吧

今天上午讲解的主要是上午的作业辅导及函数基础,并没有很难,暂时没有想问的!


一起练习吧

  1. 实现应用程序,主要是体现父类子类同的承关系。父关: 鸟 子类: 麻雀,鸵鸟,鹰。子类继承父类的一些特点,如都是鸟的话就都会有翅膀、两条腿等,但它们各自又有各自的特点,如麻雀的年龄、体重;鸵鸟的身高、奔跑速度;鹰的捕食、飞翔高度等。

  2. 将圆类作为基类,公有派生出圆柱体类和球类,分别实现圆类、圆柱体类和球类的完整定义其中:
    在圆柱体类中:
    增加数据成员 height,表示高
    定义无参构造函数,半径默认值为1,高度默认值为1
    定义带参的构造函数,按指定值创建圆柱;
    高度的设置函数和获取函数
    增加求表面积函数 getArea
    增加求体积函数 getVolume

    在球类中:
    定义一个有参构造函数,按指定值创建球
    增加求表面积函数 getArea
    增加求体积函数 getVolume
    编写测试主函数,创建一个圆柱体类对象和一个球类对象,分别输出其表面积和体积

  3. 改造以上代码在基类中写一个虛函数。子类中去实现。



上课代码笔记

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
// Week3_Class5.cpp: 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream> // 标准库的头文件用<> i表示input o表示out | 输入输出流
#include <string> // #预编译指令 编译器在编译下面代码之前插入进来
#include <array>
using namespace std;

typedef unsigned int uint;

// 低级语言速度较快
// C++ 中级语言
// 优点:
// 效率高 速度快 服务器开发
// VS 开发否则需要安装编译器 手动编译
// 难学?:面向对象 C语言所有功能
// 学习C++ “C++标准库参考”

/*
1. 语句块中声明的变量叫局部变量,只在块内有效。
(1)局部变量有形参,for循环内,语句块内的变量
(2)全局变量 在所有函数外部定义的变量
2. 关键字 变量名 类型名 各种名不能写关键字 关键字表需要看看
3. 注释: // 及 段落注释 还有 #if 0 .... #endif的方法
4. # 预编译指令 编译器在编译之前准备工作会执行的。编译器会把源码变异成二进制语言
5. 数据: 程序的本身就是在创建处理和编辑数据, 数据有数据类型 为什么有数据类型? 节约内存的目的:比如:高中就几天人使用short int即可只需要占用2个字节,如果使用int 就浪费了2个字节
// 数据类型 中unsigned 表示非负数
6. 强类型语言与弱类型语言
(1)强类型 C++,C# 任何一个数据必须有一个确定的数据类型 一般不允许随意转换,但可以强制类型转换
// 强制类型转换后 高精度转低精度会造成数据的丢失
(2)弱类型 变量数据类型不确定 根据赋值类型确定
7. typedef 定义个新类型 typedef int feet 给int类型起了个别名 size_t 其实就是 unsidned int
8. 枚举变量的声明
9. 32位系统 64位系统 一个字节=8位
10. 变量定义个和初始化
11. 左值和右值 // 10 “A” "Hello" 3.5 这些都是字变量都只能做右值 变量既可以放左边又可以放右边(左值可以放在右边 右值不能放在左边)
12. 不在任何函数内部声明的变量叫全局变量,一般写在程序头部,在函数内部,局部变量会覆盖全部变量
13. 没有初始化(全局变量)的情况下,系统自动初始化 int 0 char'\0' float 0 double 0 pointer NULL 局部变量必须手动初始化
14. 定义变量 int a = 1; 先声明变量在调用
15. 常量是固定值 不可修改 const int IntB = 100; 以后100不可更改,定义的时候可以更改以后不可修改
字符串字面量是常量不可修改 string str = "Hello"; str = "Helll",并没有改Hello是新的东西 以前指向“Hello”现在指向“Helll” str叫做字符串变量是可以更改的!!!
#dedine 预处理指定常量 或在函数里使用 const 定义
16. 修饰符 数据类型修饰符 类型限定符 普通变量会把变量放在寄存器中以加快速度 volatile(想得到地址(指针)并不需要得到他的cpu地址也得不到)
17. 储存类 auto类型 自动判断 不确定自动根据右值判断
register 把变量声明在寄存器中不能用&取地址符 取内存地址了
static 普通的局部变量在函数调用完成后就会把内存中的变量删除,static 加上后 会一直存在到关闭程序(执行完main 函数)
普通的局部变量在普通的函数调用结束后,就会从内存中删除,静态变量只会初始化一次,在程序声明周期中会一直存在.
18. 运算符 算术运算符 + - * / ++ -- 关系运算符 < > >= <= == 逻辑运算符 || & !
19. 循环 for,while,do while || break 终止循坏(不在继续循环) continue 跳过当前循环(继续下次循环)
20. 判断 if else ifelse 三目运算符 switch 及判断嵌套
21. 函数 函数命名(第一个词是动词) 函数完整体 返回值类型 返回值 函数名 函数参数列表
匿名函数可以写在函数体中,没有函数名,可以将匿名函数存储给一个变量
[](int a, int b) -> int {return a + b; }; //匿名函数没有函数名
22. 数学运算 cos sin tan log pow sqrt ...
23. 数组 二维数组 二位数组中行数可不写列数必须写 字符串数组 字符串的拼接
24. 指针 NULL表示空指针 传递指针给函数(参数是指针) C++ 引用 vs 指针
25. 单例类的创建 创建出来的类是实例化对象的复制品
*/

#define PI 3.141592654;

void func01() {
static int a = 10;
a--;
cout << "a: " << a << endl;
};
int Plus(int a,int b) {
return a + b;
}
class Water {
private:
float Capcaity = 0.f;
public:
Water operator<(const Water& Some) {
Water W; // 实例化了一个对象
W.Capcaity = this->Capcaity + Some.Capcaity;
return W; // 返回的W是上面那个对象的复制品(调用默认的复制构造函数)
}
};

int main()
{

#if 0
cout << "预编译符与注释" << endl << endl;
#endif
uint b = 3;
// 枚举变量的特殊写法
enum color {
Red = 0,
Green = 1,
Blue = 2
};
// 左值和右值 左值是指向内存位置的表达式(得到右值得内存地址) 右值是内存中的某些地址的数值
uint a = 10;
// 全局变量与局部变量
{
uint a = 20;
cout << a << endl << endl; // 就近原则?
}
// 定义常量 #define const
const int constValue = 5;

// 修饰符 volatile 告诉编译器不需要优化volatile声明的变量,让程序可以直接从内存中
// 读取变量。对于一般的变量编译器会对变量进行优化,将内存中的变量值放在寄存器中以加快读写效率。
// volatile float Fa = 3.14; // 什么时候什么情况会将它放到寄存器中?
// auto
array<int, 10> MyArray;
for (auto i : MyArray) {

};

//register 将变量存储在寄存器中 寄存器变量
//double MyDou = 1.5;
//register double MyDou02 = 2.5;
//cout << &MyDou02 << endl << endl; // 理论上不该有返回值的 为嘛有了?说好不能对寄存器变量取地址的呢?

// static 普通的局部变量在函数调用完成后就会把内存中的变量删除
// static 加上后 会一直存在到关闭程序(执行完main 函数)
// 循环及终止循环
/*
int i = 10;
while (i-- > 0) {
func01();
if (i == 5) {
break; //打断当前循环
}
}
*/
/*
for (int i = 0; i < 10; i++) {
if (i == 1) {
continue; // 跳过当前循环
}
cout << i << endl;
}
*/
// do while

// 函数传递注意传递顺序
/*
Plus(5, 6);
// 匿名函数
[](int a, int b) -> int {return a + b; }; //匿名函数没有函数名
auto Pluss = [](int a, int b) -> int {return a + b; }; // 把一个匿名函数复制给一个变量

Pluss(6, 10);
// 二维数组
int vector2Array[3][3] = { {1,2,3},{4,5,6},{7,8,9} };
for (int i= 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
cout << vector2Array[i][j] << endl;
}
}

for (int i = 0; i < 3; i++) {
cout << vector2Array[1][i] << endl; //打印4,5,6 // vector2Array[1]表示第二个子数组 i表示索引
}
*/


}




我的作业提交

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
// Week3_Class5_Homework.cpp: 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <string>
#include <math.h>
#include <iostream>

using namespace std;

double PI = 3.141592654;

enum EReproductiveMode {
Oviparity, // 卵生
Viviparity, // 胎生
Ovoviviparity // 卵胎生
};
enum EFoodTypes {
Herbivores, // 植食性动物
Carnivores, // 肉食性动物
Omnivores // 杂食性动物
};

enum EBirdLife {
SparrowObj,
OstrichObj,
Eagleobj

};

string EReproductiveModeArray[] = { "卵生","胎生","卵胎生" };
string EFoodTypesArray[] = { "植食性动物","肉食性动物","杂食性动物" };
int EBirdLifeArray[] = { 10,30,70 };
string EBirdName[] = { "麻雀","鸵鸟","鹰" };


class Bird {


protected:
int* Age;
int Life;
char* Name;
float Height;
float Weight;
float* Speed;
string TypesName;
float FlightAltitude;
EFoodTypes FoodTypes;
EReproductiveMode ReproductiveMode;
public:
friend Bird* CreateBirdObj(const char* NewName, int* NewAge, EBirdLife BirdType);

public:
int GetAge() {
return *Age;
}
float GetSpeed() {
return *Speed;
}
char* GetName() {
return Name;
}
string GetTypesName() {
return TypesName;
}
EFoodTypes GetFoodTypes() {
return FoodTypes;
}
EReproductiveMode GetReproductiveMode() {
return ReproductiveMode;
}

public:
Bird() {
Name = new char[2];
strcpy_s(Name, 2, "a");

Age = new int(0);
Speed = new float(0.0f);
cout << "Brid类无参函数被调用..." << endl << endl;
};

Bird(const char* NewName) {
int Length = strlen(NewName) + 1;
Name = new char[Length];
strcpy_s(Name, Length, NewName);
cout << "Brid类有1个参数函数被调用..." << endl << endl;
}

Bird(const char* NewName, EFoodTypes NewFoodTypes) :FoodTypes(NewFoodTypes) {
int Length = strlen(NewName) + 1;
Name = new char[Length];
strcpy_s(Name, Length, NewName);
// cout << "Brid类有2个参数函数被调用..." << endl << endl;
}

Bird(const char* NewName, int* NewAge) {
int Length = strlen(NewName) + 1;
Name = new char[Length];
strcpy_s(Name, Length, NewName);

Age = new int(*NewAge);
// cout << "Brid类有2个参数函数被调用..." << endl << endl;

}

Bird(const char* NewName, int* NewAge, float* NewSpeed) {
int Length = strlen(NewName) + 1;
Name = new char[Length];
strcpy_s(Name, Length, NewName);

Age = new int(*NewAge);
Speed = new float(*NewSpeed);
cout << "Brid类有3个参数函数被调用..." << endl << endl;

}

Bird(const char* NewName, int* NewAge, float NewWeight, float* NewSpeed) :Weight(NewWeight) {
int Length = strlen(NewName) + 1;
Age = new int(*NewAge);
Speed = new float(*NewSpeed);
cout << "Brid类有4个参数函数被调用..." << endl << endl;
}

Bird(const char* NewName, int* NewAge, float NewHeight, float NewWeight, float* NewSpeed, float NewFlightAltitude, EReproductiveMode NewReproductiveMode) :Height(NewHeight), Weight(NewWeight), FlightAltitude(NewFlightAltitude), ReproductiveMode(NewReproductiveMode) {
int Length = strlen(NewName) + 1;
Age = new int(*NewAge);
Speed = new float(*NewSpeed);
cout << "Brid类有7个参数函数被调用..." << endl << endl;
}

~Bird() {
if (Name) {
delete Name;
Name = 0;
}
if (Age) {
delete Age;
Age = 0;
}
if (Speed) {
delete Speed;
Speed = 0;
}
}

public:
virtual double GetLifeProcess() {
cout << "计算父类生命进程!" << endl << endl;
return *Age / double(Life) * 100;
}
};


class Sparrow :public Bird {
public:
Sparrow(const char* NewName, int* NewAge) :Bird(NewName, NewAge) {

// cout << "Sparrow 类有2个参数函数被调用..." << endl << endl;
}
public:
virtual double GetLifeProcess() {
cout << "计算麻雀生命进程!" << endl << endl;
return *Age / double(Life) * 100;
}

};

class Ostrich :public Bird {
public:
Ostrich(const char* NewName, int* NewAge) :Bird(NewName, NewAge) {

cout << "Ostrich 类有2个参数函数被调用..." << endl << endl;

}
public:
virtual double GetLifeProcess() {
cout << "计算鸵鸟生命进程!" << endl << endl;
return *Age / double(Life) * 100;
}

};

class Eagle :public Bird {
public:
Eagle(const char* NewName, int* NewAge) :Bird(NewName, NewAge) {
cout << "Eagle 类有2个参数函数被调用..." << endl << endl;
}

public:
virtual double GetLifeProcess() {
cout << "计算鹰生命进程!" << endl << endl;
return *Age / double(Life) * 100;
}

};

Bird* CreateBirdObj(const char* NewName, int* NewAge, EBirdLife BirdType) {
Bird* NewBird = nullptr;
switch (BirdType) {
case SparrowObj:
NewBird = new Sparrow(NewName, NewAge);
NewBird->Life = EBirdLifeArray[BirdType];
NewBird->TypesName = EBirdName[BirdType];
NewBird->FoodTypes = EFoodTypes::Omnivores;
NewBird->ReproductiveMode = EReproductiveMode::Oviparity;
break;
case OstrichObj:
NewBird = new Ostrich(NewName, NewAge);
NewBird->Life = EBirdLifeArray[BirdType];
NewBird->TypesName = EBirdName[BirdType];
NewBird->FoodTypes = EFoodTypes::Omnivores;
NewBird->ReproductiveMode = EReproductiveMode::Oviparity;
break;
case Eagleobj:
NewBird = new Eagle(NewName, NewAge);
NewBird->Life = EBirdLifeArray[BirdType];
NewBird->TypesName = EBirdName[BirdType];
NewBird->FoodTypes = EFoodTypes::Carnivores;
NewBird->ReproductiveMode = EReproductiveMode::Oviparity;
break;
}
return NewBird;
}


//=========================================================================================================================================================

class Circular {
public:
double Radius;
public:
Circular() {

}
Circular(double NewRaidus) {
Radius = NewRaidus;
}
public:
virtual double GetArea()
{
cout << "圆面积!" << endl << endl;
return pow(Radius, 2) * PI;
}
virtual double GetVolume() {
cout << "圆体积" << endl << endl;
return 0;
}
};

class Cylinder :public Circular {
public:
double Height;
public:
double GetHeight() {
return Height;
}
void SetHeight(double NewHeight) {
Height = NewHeight;
}
public:
Cylinder() {
Radius = 1;
Height = 1;
};
Cylinder(double NewRadius, double NewHeight) {
Radius = NewRadius;
Height = NewHeight;
}
public:
virtual double GetArea()
{
cout << "圆柱面积!" << endl << endl;
return 2 * pow(Radius, 2) * PI + 2 * PI * Radius * Height;
}
double GetVolume()
{
cout << "圆柱体积!" << endl << endl;
return Height * pow(Radius, 2) * PI;
}
};

class Sphere :public Circular {
public:
Sphere(double NewRadius) {
this->Radius = NewRadius;
// cout << "创建球体" << endl << endl;
}
public:
virtual double GetArea()
{
cout << "球体面积!" << endl << endl;
return 4 * pow(Radius, 2) * PI;
}

double GetVolume()
{
cout << "球体体积!" << endl << endl;

return (pow(Radius, 3) * PI) * 4 / double(3);
}
};


//==========================================================================================================================================================
int main()
{
cout << "第一题" << endl << endl;
const char* NameA = "麻雀一号";
const char* NameB = "麻雀二号";
int SparrowAAge = 3;
int SparrowBAge = 8;

Bird* SparrowA = CreateBirdObj(NameA, &SparrowAAge, EBirdLife::SparrowObj);
cout << "名字为: " << SparrowA->GetName() << " 是 " << SparrowA->GetAge() << " 岁了的 " << SparrowA->GetTypesName() << " 已经活了大概生命中的 " << SparrowA->GetLifeProcess() << " %!" << endl << endl;
cout << "名字为: " << SparrowA->GetName() << " 的 " << SparrowA->GetTypesName() << " 是 " << EReproductiveModeArray[SparrowA->GetReproductiveMode()] << EFoodTypesArray[SparrowA->GetFoodTypes()] << endl << endl;


Bird* SparrowB = CreateBirdObj(NameB, &SparrowBAge, EBirdLife::SparrowObj);
cout << "名字为: " << SparrowB->GetName() << " 是 " << SparrowB->GetAge() << " 岁了的 " << SparrowB->GetTypesName() << " 已经活了大概生命中的 " << SparrowB->GetLifeProcess() << " %!" << endl << endl;
cout << "名字为: " << SparrowB->GetName() << " 的 " << SparrowB->GetTypesName() << " 是 " << EReproductiveModeArray[SparrowB->GetReproductiveMode()] << EFoodTypesArray[SparrowB->GetFoodTypes()] << endl << endl;

int EagleAAge = 3;
const char* EagleAName = "老鹰一号";
Bird* EagleA = CreateBirdObj(EagleAName, &EagleAAge, EBirdLife::Eagleobj);
cout << "名字为: " << EagleA->GetName() << " 是 " << EagleA->GetAge() << " 岁了的 " << EagleA->GetTypesName() << " 已经活了大概生命中的 " << EagleA->GetLifeProcess() << " %!" << endl << endl;
cout << "名字为: " << EagleA->GetName() << " 的 " << EagleA->GetTypesName() << " 是 " << EReproductiveModeArray[EagleA->GetReproductiveMode()] << EFoodTypesArray[EagleA->GetFoodTypes()] << endl << endl;


cout << endl << endl;
cout << "第二题:" << endl << endl;
double NewRadius = 5;
double NewHeight = 2;


// 圆
Circular CircularA(NewRadius);
cout << "半径" << NewRadius << " 圆面积为: " << CircularA.GetArea() << endl << endl << endl << endl;

// 圆柱体
Circular* CylinderA = new Cylinder(NewRadius, NewHeight);
cout << "半径" << NewRadius << " 高度" << NewHeight << " 圆柱面积为: " << CylinderA->GetArea() << endl << endl;
cout << "半径" << NewRadius << " 高度" << NewHeight << " 圆柱面积为: " << CylinderA->GetVolume() << endl << endl << endl << endl;

// 球体
Sphere SphereA(NewRadius);
Circular* SphereB = new Sphere(NewRadius);
cout << "半径" << NewRadius << " 球体面积为: " << SphereB->GetArea() << endl << endl;
cout << "半径" << NewRadius << " 圆柱体积为: " << SphereA.GetVolume() << endl << endl;


return 0;
}


----------本文结束感谢您的阅读----------

本文标题:Unreal Engine 游戏开发学习笔记 20181109

文章作者:XIANVFX

发布时间:2018年11月09日 - 09:11

最后更新:2019年05月21日 - 09:05

原始链接:www.xianvfx.top/UE4/Training/Week3_CPP2/Unreal_Engine_Learning_Notes_W3_5.html

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。

(*❦ω❦) 感谢您的支持! (*❦ω❦)
0%