Month: March 2021

This system (linux-x86_64) is not supported

by

编译openssl-1.1.0e时，报这个错，主要修改两处

Configure文件

1
2
3

#use if $^O ne "VMS", 'File::Glob' => qw/glob/;
# 修改为
use if $^O ne "VMS", 'File::Glob' => qw/:glob/;

test/build.info文件

1
2
3

use if $^O ne "VMS", 'File::Glob' => qw/glob/;
# 同样进行修改
use if $^O ne "VMS", 'File::Glob' => qw/:glob/;

refer to: https://www.jianshu.com/p/f011a24f2667

日语之奇怪的ある

by

“ある”对应基本意思是“有”，即“have”。但这句

1

森さんは学生ではありません。

译为“森先生不是学生”，“ある”表示的意思却是“是”，即“is”，“ではありません”是“ではない”的敬语形式。

那“森先生没有学生”该怎么说呢？

先来看“あります”和“います”的区别，
“あります”用于花、草、桌子等不具有意志的事物。
“います”用于具有意志的人、动物或昆虫。

1
2

いすが部屋にあります。
こどもは公園にいます。

再在《标日》中找例句

1
2

スミスさんの家にはプールがあります。
（わたしの）うちには子供がいません。

如此我们得到“森先生没有学生”的说法

1
2

森さんには本がありません。
森さんには学生がいません。

c语言疑难点

by

1，一个星号操作并一定代表一次内存寻址操作。指针指向的内存大小是指针指向的整个内存块大小，而数组变量指向的内存大小是其某个成员所占内存大小，数组变量的大小才是整个数组占用内存大小。

1
2
3
4
5
6
7

	// in x64 mode
	int a[][2] = { 5, 4, 3, 2, 1, 6 };
	int i1 = sizeof(a);		// i1 is 24
	int i11 = sizeof(*a);		// i11 is 8
	int i2 = **(a + 1);		// i2 is 3
	int i3 = **a + 1;		// i3 is 6
	int i4 = *((int*)a + 1);	// i4 is 4

对于某类型的指针p，p+1后的地址值是增加了sizeof(*p)。
对于数组a，a+1后的地址值是增加了sizeof(*a)。

2，++操作符不参入算术式内操作符之间的优化级打架，即使++操作符在括号操作符内，是不是很反直觉？

1
2
3
4

	int a[] = { 1, 2, 3, 4, 5 };
	int *p = a;
	int j = *p++; // j is 1
	int k = *(p++); // k is 2

3，关于字节对齐

1
2
3
4
5
6

struct Diamond {
	int a1;
	char a2;
	int64_t a3;
	char a4;
};

vc2019 x64和x86下都输出

1
2
3
4
5
6
7

1>class Diamond	size(24):
1> 0	| a1
1> 4	| a2
1>  	| <alignment member> (size=3)
1> 8	| a3
1>16	| a4
1>  	| <alignment member> (size=7)
1
2
3
4
5

struct Diamond {
	char a1;
	short a2;
	char a3;
};

vc2019 x64和x86下都输出

1
2
3
4
5
6

1>class Diamond	size(6):
1> 0	| a1
1>  	| <alignment member> (size=1)
1> 2	| a2
1> 4	| a3
1>  	| <alignment member> (size=1)

vector push_back后iterator还是否有效

by 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include <vector>
 
using namespace std;
 
int main()
{
    vector<int> vec;
    vec.push_back(1);
    vec.push_back(2);
    vector<int>::iterator it = vec.begin();
    it++;
    for (int i = 5; i < 10000; i++)
        vec.push_back(i);
    int j = *it; //这里报错
    return 1;
}

实验证明：vector push_back后原来的iterator就失效了。

1
2
3
4
5
6
7
8

    list<int> li;
    li.push_back(1);
    li.push_back(2);
    list<int>::iterator itList = li.begin();
    itList++;
    for (int i = 5; i < 10000; i++)
        li.push_back(i);
    int result = *itList;

实验证明：list push_back后原来的iterator依然有效。
如此说明，iterator中存放的是成员的内存地址，而非成员相对基地址的位移。

UE4的TMap实现原理

by

TMap的成员ElementSetType是TSet类型，此TSet的成员是

1

TTuple<Key, Value>

TSet类由两个动态数组组成，一个用于Hash表，一个是TSparseArray。

先说TSparseArray，其成员Data是TArray类型，即动态数组，TSparseArray的特点是通过空闲成员内部指针将空闲成员链起来，这样可方便增加删除操作，但其中的增加操作的Index是无法预先指定的。

所以TSet类又用到了一个动态数组用于Hash表，这样可以计算Hash Key找到指定Hash表项，这个表项存的是Hash桶的最后一个入桶的成员在TSparseArray数组中的Index，而其它相同Hash Key的桶成员都在最后入桶成员结构内部链起来了。

判断类的继承性

by

比如类定义如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include <memory>
#include <iostream>
 
using namespace std;
 
class BaseA
{
public:
	int i_;
};
 
class ChildA //: public BaseA
{
public:
	int i_;
};

如下的方法只会报编译错误

1
2
3
4
5
6
7
8
9

    ChildA *a = (ChildA *)1;
    if (NULL == static_cast<BaseA*>(a))
    {
        cout << "ChildA does not inherit from BaseA 2." << endl;
    }
    else
    {
        cout << "ChildA inherits from BaseA 2." << endl;
    }

如下的方法才能编译中自动检查类的继承性并作相应处理

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

template<class T, class = void>
struct IsFromBaseA : false_type {};
 
template<class T>
struct IsFromBaseA<T, void>
    : is_convertible<T*, BaseA*>::type {};
 
int main()
{
    if constexpr (conjunction_v<IsFromBaseA<ChildA>>)
    {
        cout << "ChildA inherits from BaseA." << endl;
    }
    else
    {
        cout << "ChildA does not inherit from BaseA." << endl;
    }
    return 1;
}

这是enable_shared_from_this实现的基础。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <memory>
 
using namespace std;
 
class Aa : public enable_shared_from_this<Aa> // 'public' is necessary.
{
public:
	shared_ptr<Aa> retThis()
	{
		return shared_from_this();
	}
};
 
int main()
{
	shared_ptr<Aa> p1 = make_shared<Aa>();
	shared_ptr<Aa> p2 = p1->retThis();
 
	p2.reset();
	p1.reset();
	return 0;
}

当p1在构造时，会检查Aa是否是enable_shared_from_this派生的类，如果是，则在enable_shared_from_this类中维护一个引用计数；如果不是enable_shared_from_this派生的，则在shared_ptr类中维护一个引用计数。