笔试题整理#

输出下面函数的运行结果#

1
class A
2
{
3
public:
4
    virtual std::string clsname() { return "A"; }
5
    std::string clsname2() { return "A"; }
6

7
    void test()
8
    { std::cout << "A, " << clsname() << ", " << clsname2() << std::endl; }
9
};
10

11
class B : public A
12
{
13
public:
14
    std::string clsname() override { return "B"; }
15
    virtual std::string clsname2() { return "B"; }
16

17
    virtual void test()
18
    { std::cout << "B, " << clsname() << ", " << clsname2() << std::endl; }
19
};
20

21
class C : public B
22
{
23
public:
24
    std::string clsname() override { return "C"; }
25
    std::string clsname2() override { return "C"; }
26

27
    void test() override
28
    { std::cout << "C, " << clsname() << ", " << clsname2() << std::endl; }
29
};
30

31
int main()
32
{
33
    A a; B b; C c; A d = c;
34

35
    b.test(); //B,B,B
36
    c.test(); //C,C,C
37
    d.test(); //A,A,A
38

39
    ((A&)c).test();//A,C,A
40
    //等同于static_cast<A&>(c).test();
41
    ((B&)c).test();//C,C,C
42

43
    std::bind(&A::test, &b)();//A,B,A
44
    std::bind(&A::test, &c)();//A,C,A
45

46
    std::bind(&B::test, &b)();//B,B,B
47
    std::bind(&B::test, &c)();//C,C,C
48

49
    return 0;
50
}

解释：

前三个没什么好说的
第四个是C风格的强制类型转换。等同于static_cast<A&>(c).test();。杂记2的强制类型转换里面有。因为强制类型转换不改变原对象，只是依靠原对象生成新的指定类型的对象。这里相当于用A&类型的临时对象进行调用。注意此时临时对象是c的引用。并且引用一样可以触发多态。所以是ACA。
第五个是CCC的原因是B类里面test也是虚函数了。
六七八九就是bind。bind会返回可调用对象。注意这里也属于临时对象。第二个参数隐含的this指针传入哪个对象地址就相当于多态调用了哪个对象。

异步转同步#

微信图片_20220915011409

这题相当于让我们的request_sync函数等候request函数执行完毕后再返回。为此我们可以在sync函数内给request函数单独开一个线程，并且强制死锁等候调用完毕后进行解锁。

大概示范：

1
mutex mylock; //全局变量的锁 也可以写成局部变量然后传入。
2

3
void request(const function<void(int)>& callback){
4
    int input_param;
5
    callback(input_param);
6
    mylock.unlock(); //解锁（这个是一次锁）
7

8
}
9

10
void testfunc(int){
11

12
}
13

14
vector<int> request_sync(){
15
    mylock.lock(); //一次加锁
16
    thread th(request, testfunc);
17
    mylock.lock(); //二次重复加锁，强制死锁
18
    mylock.unlock();//获取二次加锁后记得再解锁一次
19
    th.join();
20
}

第一次加锁后，第二次加锁由于抢不到锁，所以该线程会休眠。但是不影响异步调用的函数执行。等到request的异步调用callback得到足够数据了，request进行解锁。这次解锁后可以让线程唤醒然后抢到第二次的锁。所以还要再次解锁。

自我检讨#

注意不要创建不必要的数据结构。而且使用sort不一定比for循环更慢。#

力扣 49

我的睿智解法：

1
class Solution {
2
public:
3
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
4
        unordered_map<string, vector<string>> my_map;
5
        vector<vector<string>> ret;
6
        map<char, int> tempmap;
7
        for (int i = 0; i < strs.size(); i++) {
8
            int sum = 0;
9
            for (int j = 0; j < strs[i].size(); j++) {
10
                tempmap[strs[i][j]]++;
11
            }
12

13
            string key;
14
            for (auto& i : tempmap) {
15

16
                key+= i.first + to_string(i.second);
17
            }
18
            my_map[key].push_back(strs[i]);
19
            tempmap.clear();
20
        }
21

22
        vector<string> temp;
23
        for (auto& i : my_map) {
24
            for (auto& j : i.second) {
25
                temp.emplace_back(j);
26
            }
27
            ret.emplace_back(temp);
28
            temp.clear();
29
        }
30
        return ret;
31
    }
32
};

我们完全没有必要再创建一个map来储存如a1b2c3这种key。也完全没有必要按照字符逐个遍历。更没有必要做字符串拼接和字符串比较。一眼望去全是无用功。
我们完全没有必要在放入结果集的时候再创建临时vector。我们map里面存的值本来就是vector，拿来就用不就行了？为什么要拿出来再放回去？

正确解法：

1
class Solution {
2
public:
3
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
4
        unordered_map<string, vector<string>> my_map;
5
        vector<vector<string>> ret;
6
        for (int i = 0; i < strs.size(); i++) {
7
            string tempkey = strs[i];
8
            sort(tempkey.begin(), tempkey.end());
9
            my_map[tempkey].push_back(strs[i]);
10
        }
11

12
        for(auto t = my_map.begin(); t != my_map.end(); t++){
13
            ret.emplace_back(t->second);
14
        }
15
        return ret;
16
    }
17
};

非常优雅。

首先，对字符串进行排序。这里排序一定会比逐个字符遍历 + 字符串拼接 + 放入新的map里更快。也就是我们换一种哈希方式。不再采用统计数字的方式。因为所有的字母异位词（长度相同）（dll和ldll并不是有效的一组异位词) 在给字母排序后一定是一样的。

所以这样排序后的字符串完全可以当做key。我们可以直接存入。

第二点，我们map的值本来就是vector，直接置入结果数组就行了。不需要再拿出变量再创建临时数组再放进去。