# UE4 UFUNCTION常用的的元信息宏

参考原文： [UE4-常见的宏-UFUNCTION](https://blog.csdn.net/wmy19890322/article/details/125598935)

## BlueprintCallable

该函数可以在蓝图或关卡蓝图图表中执行

```cpp
public: 
    UFUNCTION(BlueprintCallable, Category = "Snowing,BlueprintFunc")
    void BlueprintCallableFunction();
```


![img](https://img-blog.csdnimg.cn/2a1f39348030481e8c035558b1593c05.png)




## BlueprintImplementableEvent

此函数可以在蓝图或关卡蓝图图表内进行重载
不能修饰private级别的函数，函数在C++代码中不需要实现定义

```cpp
public:
    UFUNCTION(BlueprintImplementableEvent, meta = (DisplayName = "Blueprint Implementable Event Function"), Category = "Snowing|BlueprintFunc")
    float BlueprintImplementableEventFunction(float In_Float);
```

![img](https://img-blog.csdnimg.cn/cefc8fce87604a75b53de269e6fff3fa.png)

## Category

Category = TopCategory|SubCategory|Etc

指定函数在编辑器中的显示分类层级，`|` 是分层级的符号

```cpp
UFUNCTION(BlueprintPure, Category = "Snowing|BlueprintFunc")
AActor* BlueprintPureFunction();
```

![img](https://img-blog.csdnimg.cn/98a3c91a8c134549949336619530a50f.png)

## 元数据说明符

用法：UFUNCTION( [函数说明符], meta = (元数据说明符) )

### CommutativeAssociativeBinaryOperator=”true”

指示BlueprintCallable函数应该使用“Commutative Associative Binary”节点。该节点缺少引脚名称，但具有创建附加输入引脚的“Add Pin”按钮

```cpp
//.h文件函数声明
UFUNCTION(BlueprintPure, meta = (DisplayName = "Add Pin Function", CommutativeAssociativeBinaryOperator = "true"), Category = "Snowing|Parameters")
    float CommutativeAssociativeBinaryOperatorFunction(const float A, const float B);
 
//.cpp文件行数定义
float AActorTest::CommutativeAssociativeBinaryOperatorFunction(const float A, const float B)
{
    float Result{0.f};
    Result += A;
    Result += B;
 
    return Result;
}
```

![img](https://img-blog.csdnimg.cn/87750f73d75b4ccb943b11e91c69871c.png)



### CompactNodeTitle=”Name”

指示BlueprintCallable函数应在紧凑显示模式下显示，并提供在该模式下显示的名称 

```cpp
UFUNCTION(BlueprintCallable, meta = (AutoCreateRefTerm = "In_Int32", CompactNodeTitle = "CompactNodeTitleFunction"), Category = "Snowing|Parameters")
    int32 AutoCreateRefTermFunction(UPARAM(Ref) int32& In_Int32);
```

![img](https://img-blog.csdnimg.cn/4e4d06c26b1f48ae8f7c5600f17a74e5.png)



### DisplayName=”Blueprint Node Name”

蓝图中此节点的名称将替换为此处提供的值，而不是代码生成的名称（在蓝图中搜索被修饰函数也用这里提供的值）

### HidePin=”Parameter”

对于BlueprintCallable函数，这表示参数引脚应该隐藏在用户的视图中。请注意，每个功能只能有一个参数引脚以这种方式隐藏 

```cpp
UFUNCTION(BlueprintCallable, meta = (HidePin = "In_Float"), Category = "Snowing|Parameters")
    void HidePinFunction(int In_Int, float In_Float, FString In_FString, TArray<AActor*> In_TArray);
```

![img](https://img-blog.csdnimg.cn/65d3e60dba0c43ea98a8d308057db4db.png)

UE4 UFUNCTION常用的元信息宏

# 自定义随机数

```cpp
class rand_generator {
public:
    rand_generator(int seed = 0)
        : seed_{ seed } {}

    operator int() {
        seed_ = (seed_ * 214013 + 2531011) & 0x7fffffff;
        return seed_;
    }
private:
    int seed_{};
};
```

伪随机数的一种实现

# 零碎知识小记



## virtual

### 虚析构

对**父指针指向的子对象**执行**delete**，析构的时候，子对象的析构函数不会执行

```cpp
class A
{
public:
	~A(){
		std::cout << __func__ << std::endl;
	}
};

class B : public A
{
public:
	~B(){
		std::cout << __func__ << std::endl;
	}
};

A* b = new B;
delete b; // output '~A'
{
	B c;
} // output '~B ~A'
```

### 构造函数调用虚函数

基类可以调用虚函数，但调用的是基类的虚函数。***子类还没有构造，不会触发多态***。

```cpp
class A
{
public:
	A()
	{
		echo(); // A
	}

	virtual void echo()
	{
		std::cout << "A" << std::endl;
	}
};

class B : public A
{
public:
	virtual void echo()
	{
		std::cout << "B" << std::endl;
	}
};

B b; // output 'A'
```

### 虚表

- ***虚指针***（vptr）： 每个含有虚函数的对象里都有虚表指针，指向**虚表**
- ***虚函数表***（vtable）： 顺序存放虚函数地址
- 虚指针存在于对象实例的最前面的位置，可以在**多层继承**或**多重继承**时来保证最高性能
- 虚函数表属于***类***，类的所有对象通过指向虚函数表的虚指针vptr来共享虚函数表
- 虚函数表vtable放在可执行文件的***只读数据字段.rodata***中
- 重写虚函数时，子类的函数会替换虚表中对应的函数

编译器会为每一个含有虚函数的类创建一个虚表，该虚表将被所有该类的所有对象共享，里面存储的是该类的虚函数的地址。虚表的大小是N*4（N个虚函数，一个虚函数占一行，最后以0结尾）。虚函数的实现就是通过虚表来实现的。之前讲到只有虚函数才能被覆盖，就是指的是虚表中虚函数地址被覆盖。
在有虚函数的类实例化时，编译器分配了指向该表的指针的内存（虚函数表指针vptr），简单一点就是便一起给每个对象添加了一个隐藏成员，这个隐藏成员中保存了一个指向虚函数表的指针。这意味着可以通过类实例化的地址得到虚表，然后遍历其中的函数指针，并调用相应的函数。

1,基类对象含有一个指针，该指针指向基类中所有虚函数的地址表。派生类对象将含有一个指向独立地址表的指针。
2,如果派生类提供了基类虚函数的重定义，该虚函数表将保存新函数的地址。即就是虚函数覆盖实际是对虚函数表中的虚函数的地址的覆盖。
3,如果派生类定义了新的虚函数，则该函数的地址将被加入到虚函数表中。注意，无论类中是一个还是多个虚函数，都只需在对象中添加一个地址成员，只是表的大小不同。

## RAII

### 含义

- 在构造函数中申请分配资源，在析构函数中释放资源。
- **利用类来管理资源，将资源与类对象的生命周期绑定**

### 应用

- **在资源管理方面**，智能指针(`std::shared_ptr`和`std::unique_ptr`)是`RAII`最具代表性的实现，使用了智能指针，可以实现自动的内存管理，再也不用担心忘记`delete`造成内存泄漏了。
- **在状态管理方面**，线程同步中使用`std::unique_lock`或`std::lock_guard`对互斥量`std::mutex`进行状态管理也是`RAII`的典型实现，通过这种方式，我们再也不用担心互斥量之间的代码出现异常而造成线程死锁。

## 重载 隐藏 重写（覆盖）

| 三者 | 作用域 | 有无virtual | 函数名 | 形参列表   | 返回值类型   |
| :--- | :----- | :---------- | :----- | :--------- | :----------- |
| 重载 | 相同   | 可有可无    | 相同   | 不同       | 可同可不同   |
| 隐藏 | 不同   | 可有可无    | 相同   | 可同可不同 | 可同可不同   |
| 重写 | 不同   | 有          | 相同   | 相同       | 相同（协变） |

## 互斥量**mutex**

### 非定时的互斥体类

- std::mutex 已经拥有std::mutex所有权的线程**不能在这个互斥体上再次调用 lock() 和 unlock()**，否则可能导致死锁
- std::recursive_mutex 行为与 std::mutex 类似，区别在于能在**同一个互斥体上再次调用 lock() 和 unlock()**，经常用于递归函数加锁

### 定时的互斥体类

- std::timed_mutex

- std::recursive_timed_mutex

- std::shared_timed_mutex

  try_lock_for(rel_time) 在给定相对时间内获取锁，到点返回结果

  try_lock_util(abs_time) 获取锁直到给定的绝对时间

## 仿函数(functor)

通过重载***operator ()***运算符模拟函数形为的***类***。

![image.png](/static/img/0146183ae51e144efc3ba8d78a4a3e76.image.webp)

## Qt ConnectionType

1. ***Qt::AutoConnection***：如果接收者位于发出信号的线程中，则使用 **Qt::DirectConnection**。否则，使用 **Qt::QueuedConnection**。连接类型在信号发出时确定。

2. ***Qt::DirectConnection***：发出信号时**立即调用**槽函数。该槽函数在**发出信号线程**中执行。

3. ***Qt::QueuedConnection***：信号发出后，信号会暂时被放到一个**消息队列**中，需等到**接收对象**所属线程的**事件循环**取得控制权时才取得该信号，然后执行和信号关联的槽函数，这种方式既可以在**同一线程**内传递消息也可以**跨线程**操作。emit语句后的代码将在发出信号后**立即被执行**，无需等待槽函数执行完毕，槽函数在**接收者所依附线程**执行。

4. ***Qt::BlockingQueuedConnection***：槽函数的**调用时机**与**Qt::QueuedConnection**一致，不过发送完信号后**发送者所在线程会阻塞**，直到槽函数运行完。而且**接收者和发送者绝对不能在一个线程**，否则程序会死锁。在多线程间需要同步的场合可能需要这个。

5. ***Qt::UniqueConnection***：这个flag可以通过按位或（|）与以上四个结合在一起使用。当这个flag设置时，当某个信号和槽已经连接时，再进行重复的连接就会失败。也就是为了**避免重复连接**。

6. ***Qt::SingleShotConnection***：这是一个可以使用按位 OR 与上述任何一种连接类型组合的标志。当设置了 **Qt::SingleShotConnection** 时，槽只会被调用一次；发出信号时，连接将**自动断开**。

C++一些零碎知识整理

---
comments: true
---
# OpenMP 并行计算

在这里例子中用到了一个关键的语句：

```cpp
#pragma omp parallel for
```

这个句子代表了C++中使用OpenMP的基本语法规则：`#pragma omp` `指令` `[子句[子句]…]`



## 1. OpenMP指令与库函数

　　OpenMP包括以下**指令**：

-   `parallel：`用在一个代码段之前，表示这段代码将被多个线程并行执行
-   `for`：用于for循环之前，将循环分配到多个线程中并行执行，必须保证每次循环之间无相关性
-   `parallel for`：parallel 和 for语句的结合，也是用在一个for循环之前，表示for循环的代码将被多个线程并行执行
-   `sections：`用在可能会被并行执行的代码段之前
-   `parallel sections：`parallel和sections两个语句的结合
-   `critical：`用在一段代码临界区之前
-   `single：`用在一段只被单个线程执行的代码段之前，表示后面的代码段将被单线程执行
-   `barrier：`用于并行区内代码的线程同步，所有线程执行到barrier时要停止，直到所有线程都执行到barrier时才继续往下执行
-   `atomic：`用于指定一块内存区域被制动更新
-   `master：`用于指定一段代码块由主线程执行
-   `ordered：`用于指定并行区域的循环按顺序执行
-   `threadprivate：`用于指定一个变量是线程私有的

　　OpenMP除上述指令外，还有一些库函数，下面列出几个常用的`库函数`：

-   `omp_get_num_procs`：返回运行本线程的多处理机的处理器个数
-   `omp_get_num_threads：`返回当前并行区域中的活动线程个数
-   `omp_get_thread_num：`返回线程号
-   `omp_set_num_threads：`设置并行执行代码时的线程个数
-   `omp_init_lock：`初始化一个简单锁
-   `omp_set_lock：`上锁操作
-   `omp_unset_lock：`解锁操作，要和omp_set_lock函数配对使用
-   `omp_destroy_lock：`omp_init_lock函数的配对操作函数，关闭一个锁

　　OpenMP还包括以下`子句`：

-   `private：`指定每个线程都有它自己的变量私有副本
-   `firstprivate：`指定每个线程都有它自己的变量私有副本，并且变量要被继承主线程中的初值
-   `lastprivate：`主要是用来指定将线程中的私有变量的值在并行处理结束后复制回主线程中的对应变量
-   `reduce：`用来指定一个或多个变量是私有的，并且在并行处理结束后这些变量要执行指定的运算
-   `nowait：`忽略指定中暗含的等待
-   `num_threads：`指定线程的个数
-   `schedule：`指定如何调度for循环迭代
-   `shared：`指定一个或多个变量为多个线程间的共享变量
-   `ordered：`用来指定for循环的执行要按顺序执行
-   `copyprivate：`用于single指令中的指定变量为多个线程的共享变量
-   `copyin：`用来指定一个threadprivate的变量的值要用主线程的值进行初始化。
-   `default：`用来指定并行处理区域内的变量的使用方式，缺省是shared

## 2. parallel指令用法

parallel 是用来构造一个并行块的，也可以使用其他指令如for、sections等和它配合使用。其用法如下：

```
#pragma omp parallel [for | sections] [子句[子句]…]
{
　　// 需要并行执行的代码
}
```
例如，可以写一个简单的并行输出提示信息的代码：

```
#pragma omp parallel num_threads(8)
{
    printf(“Hello, World!, ThreadId=%d\n”, omp_get_thread_num() );
}
```

在本机测试将会得到如下结果：

![img](https://i.loli.net/2021/02/02/hiX6fctonxgEYBq.png)

　　结果表明，printf函数被创建了8个线程来执行，并且每一个线程执行的先后次序并不确定。和传统的创建线程函数比起来，OpenMP相当于为一个线程入口函数重复调用创建线程函数来创建线程并等待线程执行完。如果在上面的代码中去掉num_threads(8)来指定线程数目，那么将根据实际CPU核心数目来创建线程数。

## 3. for指令用法

for指令则是用来将一个for循环分配到多个线程中执行。for指令一般可以和parallel指令合起来形成parallel for指令使用，也可以单独用在parallel语句的并行块中。其语法如下：

```
#pragma omp [parallel] for [子句]
    for循环语句
```

例如有这样一个例子：

```
#pragma omp parallel for
for ( int j = 0; j < 4; j++ )
{
    printf("j = %d, ThreadId = %d\n", j, omp_get_thread_num());
}
```

可以得到如下结果：

![img](https://i.loli.net/2021/02/02/j45z8qHDlZ2yFnN.png)

　　从结果可以看出，for循环的语句被分配到不同的线程中分开执行了。需要注意的是，如果不添加parallel关键字，那么四次循环将会在同一个线程里执行，结果将会是下面这样的：

![img](https://i.loli.net/2021/02/02/2Ab9tYvofFyuO8g.png)

## 4. sections和section的用法

section语句是用在sections语句里用来将sections语句里的代码划分成几个不同的段，每段都并行执行。用法如下：

```
#pragma omp [parallel] sections [子句]
{
    #pragma omp section
    {
        // 代码块
    }
}
```

例如有这样一个例子：

```
#pragma omp parallel sections 
{
#pragma omp section
    printf("section 1 ThreadId = %d\n", omp_get_thread_num());
#pragma omp section
    printf("section 2 ThreadId = %d\n", omp_get_thread_num());
#pragma omp section
    printf("section 3 ThreadId = %d\n", omp_get_thread_num());
#pragma omp section
    printf("section 4 ThreadId = %d\n", omp_get_thread_num());
}
```

可以得到如下结果：

![img](https://i.loli.net/2021/02/02/VEkTFfChDgJrXpS.png)

结果表明，每一个section内部的代码都是（分配到不同的线程中）并行执行的。使用section语句时，需要注意的是这种方式需要保证各个section里的代码执行时间相差不大，否则某个section执行时间比其他section长太多就达不到并行执行的效果了。

如果将上面的代码拆分成两个sections，即：

```
#pragma omp parallel sections 
{
#pragma omp section
    printf("section 1 ThreadId = %d\n", omp_get_thread_num());
#pragma omp section
    printf("section 2 ThreadId = %d\n", omp_get_thread_num());
}

#pragma omp parallel sections 
{
#pragma omp section
    printf("section 3 ThreadId = %d\n", omp_get_thread_num());
#pragma omp section
    printf("section 4 ThreadId = %d\n", omp_get_thread_num());
}
```

产生的结果将会是这样的：

![img](https://i.loli.net/2021/02/02/n4ogYbTt1NsXZ9V.png)

可以看出，两个sections之间是串行执行的，而section内部则是并行执行的。

OpenMP并行计算的使用

# 快速BigNumber伪随机数生成器

## 示例

```cpp
#include <random>
#include <iostream>

int main()
{
    std::random_device rd;  //获取随机数种子
    std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()
    std::uniform_int_distribution<> dis(0, 9);

    for (int n = 0; n<20; ++n)
        std::cout << dis(gen) << ' ';
    std::cout << '\n';
    system("pause");
    return 0;
}
```