Unreal Engine 游戏开发学习笔记 20181031


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

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

今日内容摘要(知识点梳理):
1. enum 枚举 创建了一个枚举就是创建了一个新的数据类型
2. Array 数组 数组的长度 索引号
3. C语言中的string使用Char数组表示,数组必须使用’\0’。
4. if 分支语句
5. swith 分支语句 swith与枚举类型的结合使用
6. if 和 switch的关系
7. for 循环
8. while 循环
9. 数组与循环的结合使用


数组

数组

C++ 支持数组数据结构,它可以存储一个固定大小的相同类型元素的顺序集合。数组是用来存储一系列数据,但它往往被认为是一系列相同类型的变量。

数组的声明并不是声明一个个单独的变量,比如 number0、number1、…、number99,而是声明一个数组变量,比如 numbers,然后使用 numbers[0]、numbers[1]、…、numbers[99] 来代表一个个单独的变量。数组中的特定元素可以通过索引访问。

所有的数组都是由连续的内存位置组成。最低的地址对应第一个元素,最高的地址对应最后一个元素。

数组的声明

在 C++ 中要声明一个数组,需要指定元素的类型和元素的数量,如下所示:

1
type arrayName [ arraySize ];

这叫做一维数组。arraySize 必须是一个大于零的整数常量,type 可以是任意有效的 C++ 数据类型。例如,要声明一个类型为 double 的包含 10 个元素的数组 balance,声明语句如下:

1
double balance[10];

现在 balance 是一个可用的数组,可以容纳 10 个类型为 double 的数字。

初始化数组

在 C++ 中,您可以逐个初始化数组,也可以使用一个初始化语句,如下所示:

1
double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};

大括号 { } 之间的值的数目不能大于我们在数组声明时在方括号 [ ] 中指定的元素数目。

如果您省略掉了数组的大小,数组的大小则为初始化时元素的个数。因此,如果:

1
double balance[] = {1000.0, 2.0, 3.4, 7.0, 50.0};

您将创建一个数组,它与前一个实例中所创建的数组是完全相同的。下面是一个为数组中某个元素赋值的实例:

1
balance[4] = 50.0;

上述的语句把数组中第五个元素的值赋为 50.0。所有的数组都是以 0 作为它们第一个元素的索引,也被称为基索引,数组的最后一个索引是数组的总大小减去 1。以下是上面所讨论的数组的的图形表示:

 数组图形(图片来自菜鸟教程)

访问数组元素

数组元素可以通过数组名称加索引进行访问。元素的索引是放在方括号内,跟在数组名称的后边。例如:

1
double salary = balance[9];

上面的语句将把数组中第 10 个元素的值赋给 salary 变量。下面的实例使用了上述的三个概念,即,声明数组、数组赋值、访问数组:

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
#include <iostream>
using namespace std;

#include <iomanip>
using std::setw;

int main ()
{
int n[ 10 ]; // n 是一个包含 10 个整数的数组

// 初始化数组元素
for ( int i = 0; i < 10; i++ )
{
n[ i ] = i + 100; // 设置元素 i 为 i + 100
}
cout << "Element" << setw( 13 ) << "Value" << endl;

// 输出数组中每个元素的值
for ( int j = 0; j < 10; j++ )
{
cout << setw( 7 )<< j << setw( 13 ) << n[ j ] << endl;
}

return 0;
}

上面的程序使用了 setw() 函数来格式化输出。当上面的代码被编译和执行时,它会产生下列结果:

1
2
3
4
5
6
7
8
9
10
11
Element        Value
0 100
1 101
2 102
3 103
4 104
5 105
6 106
7 107
8 108
9 109

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 变量声明三要素: 变量类型 变量名 初始值
// 变量只能存储一个数据 比如long类型决定Number在内存中占用8字节

long Number = 10000L;
char A = 'A';
A = 'B';

// 数组:用来存储一组数据,数组的长度是固定的
long Numbers[5] = { 100,200,300,400,500 };
// 取得数组成员数据的访问:数组[索引号]
// cout << Numbers[4] << endl;
Numbers[4] = 600;
// cout << Numbers[4] << endl;
// 数组定义时候设置了长度[长度可不写],超出长度不行,不够长度会自动不全字符默认字符 '\0'
char Char_Array[3] = { 'A', 'B' };
// 数字可不写长度,但当没有初始值的时候必须定义长度,否则编译器不知如何预留内存。
char Char_Array_01[] = { 'H','e','l','l','o' };
// cout << "\n" << Char_Array_01[0] << Char_Array_01[1] << Char_Array_01[2] << Char_Array_01[3] << Char_Array_01[4] << "\n";
// char Char_Array_02[6];
// 字符串数组
string NameArray[] = { "张三","李四","王五" };
// cout << "\n" << NameArray[0] << "\n";
// cout << "\n" << size(NameArray) << "\n";
// 没有初始化的数组存储的也是垃圾值,啥都不写是空,空格的话也是一个字符

C中的字符串类型以char数组表示

1
2
3
4
string是C++的字符串,C中没有字符串,用char Array表示字符串。
char Char_Array_C[] = { 'H','e','l','l','o','\0'} '\0'必须加,表示C语言中 string 得的结尾;
char Char_Array_C[] = { 'H','e','l','l','o','\0' };
cout <<"C 语言中的string 为char数组 " <<Char_Array_C << endl;

switch 枚举 for循环

Switch

一个 switch 语句允许测试一个变量等于多个值时的情况。每个值称为一个 case,且被测试的变量会对每个 switch case 进行检查。

语法

1
2
3
4
5
6
7
8
9
10
11
12
switch(expression){
case constant-expression :
statement(s);
break; // 可选的
case constant-expression :
statement(s);
break; // 可选的

// 您可以有任意数量的 case 语句
default : // 可选的
statement(s);
}

switch 语句必须遵循下面的规则:

  • switch 语句中的 expression 必须是一个整型或枚举类型,或者是一个 class 类型,其中 class 有一个单一的转换函数将其转换为整型或枚举类型。
  • 在一个 switch 中可以有任意数量的 case 语句。每个 case 后跟一个要比较的值和一个冒号。
  • case 的 constant-expression 必须与 switch 中的变量具有相同的数据类型,且必须是一个常量或字面量。
  • 当被测试的变量等于 case 中的常量时,case 后跟的语句将被执行,直到遇到 break 语句为止。
  • 当遇到 break 语句时,switch 终止,控制流将跳转到 switch 语句后的下一行。
  • 不是每一个 case 都需要包含 break。如果 case 语句不包含 break,控制流将会 继续 后续的 case,直到遇到 break 为止。
  • 一个 switch 语句可以有一个可选的 default case,出现在 switch 的结尾。default case 可用于在上面所有 case 都不为真时执行一个任务。default case 中的 break 语句不是必需的。

 switch流程图(图片来自菜鸟教程)

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
#include <iostream>
using namespace std;

int main ()
{
// 局部变量声明
char grade = 'D';

switch(grade)
{
case 'A' :
cout << "很棒!" << endl;
break;
case 'B' :
case 'C' :
cout << "做得好" << endl;
break;
case 'D' :
cout << "您通过了" << endl;
break;
case 'F' :
cout << "最好再试一下" << endl;
break;
default :
cout << "无效的成绩" << endl;
}
cout << "您的成绩是 " << grade << endl;

return 0;
}

当上面的代码被编译和执行时,它会产生下列结果:

1
2
您通过了
您的成绩是 D

曾经用到的判断星期几的例子:

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
int Week = 0;
cin >> Week;
switch (Week)
{
case 1:
cout << "今天是周一!" << endl;
break;
case 2:
cout << "今天是周二!" << endl;
break;
case 3:
cout << "今天是周三!" << endl;
break;
case 4:
cout << "今天是周四!" << endl;
break;
case 5:
cout << "今天是周五!" << endl;
break;
case 6:
cout << "今天是周六!" << endl;
break;
case 7:
cout << "今天是周日!" << endl;
break;
default:
cout << "输入错误" << endl;
break;
}

枚举

枚举类型(enumeration)是 C++ 中的一种派生数据类型,它是由用户定义的若干枚举常量的集合。

定义格式:枚举类型的定义格式为:

1
enum <类型名> {<枚举常量表>};

格式说明

  • 关键字enum——指明其后的标识符是一个枚举类型的名字。
  • 枚举常量表——由枚举常量构成。”枚举常量”或称”枚举成员”,是以标识符形式表示的整型量,表示枚举类型的取值。枚举常量表列出枚举类型的所有取值,各枚举常量之间以”,”间隔,且必须各不相同。取值类型与条件表达式相同。
1
2
enum color_set1 {RED, BLUE, WHITE, BLACK}; // 定义枚举类型color_set1
enum week {Sun, Mon, Tue, Wed, Thu, Fri, Sat}; // 定义枚举类型week

重要提示

枚举常量代表该枚举类型的变量可能取的值,编译系统为每个枚举常量指定一个整数值,缺省状态下,这个整数就是所列举元素的序号,序号从0开始。 可以在定义枚举类型时为部分或全部枚举常量指定整数值,在指定值之前的枚举常量仍按缺省方式取值,而指定值之后的枚举常量按依次加1的原则取值。 各枚举常量的值可以重复。例如:

1
2
enum fruit_set {apple, orange, banana=1, peach, grape}
//枚举常量apple=0,orange=1, banana=1,peach=2,grape=3。

1
2
enum week {Sun=7, Mon=1, Tue, Wed, Thu, Fri, Sat};
//枚举常量Sun,Mon,Tue,Wed,Thu,Fri,Sat的值分别为7、1、2、3、4、5、6。

枚举常量只能以标识符形式表示,而不能是整型、字符型等文字常量。例如,以下定义非法:

1
2
enum letter_set {'a','d','F','s','T'}; //枚举常量不能是字符常量
enum year_set{2000,2001,2002,2003,2004,2005}; //枚举常量不能是整型常量

可改为以下形式则定义合法:

1
2
enum letter_set {a, d, F, s, T};
enum year_set{y2000, y2001, y2002, y2003, y2004, y2005};

枚举变量的使用

定义枚举类型的主要目的是:增加程序的可读性。枚举类型最常见也最有意义的用处之一就是用来描述状态量。

定义格式:定义枚举类型之后,就可以定义该枚举类型的变量,如:

1
color_set1 color1, color2;

亦可类型与变量同时定义(甚至类型名可省),格式如下:

1
enum {Sun,Mon,Tue,Wed,Thu,Fri,Sat} weekday1, weekday2;

枚举的相关操作

枚举变量的值只能取枚举常量表中所列的值,就是整型数的一个子集。

枚举变量占用内存的大小与整型数相同。

枚举变量只能参与赋值和关系运算以及输出操作,参与运算时用其本身的整数值。例如,设有定义:

1
2
enum color_set1 {RED, BLUE, WHITE, BLACK} color1, color2;
enum color_set2 { GREEN, RED, YELLOW, WHITE} color3, color4;

则允许的赋值操作如下:

1
2
3
4
color3=RED;           //将枚举常量值赋给枚举变量
color4=color3; //相同类型的枚举变量赋值,color4的值为RED
int i=color3; //将枚举变量赋给整型变量,i的值为1
int j=GREEN; //将枚举常量赋给整型变量,j的值为0

允许的关系运算有:==、<、>、<=、>=、!=等,例如:

1
2
3
4
//比较同类型枚举变量color3,color4是否相等
if (color3==color4) cout<<"相等"
//输出的是变量color3与WHITE的比较结果,结果为1
cout<< color3<WHITE;

枚举变量可以直接输出,输出的是变量的整数值。例如:

1
cout<< color3;         //输出的是color3的整数值,即RED的整数值1

其他枚举实例

1
2
3
4
5
6
7
enum Sex {
Female,
Male
};

Sex MySex = Sex::Male;
cout <<"我的性别:"<< MySex << endl; //输出的是1

例如:创建一个用于游戏环境中的枚举:

1
2
3
4
5
6
7
// Item指的是小物件
enum Item {
Weapon,
Coin,
Drug,
Bullet
};

枚举和switch的结合使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 枚举情况下 Swith中的Default可以被删除
Item MyItem = Item::Weapon;
switch (MyItem)
{
case Weapon:
break;
case Coin:
break;
case Drug:
break;
case Bullet:
break;
default:
break;
}

For 循环

有的时候,可能需要多次执行同一块代码。一般情况下,语句是顺序执行的:函数中的第一个语句先执行,接着是第二个语句,依此类推。

编程语言提供了允许更为复杂的执行路径的多种控制结构。

循环语句允许我们多次执行一个语句或语句组,下面是大多数编程语言中循环语句的一般形式:

 for循环(图片来自菜鸟教程)

For循环:多次执行一个语句序列,简化管理循环变量的代码。
for 循环允许您编写一个执行特定次数的循环的重复控制结构。

语法

C++ 中 for 循环的语法:

1
2
3
4
for ( init; condition; increment )
{
statement(s);
}

下面是 for 循环的控制流:

  • init 会首先被执行,且只会执行一次。这一步允许您声明并初始化任何循环控制变量。您也可以不在这里写任何语句,只要有一个分号出现即可。
  • 接下来,会判断 condition。如果为真,则执行循环主体。如果为假,则不执行循环主体,且控制流会跳转到紧接着 for 循环的下一条语句。
  • 在执行完 for 循环主体后,控制流会跳回上面的 increment 语句。该语句允许您更新循环控制变量。该语句可以留空,只要在条件后有一个分号出现即可。
  • 条件再次被判断。如果为真,则执行循环,这个过程会不断重复(循环主体,然后增加步值,再然后重新判断条件)。在条件变为假时,for 循环终止。
1
2
3
4
5
6
7
8
9
10
11
12
13
#include <iostream>
using namespace std;

int main ()
{
// for 循环执行
for( int a = 10; a < 20; a = a + 1 )
{
cout << "a 的值:" << a << endl;
}

return 0;
}

当上面的代码被编译和执行时,它会产生下列结果:

1
2
3
4
5
6
7
8
9
10
a 的值: 10
a 的值: 11
a 的值: 12
a 的值: 13
a 的值: 14
a 的值: 15
a 的值: 16
a 的值: 17
a 的值: 18
a 的值: 19

for 实例

打印100遍1
1
2
3
for (int i = 1; i<=100;i++) { //括号内含有三个元素 1.声明变量 2. 控制循环次数 3. 让i自增1
cout << "当前第 "<< i <<" 次循环 "<< "1" << endl;
}
打印100以内的偶数
1
2
3
4
5
6
for (int i = 1; i <= 100; i++)
{
if (i % 2 == 0) {
cout<<i<<endl;
}
}
打印100以内的的加法
1
2
3
4
5
6
int j = 0;
for (int i = 1; i <= 100; i++)
{
j = j + i;
cout << j-i << " + " << i << " = " << j << endl;
}

while

当给定条件为真时,重复语句或语句组。它会在执行循环主体之前测试条件。只要给定的条件为真,while 循环语句会重复执行一个目标语句。

语法

1
2
3
4
while(condition)
{
statement(s);
}

在这里,statement(s) 可以是一个单独的语句,也可以是几个语句组成的代码块。condition 可以是任意的表达式,当为任意非零值时都为真。当条件为真时执行循环。

当条件为假时,程序流将继续执行紧接着循环的下一条语句。
 while循环(图片来自菜鸟教程)
在这里,while 循环的关键点是循环可能一次都不会执行。当条件被测试且结果为假时,会跳过循环主体,直接执行紧接着 while 循环的下一条语句。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <iostream>
using namespace std;

int main ()
{
// 局部变量声明
int a = 10;

// while 循环执行
while( a < 20 )
{
cout << "a 的值:" << a << endl;
a++;
}

return 0;
}

当上面的代码被编译和执行时,它会产生下列结果:

1
2
3
4
5
6
7
8
9
10
a 的值: 10
a 的值: 11
a 的值: 12
a 的值: 13
a 的值: 14
a 的值: 15
a 的值: 16
a 的值: 17
a 的值: 18
a 的值: 19

while 实例

打印100遍 1
1
2
3
4
5
6
int j = 1;
while (j<=100)
{
cout << "j: " << j << endl;
j++;
}
打印100以内的偶数
1
2
3
4
5
6
7
8
int j = 1;
while (j <= 100)
{
if (j % 2 != 0) {
cout << j << endl;
}
j++;
}

可能想问吧

暂时没有,或这当时有忘记了,如果朋友们有,可以在留言区留言哈


一起练习吧

  1. 编程将所有“水仙花数”打印出来,并打印其总个数。 “水仙花数”是一个 各个位立方之和等于该整数的三位数。
  2. 找出下列整型数组中最大和最小值及其所在位置i。
    int[] a={3,5,8,13,47,9};
    int[] b ={-23,45,14,65};
  3. 给定某年某月某日,输出其为这一年的第几天。
  4. 已知abc+cba = 1333,其中a,b,c均为一位数,编程求出满足条件的a,b,c所有组合。
  5. 分别用while、for循环打印1~100之间3的倍数
  6. 用while和for循环打印出1-100之间7的倍数,个位为7的数,十位为7的倍数,不是7的倍数并且不包含7。


上课代码笔记
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
#include "stdafx.h"
#include "targetver.h"
#include <string>
#include <iostream>

using namespace std;


int class3()
{
// 变量声明三要素: 变量类型 变量名 初始值
// 变量只能存储一个数据 比如long类型决定Number在内存中占用8字节

long Number = 10000L;
char A = 'A';
A = 'B';

// 数组:用来存储一组数据,数组的长度是固定的
long Numbers[5] = { 100,200,300,400,500 };
// 取得数组成员数据的访问:数组[索引号]
// cout << Numbers[4] << endl;
Numbers[4] = 600;
// cout << Numbers[4] << endl;
// 数组定义时候设置了长度[长度可不写],超出长度不行,不够长度会自动不全字符默认字符 '\0'
char Char_Array[3] = { 'A', 'B' };
// 数字可不写长度,但当没有初始值的时候必须定义长度,否则编译器不知如何预留内存。
char Char_Array_01[] = { 'H','e','l','l','o' };
// cout << "\n" << Char_Array_01[0] << Char_Array_01[1] << Char_Array_01[2] << Char_Array_01[3] << Char_Array_01[4] << "\n";
// char Char_Array_02[6];
// 字符串数组
string NameArray[] = { "张三","李四","王五" };
// cout << "\n" << NameArray[0] << "\n";
// cout << "\n" << size(NameArray) << "\n";
// 没有初始化的数组存储的也是垃圾值,啥都不写是空,空格的话也是一个字符
/*
string是C++的字符串,C中没有字符串,用char Array表示字符串。
char Char_Array_C[] = { 'H','e','l','l','o','\0'} '\0'必须加,表示C语言中 string 得的结尾;
char Char_Array_C[] = { 'H','e','l','l','o','\0' };
cout <<"C 语言中的string 为char数组 " <<Char_Array_C << endl;
*/
string StringArray[] = { "" };
/*
int Week = 0;
cin >> Week;
switch (Week)
{
case 1:
cout << "今天是周一!" << endl;
break;
case 2:
cout << "今天是周二!" << endl;
break;
case 3:
cout << "今天是周三!" << endl;
break;
case 4:
cout << "今天是周四!" << endl;
break;
case 5:
cout << "今天是周五!" << endl;
break;
case 6:
cout << "今天是周六!" << endl;
break;
case 7:
cout << "今天是周日!" << endl;
break;
default:
cout << "输入错误" << endl;
break;
}
*/


/*
string StringName = "";
cin >> StringName;
switch (StringName)
{
case "li":
cout << "li" << endl;
break; // 跳出
default:
break;
}
*/

// 定义枚举就是创造了一个新的数据类型
enum Sex {
Female,
Male
};

Sex MySex = Sex::Male;
cout <<"我的性别:"<< MySex << endl;


// Item指的是小物件
enum Item {
Weapon,
Coin,
Drug,
Bullet
};
// 枚举情况下 Swith中的Default可以被删除
Item MyItem = Item::Weapon;
switch (MyItem)
{
case Weapon:
break;
case Coin:
break;
case Drug:
break;
case Bullet:
break;
default:
break;
}

// 分支语句: if...else... swith...case...
// if后可以是判断 swith后面接固定
// 所有的swith语句都可以转成if语句

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

// 循环
// for 打印1001
/*
for (int i = 1; i<=100;i++) { //括号内含有三个元素 1.声明变量 2. 控制循环次数 3. 让i自增1
cout << "当前第 "<< i <<" 次循环 "<< "1" << endl;
}
*/
/*
for (int i = 1; i <= 100; i++)
{
if (i % 2 == 0) {
cout<<i<<endl;
}
}
*/
/*
int j = 0;
for (int i = 1; i <= 100; i++)
{
j = j + i;
cout << j-i << " + " << i << " = " << j << endl;
}
*/
/*
unsigned long long j = 1;
for (unsigned long long i = 1; i <= 100; i++)
{
j = j * i;
cout << j / i << " * " << i << " = " << j << endl;
}
*/

//while 循环

/*
int j = 1;
while (j<=100)
{
cout << "j: " << j << endl;
j++;
}
*/
/*
int j = 1;
while (j <= 100)
{
if (j % 2 != 0) {
cout << j << endl;
}
j++;
}
*/
// forwhile 循环的差异不大,只是将定义并初始化变量写在了while前,将自增放在了作用域内。
/*
int Scores[10] = { 11,22,33,44,55,66,77,88,99,100 };
// cout << sizeof(Scores)/sizeof(Scores[0])<<endl;
int SumArray = 0;
for (int i = 0; i < 10; i++) {
SumArray += Scores[i];
cout << SumArray << endl;
}
*/
/*
int Scores[10] = { 11,22,33,44,55,66,77,88,99,100 };
// 数组的最后一个元素的下标=数组的长度-1
int OtherArray[10] = {0};
for (int i = 0; i < 10; i++) {
OtherArray[i] = Scores[i];
}
cout << OtherArray << endl;
*/


int Scores[10] = { 11,22,33,44,55,66,77,88,99,100 };
// 数组的最后一个元素的下标=数组的长度-1
// sizeof 计算占用内存空间的大小
const int lengScores = sizeof(Scores) / sizeof(Scores[0]); //变量转常量
//int OtherArray[size(Scores)] = { 0 };
int OtherArray[lengScores] = { 0 };
for (int i = 0; i < lengScores-1; i++) {
OtherArray[i] = Scores[i];
}
cout << OtherArray << endl;


return 0;

}

void zhishidian()
{
printf("hello");
// 1. enum 枚举 创建了一个枚举就是创建了一个新的数据类型
// 2. Array 数组 数组的长度 索引号
// 3. C语言中的string使用Char数组表示,数组必须使用'\0'。
// 4. if 分支语句
// 5. swith 分支语句 swith与枚举类型的结合使用
// 6. if 和 switch的关系
// 7. for 循环
// 8. while 循环
// 9. 数组与循环的结合使用

// 明天讲for循环的嵌套
// 行列式 二维数组
// 冒号排序(for循环的嵌套应用)
}




我的作业提交
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
// Week2 Day03 Homework
#include "stdafx.h"
#include <string>
#include <iostream>
#include <algorithm>

using namespace std;

int main()
{

//第一题:编程将所有“水仙花数”打印出来,并打印其总个数。水仙花数是指一个 3 位数,它的每个位上的数字的 3次幂之和等于它本身(例如:1^3 + 5^3+ 3^3 = 153)
cout << "第一题:水仙花数: \n\n";
int TotalNarcissisticNumber = 0;
for (int e = 100; e < 1000; e++) {
int OnesPlace = e % 100 % 10;
int TensPlace = e % 100 / 10;
int HundredsPlace = e / 100;
if (HundredsPlace* HundredsPlace*HundredsPlace + TensPlace* TensPlace*TensPlace + OnesPlace * OnesPlace*OnesPlace == e) {
cout << e << "\n" << endl;
TotalNarcissisticNumber++;
}
}
printf("%s %d %s\n","水仙花数一共",TotalNarcissisticNumber,"个!\n");
cout << endl;

//第二题:找出下列整型数组中最大和最小值及其所在位置i
int a[] = { 3,5,8,13,47,9 };
int b[] = { -23,45,14,65 };
//数组a
int AArrayMin = a[0], AArrayMax = a[0];
int AArrayMinIndex = 0, AArrayMaxIndex = 0;
for (int i = 1; i < sizeof(a) / sizeof(a[0]); i++) {
if (a[i] < AArrayMin){
AArrayMin = a[i];
AArrayMinIndex = i;
}
if (a[i] > AArrayMax) {
AArrayMax = a[i];
AArrayMaxIndex = i;
}

}
printf("%s %d %s %d\n\n", "数组a中最小值: ", AArrayMin, " 索引号: ", AArrayMinIndex);
printf("%s %d %s %d\n\n", "数组a中最大值: ", AArrayMax, " 索引号: ", AArrayMaxIndex);
// 数组a
int BArrayMin = b[0], BArrayMax = b[0];
int BArrayMinIndex = 0, BArrayMaxIndex = 0;
for (int i = 1; i < sizeof(b) / sizeof(b[0]); i++) {
if (b[i] < BArrayMin) {
BArrayMin = b[i];
BArrayMinIndex = i;
}
if (b[i] > BArrayMax) {
BArrayMax = b[i];
BArrayMaxIndex = i;
}

}
printf("%s %d %s %d\n\n", "数组b中最小值: ", BArrayMin, " 索引号: ", BArrayMinIndex);
printf("%s %d %s %d\n\n", "数组b中最大值: ", BArrayMax, " 索引号: ", BArrayMaxIndex);


//第四题:已知abc+cba = 1333,其中a,b,c均为一位数,编程求出满足条件的a,b,c所有组合
cout << "第四题:已知abc+cba = 1333,其中a,b,c均为一位数,编程求出满足条件的a,b,c所有组合 " << endl<<endl;
for (int f = 0; f < 10; f++) {
for (int j = 0; j < 10; j++) {
for (int k = 0; k < 10; k++) {
if (100 * f + 10 * j + k + 100 * k + 10 * j + f == 1333) {
printf("a = %d b = %d c = %d\n", f, j, k);
}
}
}
}
cout << endl;

// 第六题:分别用while、for循环打印1~100之间3的倍数
cout << "第六题:While 打印 1 - 100之间 3 的倍数有: \n\n";
int WhilesLoop_6 = 1;
while (WhilesLoop_6 <= 100) {
if (WhilesLoop_6 % 3 == 0) {
cout << "1-100中3的倍数: " << WhilesLoop_6 << "\n" << endl;
}
WhilesLoop_6++;
}
cout << endl;
cout << "For 打印 1 - 100之间 3 的倍数有: \n\n";
int ForLoop_6 = 1;
for (ForLoop_6; ForLoop_6 <= 100; ForLoop_6++) {
if (ForLoop_6 % 3 == 0) {
cout << "1-100中3的倍数: " << ForLoop_6 <<"\n"<< endl;
}
}
cout << endl;


// 第七题:用while和for循环打印出1-100之间7的倍数,个位为7的数,十位为7的倍数,不是7的倍数并且不包含7
// for And While 打印7的被倍数
cout << "第七题:用while和for循环打印出1-100之间7的倍数,个位为7的数,十位为7的倍数,不是7的倍数并且不包含7 \n\n";
cout << "While 打印 1 - 100之间 7 的倍数有: \n\n";
int WhilesLoop_7 = 1;
while (WhilesLoop_7 <= 100) {
if (WhilesLoop_7 % 7 == 0) {
cout << "1-100中7的倍数: " << WhilesLoop_7 << "\n" << endl;
}
WhilesLoop_7++;
}
cout << endl;
cout << "For 打印 1 - 100之间 3 的倍数有: \n\n";
int ForLoop_7 = 1;
for (ForLoop_7; ForLoop_7 <= 100; ForLoop_7++) {
if (ForLoop_7 % 7 == 0) {
cout << "1-100中3的倍数: " << ForLoop_7 << "\n" << endl;
}
}
cout<<endl;


//For 和 while 打印各位数含有7的数
cout << "For 打印 1 - 100之间 个数为7 的数有: \n\n";
for (int i = 0; i <= 100; i++) {
if (i % 10 == 7) {
cout << i << endl;
}
}
cout << endl;

cout << "While 打印 1 - 100之间 个数为7 的数有: \n\n";
int j = 0;
while (j <= 100) {
if (j % 10 == 7) {
cout << j << endl;
}
j++;
}
cout << endl;


//For 和 while 打印十位数含有7的数
cout << "For 打印 1 - 100之间 十数为7 的数有: \n\n";
for (int k = 0; k <= 100; k++) {
if (k / 10 == 7) {
cout << k << endl;
}
}
cout << endl;
cout << "While 打印 1 - 100之间 十数为7 的数有: \n\n";
int l = 0;
while (l <= 100) {
if (l / 10 == 7) {
cout << l << endl;
}
l++;
}
cout << endl;


//For 和 while 打印不是7的倍数并且不包含7的数
cout << "For 打印 1 - 100之间不是7的倍数并且不包含7的数: \n\n";
for (int m = 0; m <= 100; m++) {
if (m / 10 != 7 && m % 10 != 7 && m % 7 !=0) {
cout << m << endl;
}
}
cout << endl;
cout << "while 打印 1 - 100之间不是7的倍数并且不包含7的数: \n\n";
int n = 0;
while (n <= 100) {
if (n / 10 != 7 && n % 10 != 7 && n % 7 != 0) {
cout << n << endl;
}
n++;
}

return 0;
}


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

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

文章作者:XIANVFX

发布时间:2018年10月31日 - 09:10

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

原始链接:www.xianvfx.top/UE4/Training/Week2_CPP1/Unreal_Engine_Learning_Notes_W2_3.html

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

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