笔试题整理
输出下面函数的运行结果
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
class A
{
public:
virtual std::string clsname() { return "A"; }
std::string clsname2() { return "A"; }
void test()
{ std::cout << "A, " << clsname() << ", " << clsname2() << std::endl; }
};
class B : public A
{
public:
std::string clsname() override { return "B"; }
virtual std::string clsname2() { return "B"; }
virtual void test()
{ std::cout << "B, " << clsname() << ", " << clsname2() << std::endl; }
};
class C : public B
{
public:
std::string clsname() override { return "C"; }
std::string clsname2() override { return "C"; }
void test() override
{ std::cout << "C, " << clsname() << ", " << clsname2() << std::endl; }
};
int main()
{
A a; B b; C c; A d = c;
b.test(); //B,B,B
c.test(); //C,C,C
d.test(); //A,A,A
((A&)c).test();//A,C,A
//等同于static_cast<A&>(c).test();
((B&)c).test();//C,C,C
std::bind(&A::test, &b)();//A,B,A
std::bind(&A::test, &c)();//A,C,A
std::bind(&B::test, &b)();//B,B,B
std::bind(&B::test, &c)();//C,C,C
return 0;
}
解释：
- 前三个没什么好说的
- 第四个是C风格的强制类型转换。等同于
static_cast<A&>(c).test();。杂记2的强制类型转换里面有。因为强制类型转换不改变原对象，只是依靠原对象生成新的指定类型的对象。这里相当于用A&类型的临时对象进行调用。注意此时临时对象是c的引用。并且引用一样可以触发多态。所以是ACA。 - 第五个是CCC的原因是B类里面test也是虚函数了。
- 六七八九就是bind。bind会返回可调用对象。注意这里也属于临时对象。第二个参数隐含的this指针传入哪个对象地址就相当于多态调用了哪个对象。
异步转同步
这题相当于让我们的request_sync函数等候request函数执行完毕后再返回。为此我们可以在sync函数内给request函数单独开一个线程，并且强制死锁等候调用完毕后进行解锁。
大概示范：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
mutex mylock; //全局变量的锁 也可以写成局部变量然后传入。
void request(const function<void(int)>& callback){
int input_param;
callback(input_param);
mylock.unlock(); //解锁（这个是一次锁）
}
void testfunc(int){
}
vector<int> request_sync(){
mylock.lock(); //一次加锁
thread th(request, testfunc);
mylock.lock(); //二次重复加锁，强制死锁
mylock.unlock();//获取二次加锁后记得再解锁一次
th.join();
}
第一次加锁后，第二次加锁由于抢不到锁，所以该线程会休眠。但是不影响异步调用的函数执行。等到request的异步调用callback得到足够数据了，request进行解锁。这次解锁后可以让线程唤醒然后抢到第二次的锁。所以还要再次解锁。
自我检讨
注意不要创建不必要的数据结构。而且使用sort不一定比for循环更慢。
力扣 49
我的睿智解法：
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
class Solution {
public:
vector<vector<string>> groupAnagrams(vector<string>& strs) {
unordered_map<string, vector<string>> my_map;
vector<vector<string>> ret;
map<char, int> tempmap;
for (int i = 0; i < strs.size(); i++) {
int sum = 0;
for (int j = 0; j < strs[i].size(); j++) {
tempmap[strs[i][j]]++;
}
string key;
for (auto& i : tempmap) {
key+= i.first + to_string(i.second);
}
my_map[key].push_back(strs[i]);
tempmap.clear();
}
vector<string> temp;
for (auto& i : my_map) {
for (auto& j : i.second) {
temp.emplace_back(j);
}
ret.emplace_back(temp);
temp.clear();
}
return ret;
}
};
- 我们完全没有必要再创建一个map来储存如
a1b2c3这种key。也完全没有必要按照字符逐个遍历。更没有必要做字符串拼接和字符串比较。一眼望去全是无用功。 - 我们完全没有必要在放入结果集的时候再创建临时vector。我们map里面存的值本来就是vector，拿来就用不就行了？为什么要拿出来再放回去？
正确解法：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Solution {
public:
vector<vector<string>> groupAnagrams(vector<string>& strs) {
unordered_map<string, vector<string>> my_map;
vector<vector<string>> ret;
for (int i = 0; i < strs.size(); i++) {
string tempkey = strs[i];
sort(tempkey.begin(), tempkey.end());
my_map[tempkey].push_back(strs[i]);
}
for(auto t = my_map.begin(); t != my_map.end(); t++){
ret.emplace_back(t->second);
}
return ret;
}
};
非常优雅。
首先，对字符串进行排序。这里排序一定会比 逐个字符遍历 + 字符串拼接 + 放入新的map里更快。也就是我们换一种哈希方式。不再采用统计数字的方式。因为所有的字母异位词（长度相同）（dll和ldll并不是有效的一组异位词) 在给字母排序后一定是一样的。
所以这样排序后的字符串完全可以当做key。我们可以直接存入。
第二点，我们map的值本来就是vector，直接置入结果数组就行了。不需要再拿出变量再创建临时数组再放进去。