Unreal Engine 游戏开发学习笔记 20181030


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

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

今日内容摘要(知识点梳理):
1. 安装 Visual Studio 2017 并了解常用功能和了解 C++ 工程的创建及目录结构
2. C++ 基础 #include 头文件 源文件 数据类型 变量等相关知识
3. 变量 常量 前++ 后++ 算数运算符 判断(if) swith 三目元算符 转移字符 占位符


变量及常量

变量类型

变量其实只不过是程序可操作的存储区的名称。C++ 中每个变量都有指定的类型,类型决定了变量存储的大小和布局,该范围内的值都可以存储在内存中,运算符可应用于变量上。

变量的名称可以由字母、数字和下划线字符组成。它必须以字母或下划线开头。大写字母和小写字母是不同的,因为 C++ 是大小写敏感的。

 变量类型(图片来自菜鸟教程)
C++ 也允许定义各种其他类型的变量,比如枚举、指针、数组、引用、数据结构、类等等。

变量的定义

变量定义就是告诉编译器在何处创建变量的存储,以及如何创建变量的存储。变量定义指定一个数据类型,并包含了该类型的一个或多个变量的列表,如下所示:

1
type variable_list;

在这里,type 必须是一个有效的 C++ 数据类型,可以是 char、wchar_t、int、float、double、bool 或任何用户自定义的对象,variable_list 可以由一个或多个标识符名称组成,多个标识符之间用逗号分隔。变量可以在声明的时候被初始化(指定一个初始值)。初始化器由一个等号,后跟一个常量表达式组成,下面列出几个有效的声明:

1
2
3
4
extern int d = 3, f = 5;    // d 和 f 的声明 
int d = 3, f = 5; // 定义并初始化 d 和 f
byte z = 22; // 定义并初始化 z
char x = 'x'; // 变量 x 的值为 'x'

变量的类型转换

1
2
3
4
5
6
7
8
float Price = 5.5f;
// static_cast<int>(Price); 编译期间做的类型转换 静态转换 模板函数静态转换
cout << AppleNum * (int)Price << endl;
cout << ((float)AppleNum) * Price << endl; //int float double 强制类型换化(不强制的时候由编译器完成)
/*
只有类型相同的变量类型才能进行数学运算,如果编译器进行强制类型转换,
会将低精度的变量类型换为高精度,高精度转低精度可能有数据的损失。
*/

变量作用域

作用域是程序的一个区域,一般来说有三个地方可以定义变量:

  • 在函数或一个代码块内部声明的变量,称为局部变量。

  • 在函数参数的定义中声明的变量,称为形式参数。

  • 在所有函数外部声明的变量,称为全局变量。

函数和参数暂时没有学习,先看下局部变量和全局变量

局部变量

在函数或一个代码块内部声明的变量,称为局部变量。它们只能被函数内部或者代码块内部的语句使用。下面的实例使用了局部变量:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
using namespace std;
int main ()
{
// 局部变量声明
int a, b;
int c;
// 实际初始化
a = 10;
b = 20;
c = a + b;
cout << c;
return 0;
}

全局变量

在所有函数外部定义的变量(通常是在程序的头部),称为全局变量。全局变量的值在程序的整个生命周期内都是有效的。

全局变量可以被任何函数访问。也就是说,全局变量一旦声明,在整个程序中都是可用的。下面的实例使用了全局变量和局部变量:

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

// 全局变量声明
int g;

int main ()
{
// 局部变量声明
int a, b;
// 实际初始化
a = 10;
b = 20;
g = a + b;
cout << g;
return 0;
}

在程序中,局部变量和全局变量的名称可以相同,但是在函数内,局部变量的值会覆盖全局变量的值。下面是一个实例:

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
using namespace std;
// 全局变量声明
int g = 20;
int main ()
{
// 局部变量声明
int g = 10;
cout << g;
return 0;
}
// 当上面的代码被编译和执行时,它会产生下列结果:10

初始化局部变量和全局变量

当局部变量被定义时,系统不会对其初始化,您必须自行对其初始化。定义全局变量时,系统会自动初始化为下列值:
 全局变量初始化(图片来自菜鸟教程)

常量

常量是固定值,在程序执行期间不会改变。这些固定的值,又叫做字面量。
常量可以是任何的基本数据类型,可分为整型数字、浮点数字、字符、字符串和布尔值。
常量就像是常规的变量,只不过常量的值在定义后不能进行修改。

整数常量

整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数:0x 或 0X 表示十六进制,0 表示八进制,不带前缀则默认表示十进制。
整数常量也可以带一个后缀,后缀是 U 和 L 的组合,U 表示无符号整数(unsigned),L 表示长整数(long)。后缀可以是大写,也可以是小写,U 和 L 的顺序任意。

下面列举几个整数常量的实例:

1
2
3
4
5
212         // 合法的
215u // 合法的
0xFeeL // 合法的
078 // 非法的:8 不是八进制的数字
032UU // 非法的:不能重复后缀

以下是各种类型的整数常量的实例:

1
2
3
4
5
6
7
85         // 十进制
0213 // 八进制
0x4b // 十六进制
30 // 整数
30u // 无符号整数
30l // 长整数
30ul // 无符号长整数

浮点常量

浮点常量由整数部分、小数点、小数部分和指数部分组成。您可以使用小数形式或者指数形式来表示浮点常量。

当使用小数形式表示时,必须包含整数部分、小数部分,或同时包含两者。当使用指数形式表示时, 必须包含小数点、指数,或同时包含两者。带符号的指数是用 e 或 E 引入的。

下面列举几个浮点常量的实例:

1
2
3
4
5
3.14159       // 合法的 
314159E-5L // 合法的
510E // 非法的:不完整的指数
210f // 非法的:没有小数或指数
.e55 // 非法的:缺少整数或分数

布尔常量

布尔常量共有两个,它们都是标准的 C++ 关键字:

true 值代表真。
false 值代表假。
我们不应把 true 的值看成 1,把 false 的值看成 0

字符常量

字符常量是括在单引号中。如果常量以 L(仅当大写时)开头,则表示它是一个宽字符常量(例如 L’x’),此时它必须存储在 wchar_t 类型的变量中。否则,它就是一个窄字符常量(例如 ‘x’),此时它可以存储在 char 类型的简单变量中。

字符常量可以是一个普通的字符(例如 ‘x’)、一个转义序列(例如 ‘\t’),或一个通用的字符(例如 ‘\u02C0’)。

在 C++ 中,有一些特定的字符,当它们前面有反斜杠时,它们就具有特殊的含义,被用来表示如换行符(\n)或制表符(\t)等。下表列出了一些这样的转义序列码:

 转义字符(图片来自菜鸟教程)

下面的实例显示了一些转义序列字符:

1
2
3
4
5
6
7
8
9
10
11
#include <iostream>
using namespace std;

int main()
{
cout << "Hello\tWorld\n\n";
return 0;
}
// 当上面的代码被编译和执行时,它会产生下列结果:

// Hello World

字符串常量

字符串字面值或常量是括在双引号 “” 中的。一个字符串包含类似于字符常量的字符:普通的字符、转义序列和通用的字符。

您可以使用空格做分隔符,把一个很长的字符串常量进行分行。

下面的实例显示了一些字符串常量。下面这三种形式所显示的字符串是相同的。

1
2
3
4
5
6
7
"hello, dear"

"hello, \

dear"

"hello, " "d" "ear"

定义常量

在 C++ 中,有两种简单的定义常量的方式:

  • 使用 #define 预处理器。
  • 使用 const 关键字。
#define 预处理器

下面是使用 #define 预处理器定义常量的形式:

1
#define identifier value

具体请看下面的实例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <iostream>
using namespace std;
#define LENGTH 10
#define WIDTH 5
#define NEWLINE '\n'
int main()
{
int area;
area = LENGTH * WIDTH;
cout << area;
cout << NEWLINE;
return 0;

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

const 关键字

您可以使用 const 前缀声明指定类型的常量,如下所示:

1
const type variable = value;

具体请看下面的实例:

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

int main()
{
const int LENGTH = 10;
const int WIDTH = 5;
const char NEWLINE = '\n';
int area;

area = LENGTH * WIDTH;
cout << area;
cout << NEWLINE;
return 0;
}
// 当上面的代码被编译和执行时,它会产生下列结果:
// 50
** 请注意,把常量定义为大写字母形式,是一个很好的编程实践。**

修饰符类型

C++ 允许在 char、int 和 double 数据类型前放置修饰符。修饰符用于改变基本类型的含义,所以它更能满足各种情境的需求。

下面列出了数据类型修饰符:

  • signed
  • unsigned
  • long
  • short
    修饰符 signed、unsigned、long 和 short 可应用于整型,signed 和 unsigned 可应用于字符型,long 可应用于双精度型。

修饰符 signed 和 unsigned 也可以作为 long 或 short 修饰符的前缀。例如:unsigned long int。

C++ 允许使用速记符号来声明无符号短整数或无符号长整数。您可以不写 int,只写单词 unsigned、short 或 unsigned、long,int 是隐含的。例如,下面的两个语句都声明了无符号整型变量。

1
2
unsigned x;
unsigned int y;

了理解 C++ 解释有符号整数和无符号整数修饰符之间的差别,我们来运行一下下面这个短程序:

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

/*
* 这个程序演示了有符号整数和无符号整数之间的差别
*/
int main()
{
short int i; // 有符号短整数
short unsigned int j; // 无符号短整数

j = 50000;

i = j;
cout << i << " " << j;

return 0;
}
// 当上面的程序运行时,会输出下列结果:
// -15536 50000
// 上述结果中,无符号短整数 50,000 的位模式被解释为有符号短整数 -15,536。

C++ 中的类型限定符

类型限定符提供了变量的额外信息。
 类型限定符(图片来自菜鸟教程)

运算符

运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C++ 内置了丰富的运算符,并提供了以下类型的运算符:

  • 算术运算符
  • 关系运算符
  • 逻辑运算符
  • 位运算符
  • 赋值运算符
  • 杂项运算符
  • 本章将逐一介绍算术运算符、关系运算符、逻辑运算符、* 位运算符、赋值运算符和其他运算符。

算术运算符

假设变量 A 的值为 10,变量 B 的值为 20,则:
 算术运算符(图片来自菜鸟教程)

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

int main()
{
int a = 21;
int b = 10;
int c;

c = a + b;
cout << "Line 1 - c 的值是 " << c << endl ;
c = a - b;
cout << "Line 2 - c 的值是 " << c << endl ;
c = a * b;
cout << "Line 3 - c 的值是 " << c << endl ;
c = a / b;
cout << "Line 4 - c 的值是 " << c << endl ;
c = a % b;
cout << "Line 5 - c 的值是 " << c << endl ;

int d = 10; // 测试自增、自减
c = d++;
cout << "Line 6 - c 的值是 " << c << endl ;

d = 10; // 重新赋值
c = d--;
cout << "Line 7 - c 的值是 " << c << endl ;
return 0;
}

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

1
2
3
4
5
6
7
Line 1 - c 的值是 31
Line 2 - c 的值是 11
Line 3 - c 的值是 210
Line 4 - c 的值是 2
Line 5 - c 的值是 1
Line 6 - c 的值是 10
Line 7 - c 的值是 10

前++ 与 后++

前++为在运算以前先自增1 后++为在运算之后自增1

前++ 自增运算符,整数值增加 1
1
2
3
4
5
6
7
8
9
10
11
12
13
int PCNum = 11;
++PCNum; //前++ 运算符 也让变量自增1
cout << ++PCNum + 5 << endl; // 12 + 5
cout << ++PCNum + PCNum++ << endl; // 加法的答案
cout << PCNum << endl;

cout << ++PCNum + PCNum++ << endl; // 加法的答案
++PCNum算完后是12 现在PCNum是1212+12 = 24 下面还有一个后++的加没有加 又改变一次变量PCNum+1
cout << PCNum << endl;


int initial = 3;
cout << ++initial + initial++ + initial << endl; // 4 + 4 + 4
后++
1
2
3
4
5
6
7
8
9
10
11
int Age = 10; // 创建并初始化变量
Age = Age + 1; // 修改Age变量
Age += 1; // = 赋值符号 右边的数据给左边的变量
Age++; // ++ 为自增运算符 Age只加1
cout << Age << endl;

int BananaNum = 20;
BananaNum++;
cout << BananaNum << endl;
cout << BananaNum++ + AppleNum++ << endl; // 20 + 6
cout << AppleNum << endl; // 21

关系运算符

假设变量 A 的值为 10,变量 B 的值为 20,则:
 关系运算符(图片来自菜鸟教程)

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

int main()
{
int a = 21;
int b = 10;
int c ;

if( a == b )
{
cout << "Line 1 - a 等于 b" << endl ;
}
else
{
cout << "Line 1 - a 不等于 b" << endl ;
}
if ( a < b )
{
cout << "Line 2 - a 小于 b" << endl ;
}
else
{
cout << "Line 2 - a 不小于 b" << endl ;
}
if ( a > b )
{
cout << "Line 3 - a 大于 b" << endl ;
}
else
{
cout << "Line 3 - a 不大于 b" << endl ;
}
/* 改变 a 和 b 的值 */
a = 5;
b = 20;
if ( a <= b )
{
cout << "Line 4 - a 小于或等于 b" << endl ;
}
if ( b >= a )
{
cout << "Line 5 - b 大于或等于 a" << endl ;
}
return 0;
}

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

1
2
3
4
5
Line 1 - a 不等于 b
Line 2 - a 不小于 b
Line 3 - a 大于 b
Line 4 - a 小于或等于 b
Line 5 - b 大于或等于 a

逻辑运算符

假设变量 A 的值为 1,变量 B 的值为 0,则:

 逻辑运算符(图片来自菜鸟教程)

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

int main()
{
int a = 5;
int b = 20;
int c ;

if ( a && b )
{
cout << "Line 1 - 条件为真"<< endl ;
}
if ( a || b )
{
cout << "Line 2 - 条件为真"<< endl ;
}
/* 改变 a 和 b 的值 */
a = 0;
b = 10;
if ( a && b )
{
cout << "Line 3 - 条件为真"<< endl ;
}
else
{
cout << "Line 4 - 条件不为真"<< endl ;
}
if ( !(a && b) )
{
cout << "Line 5 - 条件为真"<< endl ;
}
return 0;
}

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

1
2
3
4
Line 1 - 条件为真
Line 2 - 条件为真
Line 4 - 条件不为真
Line 5 - 条件为真

赋值运算符

 赋值运算符(图片来自菜鸟教程)

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

int main()
{
int a = 21;
int c ;

c = a;
cout << "Line 1 - = 运算符实例,c 的值 = : " <<c<< endl ;

c += a;
cout << "Line 2 - += 运算符实例,c 的值 = : " <<c<< endl ;

c -= a;
cout << "Line 3 - -= 运算符实例,c 的值 = : " <<c<< endl ;

c *= a;
cout << "Line 4 - *= 运算符实例,c 的值 = : " <<c<< endl ;

c /= a;
cout << "Line 5 - /= 运算符实例,c 的值 = : " <<c<< endl ;

c = 200;
c %= a;
cout << "Line 6 - %= 运算符实例,c 的值 = : " <<c<< endl ;

c <<= 2;
cout << "Line 7 - <<= 运算符实例,c 的值 = : " <<c<< endl ;

c >>= 2;
cout << "Line 8 - >>= 运算符实例,c 的值 = : " <<c<< endl ;

c &= 2;
cout << "Line 9 - &= 运算符实例,c 的值 = : " <<c<< endl ;

c ^= 2;
cout << "Line 10 - ^= 运算符实例,c 的值 = : " <<c<< endl ;

c |= 2;
cout << "Line 11 - |= 运算符实例,c 的值 = : " <<c<< endl ;

return 0;
}

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

1
2
3
4
5
6
7
8
9
10
11
Line 1 - =  运算符实例,c 的值 = 21
Line 2 - += 运算符实例,c 的值 = 42
Line 3 - -= 运算符实例,c 的值 = 21
Line 4 - *= 运算符实例,c 的值 = 441
Line 5 - /= 运算符实例,c 的值 = 21
Line 6 - %= 运算符实例,c 的值 = 11
Line 7 - <<= 运算符实例,c 的值 = 44
Line 8 - >>= 运算符实例,c 的值 = 11
Line 9 - &= 运算符实例,c 的值 = 2
Line 10 - ^= 运算符实例,c 的值 = 0
Line 11 - |= 运算符实例,c 的值 = 2

运算符优先级

运算符的优先级确定表达式中项的组合。这会影响到一个表达式如何计算。某些运算符比其他运算符有更高的优先级,例如,乘除运算符具有比加减运算符更高的优先级。

例如 x = 7 + 3 2,在这里,x 被赋值为 13,而不是 20,因为运算符 具有比 + 更高的优先级,所以首先计算乘法 3 * 2,然后再加上 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
#include <iostream>
using namespace std;

int main()
{
int a = 20;
int b = 10;
int c = 15;
int d = 5;
int e;

e = (a + b) * c / d; // ( 30 * 15 ) / 5
cout << "(a + b) * c / d 的值是 " << e << endl ;

e = ((a + b) * c) / d; // (30 * 15 ) / 5
cout << "((a + b) * c) / d 的值是 " << e << endl ;

e = (a + b) * (c / d); // (30) * (15/5)
cout << "(a + b) * (c / d) 的值是 " << e << endl ;

e = a + (b * c) / d; // 20 + (150/5)
cout << "a + (b * c) / d 的值是 " << e << endl ;

return 0;
}

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

1
2
3
4
(a + b) * c / d 的值是 90
((a + b) * c) / d 的值是 90
(a + b) * (c / d) 的值是 90
a + (b * c) / d 的值是 50


条件判断及占位符

判断结构要求程序员指定一个或多个要评估或测试的条件,以及条件为真时要执行的语句(必需的)和条件为假时要执行的语句(可选的)。

下面是大多数编程语言中典型的判断结构的一般形式:
 判断结构(图片来自菜鸟教程)
判断语句分为:

  • if 语句
  • if…else…语句
  • 嵌套if语句
  • switch 语句
  • 嵌套switch语句

这里先说一下if语句的使用

if

得到用户输入的是否为字母

1
2
3
4
5
6
7
8
9
char Char_b = ' ';
cin >> Char_b;
// if (Char_b >= 65 && Char_b <= 90 || Char_b >= 97 && Char_b <= 122) {
if (Char_b >= 'a' && Char_b <= 'z' || Char_b >= 'A' && Char_b <= 'Z') {
cout << "输入的是字母" << endl;
}
else {
cout << "输入的不是字母" << endl;
}

判断一个数的个位是不是3 十位是不是2

1
2
3
4
5
6
7
8
9
10
11
int Int_b = 123;

if (Int_b % 12 == 3) {
cout << Int_b << "的各位是3" << endl;
}
cout << (Int_b % 12) << endl;

if ((Int_b / 10) % 10 == 2) {
cout << "yes" << endl;
cout << ((Int_b / 10) % 10) << endl;
}

下面还有两个例子练习if语句的用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
unsigned  int Week = 1;
cin >> Week;
if (Week == 1) {
cout << " 今天星期一! " << endl;
}
else if (Week == 2) {
cout << " 今天星期二! " << endl;
}
else if (Week == 3) {
cout << " 今天星期三! " << endl;
}
else if (Week == 4) {
cout << " 今天星期四! " << endl;
}
else if (Week == 5) {
cout << " 今天星期五! " << endl;
}
else if (Week == 6) {
cout << " 今天星期六! " << endl;
}
else if (Week == 7) {
cout << " 今天星期日! " << endl;
}
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
unsigned int Month = 1;
cout << "输出月份判断是不是下半年!" << endl;
// cin >> Month;
if (Month == 7) {
cout << "Yes" << endl;
}
else if (Month == 8) {
cout << "Yes" << endl;
}
else if (Month == 9) {
cout << "Yes" << endl;
}
else if (Month == 10) {
cout << "Yes" << endl;
}
else if (Month == 11) {
cout << "Yes" << endl;
}
else if (Month == 12) {
cout << "Yes" << endl;
}
else if(Month >12)
{
cout << "你输入的是其他星球的月份!" << endl;
}
else {
cout << "你输入的是上半年的月份!" << endl;
}

? : 运算符(条件运算符)

条件运算符,可以用来替代 if…else 语句。用条件运算符会让代码更加简洁,它的一般形式如下:

1
Exp1 ? Exp2 : Exp3;

其中,Exp1、Exp2 和 Exp3 是表达式。请注意,冒号的使用和位置。

? 表达式的值是由 Exp1 决定的。如果 Exp1 为真,则计算 Exp2 的值,结果即为整个 ? 表达式的值。如果 Exp1 为假,则计算 Exp3 的值,结果即为整个 ? 表达式的值。

1
2
3
int s = 5;
int h = 9;
cout << "s 和 h 较大的是: " << ((s > h) ? s : h) << endl; // 得到较大的数
1
2
3
4
5
6
7
if (s > h) {
//cout << "s 和 h 较大的是: " << s << endl;
}
else
{
//cout << "s 和 h 较大的是: " << h << endl;
}

C++ 格式占位符(格式描述符)

格式占位符(%)是在C/C++语言中格式输入函数,如scanf、printf等函数中使用。其意义就是起到格式占位的意思,表示在该位置有输入或者输出。

格式占位符说明:

  • %d表示其输出格式为十进制有符号整数。

  • %f表示其输出格式为浮点数。

  • %lf同%f,表示浮点数。但是它是用在输入函数scanf中的,而%f则是用在输出函数printf中的。

  • %c表示输出格式为字符。

  • %s表示其输出格式为字符串。

    1
    2
    3
    4
    5
    6
    7
    unsigned short Short_b = 1000;
    printf("\n%d\n", Short_b); // %d 占位符 给10进制的数字创建占位符。
    string MyString = "Good";
    printf("%s", MyString);
    float Flt_3 = 9.521254f;
    printf("%f", Flt_3);
    return 0;

可能想问吧

  1. 在整理笔记的时候发现 位运算符和一个杂项运算符没有讲到,在所有学习的例子中也没有涉及,所以暂时不整理,用到的时候在说,并在此处链接。

  2. 在判断中witch语句也没有讲到,今天主要练习的是if的几种写法和加入各种运算符做一个判断。


一起练习吧

  1. 打印下面图形:
    *
    **
    ***
  2. 从键盘输入两个实数a和b,输出a占b的百分之几。小数点后保留2位。
    例如:输入1和4,输出:25.00%
  3. 编写一个程序,要求用户输入一个美金数量, 然后显示出如何用最少的20美元、10美元、5美元和1美元来付款:
    Enter a dollar amout:93
    $20 bills: 4
    $10 bills: 1
    $5 bills:0
    $1 bills:3
  4. 用户输入一个字符,判断是否是大写字母,是输出“您输入一个大写字母”,不是,输出“…”
  5. 编写一个程序,要求用户从键盘输入2个float数,输出最大者.
  6. 判断用户输入的数字是偶数还是奇数。
  7. 输入一个成绩(0到100之间的整数),如果大于等于90输出:优秀;小于90而大于等于80输出:良好;小于80而大于等于70输出:一般;小于70而大于等于60输出:及格,否则输出:不及格.


上课代码笔记

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
// Week2_Day1_HomeWork.cpp: 定义控制台应用程序的入口点。
//

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

using namespace std;

#define GRAVITY 9.8 // 宏的定义 (别称 GRAVITY就是9.8,9.8也就是GRAVITY)

int class02()
{
// 变量:在程序运行中可以被修改的量,常亮:不能被修改
float Weight = 0.0f;
Weight = 10.f;

// cout << 6 + 7 << endl; //直接相加的数字叫做幻数 (过几天他认识你,你不是认识他)
// 1.声明常量
// (1). const
const double PI = 3.14;
const double g = 9.8;

int AppleNum = 6;
int ApplePrice = 7;
// cout << AppleNum * ApplePrice << endl; //幻数

// 宏
// 2. 类型转换 隐式类型转换(不写 编译器做的) 显示类型转换(手写 自己指定)
float Price = 5.5f;
// static_cast<int>(Price); 编译期间做的类型转换 静态转换 模板函数静态转换
// cout << AppleNum * (int)Price << endl;
// cout << ((float)AppleNum) * Price << endl; //int float double 强制类型换化(不强制的时候由编译器完成)
/*
只有类型相同的变量类型才能进行数学运算,如果编译器进行强制类型转换,
会将低精度的变量类型换为高精度,高精度转低精度可能有数据的损失。
*/

// 3. 数学运算 + - * / ++
int Mango = 10;
int MangoPrice = 4;
// cout << Mango * MangoPrice << endl;
// cout << Mango / MangoPrice << endl; //整数和整数相除为整除 答案为整数 小数被丢弃

float Flt_1 = 10.f, Flt_2 = 6.0f;
// cout << Flt_1 / Flt_2 << endl;

// cout << "int /:" << 100 / 30 << endl;
// cout << "float /:" << 100.f / 30.f << endl;

// 3.1 后++
int Age = 10; // 创建并初始化变量
// Age = Age + 1; // 修改Age变量
// Age += 1; // = 赋值符号 右边的数据给左边的变量
Age++; // ++ 为自增运算符 Age只加1
// cout << Age << endl;

int BananaNum = 20;
// BananaNum++;
// cout << BananaNum << endl;
// cout << BananaNum++ + AppleNum++ << endl; // 20 + 6
// cout << AppleNum << endl; // 21

// 3.2 前++
int PCNum = 11;
// ++PCNum; //前++ 运算符 也让变量自增1
// cout << ++PCNum + 5 << endl; // 12 + 5
// cout << ++PCNum + PCNum++ << endl; // 加法的答案
// cout << PCNum << endl;
/*
cout << ++PCNum + PCNum++ << endl; // 加法的答案
++PCNum算完后是12 现在PCNum是12了 12+12 = 24 下面还有一个后++的加没有加 又改变一次变量PCNum+1
cout << PCNum << endl;
*/

int initial = 3;
// cout << ++initial + initial++ + initial << endl; // 4 + 4 + 4

// 4. if
// 4.1 通过判断式来创建判断
int c = 1; //
if (c > 5) {
cout << "c变量大于5" << endl;
}

// 如果输入的时q字符,就输出输入的是q字符,如果不是就直接输出输入不是q字符。
char Char_a = 'a';
// cin >> Char_a;
if (Char_a == 'q') {
// 括号里面是if语句块
// cout << "Char_a 是 'q'字符" << endl;
}
else {
// cout << "Char_a 不是 'q'字符" << endl;
}

// 4.2 三目运算符 表达式1?表达式2:表达式3
// 三目运算符可以与if语句等价替换
int s = 5;
int h = 9;
//cout << "s 和 h 较大的是: " << ((s > h) ? s : h) << endl; // 得到较大的数
if (s > h) {
//cout << "s 和 h 较大的是: " << s << endl;
}
else
{
//cout << "s 和 h 较大的是: " << h << endl;
}

// 4.3 插入比较运算符的运算

int T = 10;
//cout << ((T++ > 9) ? T : 9) << endl; // 11 比较运算符完成后即执行++运算符 等价于下面的if判断方法

if (T++ > 9) { // 1. T>9 2.T++
//cout << T << endl;
}
else {
//cout << 9 << endl;
}

// 运算符分类 http://www.cnblogs.com/nuthings/p/9240720.html
// 运算符优先级 https://www.cnblogs.com/ywl925/p/3710246.html
// 比较运算符 > < >= <= == !=
// 算术运算符 + - * / ++ %
// 逻辑运算符 或 || 且 && 非 !

/*
char Char_b = ' ';
cin >> Char_b;
// if (Char_b >= 65 && Char_b <= 90 || Char_b >= 97 && Char_b <= 122) {
if (Char_b >= 'a' && Char_b <= 'z' || Char_b >= 'A' && Char_b <= 'Z') {
cout << "输入的是字母" << endl;
}
else {
cout << "输入的不是字母" << endl;
}
*/


int Int_b = 123;

// 得到个位是3
/*
if (Int_b % 12 == 3) {
cout << Int_b << "的各位是3" << endl;
}
cout << (Int_b % 12) << endl;
*/

/*
if ((Int_b / 10) % 10 == 2) {
cout << "yes" << endl;
cout << ((Int_b / 10) % 10) << endl;
}
*/

/*
Int_c = 17;
17/10
17%10
*/
/*
int Int_c = 137;
cout << (Int_c % 100 / 10) << endl;
cout << (Int_c / 10 % 10) << endl;

// int 整数 正数
int Inc_d = -100;
long Long_a = -1000000000L;
// 正整数 无符号
unsigned int Int_d = 1000; //
unsigned long Long_b = 1000000000UL;
unsigned short short_a = 111;
*/

// 5. if 语句的三种结构
/*
unsigned int Week = 1;
cin >> Week;
if (Week == 1) {
cout << " 今天星期一! " << endl;
}
else if (Week == 2) {
cout << " 今天星期二! " << endl;
}
else if (Week == 3) {
cout << " 今天星期三! " << endl;
}
else if (Week == 4) {
cout << " 今天星期四! " << endl;
}
else if (Week == 5) {
cout << " 今天星期五! " << endl;
}
else if (Week == 6) {
cout << " 今天星期六! " << endl;
}
else if (Week == 7) {
cout << " 今天星期日! " << endl;
}
*/

unsigned int Month = 1;
cout << "输出月份判断是不是下半年!" << endl;
// cin >> Month;
if (Month == 7) {
cout << "Yes" << endl;
}
else if (Month == 8) {
cout << "Yes" << endl;
}
else if (Month == 9) {
cout << "Yes" << endl;
}
else if (Month == 10) {
cout << "Yes" << endl;
}
else if (Month == 11) {
cout << "Yes" << endl;
}
else if (Month == 12) {
cout << "Yes" << endl;
}
else if(Month >12)
{
cout << "你输入的是其他星球的月份!" << endl;
}
else {
cout << "你输入的是上半年的月份!" << endl;
}

//转义字符的使用
// \ \n \a \t
printf("Hello World!\n"); //字符串 "hey" 'h' 'e' 'y' 转义字符
printf("\"Hello World\"\n");

//占位符
unsigned short Short_b = 1000;
printf("\n%d\n", Short_b); // %d 占位符 给10进制的数字创建占位符。
string MyString = "Good";
printf("%s", MyString);
float Flt_3 = 9.521254f;
return 0;
}




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

using namespace std;

int homework02()
{

//第一题:
cout << "第一题打印指定字符: " << endl;
for (int i = 1; i < 4; i++) {
for (int j = 0; j < i; j++) {
cout << '*';
}
printf("\n");
}


//第二题:
cout << endl;
cout << "第二题占比计算: " << endl << endl;
float FirstInputNum = 0.0f, SecondInputNum = 0.0f;
cout << "请输入第一个数:\n" << endl;
cin >> FirstInputNum;
cout << endl;
cout << "请输入第二个数:\n" << endl;
cin >> SecondInputNum;
cout << endl;
printf("%.4f %s %.4f %s %.2f%% \n\n", FirstInputNum, " 占 ", SecondInputNum," 的 ", FirstInputNum / SecondInputNum * 100);


//第三题:
cout << "第三题最小张数币值付款: " << endl << endl;
int InputDollar = 0;
cout << "请输入需付款金额: " << endl << endl;
cin >> InputDollar;
cout << endl;
int Complementation = 0;
cout << "$20 bills: " << (InputDollar / 20) << endl << endl;
Complementation = (InputDollar % 20);
cout << "$10 bills: " << (Complementation / 10) << endl << endl;
Complementation = (Complementation % 10);
cout << "$5 bills: " << (Complementation / 5) << endl << endl;
Complementation = (Complementation % 5);
cout << "$1 bills: " << (Complementation / 1) << endl << endl;
Complementation = (Complementation % 5);



//第四题:
cout << endl << "第四题判断输入字符是不是大写字母: " << endl << endl;
char Char_Input = ' ';
cout << "请输入一个字符: " << endl << endl;
cin >> Char_Input;
cout << endl;
(Char_Input <= 'Z' && Char_Input >= 'A') ? cout << "您输入了一个大写字符" << endl << endl : cout << "...\n" << endl;



//第五题:
cout << "第五题:判断输入两个浮点数的最大值:\n" << endl;
float User_Input_1 = 0.0f;
float User_Input_2 = 0.0f;
cout << "请输入第一个浮点数:\n" << endl;
cin >> User_Input_1;
cout << endl;
cout << "请输入第二个浮点数:\n" << endl;
cin >> User_Input_2;
cout << endl;
cout << User_Input_1 << " 与 " << User_Input_2 << " 比较 " << ((User_Input_1 > User_Input_2) ? User_Input_1 : User_Input_2) << " 较大 !\n" << endl;


//第六题:
int even = 0;
cout << "第六题:请输入数字,自动判断奇数还是偶数:\n" << endl;
cin >> even;
cout << endl;
even % 2 == 0 ? cout << even<<" 为偶数 !" << endl << endl : cout << even << " 为奇数 !" << endl << endl;


//第七题:
cout << "第七题:成绩判断:\n" << endl;
int score = 0;
cout << "请输入得分:\n" << endl;
cin >> score;
cout << endl;
if (score >= 0 && score<=100) {
cout << "输入分数为 " << score << ", 查询中 ... \n\n";
if (score >= 90) {
printf("优秀\n\n");
}
else if (score < 90 && score >= 80) {
printf("良好\n\n");
}
else if (score < 80 && score >= 70) {
printf("一般\n\n");
}
else if (score < 70 && score >= 60) {
printf("及格\n\n");
}
else {
printf("不及格\n");
}
}
else {
printf("满分100分!输入的成绩不在0-100范围内!\n\n");
}

return 0;
}


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

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

文章作者:XIANVFX

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

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

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

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

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