const char*作为map的key，find不到

使用 `const char*` 作为 `map` 的键时，需要自定义比较函数，否则默认的比较函数是比较指针的地址，而不是字符串的内容。

以下是一个示例代码，其中定义了一个自定义比较函数 `cmp`，用于比较 `const char*` 类型的键：

#include <iostream>
#include <map>
#include <string.h>

struct cmp {
    bool operator()(const char* a, const char* b) const {
        return strcmp(a, b) < 0;
    }
};

int main() {
    std::map<const char*, int, cmp> mp;
    mp["hello"] = 1;
    mp["world"] = 2;
    auto it = mp.find("hello");
    if (it != mp.end()) {
        std::cout << it->second << std::endl; // 输出 1
    }
    return 0;
}

在上面的代码中，我们定义了一个结构体 `cmp`，其中重载了 `()` 运算符，用于比较两个 `const char*` 类型的键。我们在定义 `map` 时指定了这个比较函数，这样 `map` 就会使用我们自定义的比较函数来比较键的大小了。

相关问题

如何用char*作为map的key

在使用 `char*` 作为 `map` 的键时，需要注意以下几点：

1. `char*` 是一个指针类型，需要使用指针比较函数来进行比较，否则默认比较的是指针地址而不是字符串内容。

2. `char*` 类型的键需要手动管理内存，因为 `map` 不会为其分配内存，也不会在键被删除时自动释放内存，需要程序员自行管理。

以下是一个示例代码，用于演示如何使用 `char*` 作为 `map` 的键：

#include <iostream>
#include <map>
#include <string.h>

struct cmp {
    bool operator()(const char* a, const char* b) const {
        return strcmp(a, b) < 0;
    }
};

int main() {
    std::map<char*, int, cmp> mp;
    char str1[] = "hello";
    char str2[] = "world";
    mp[str1] = 1;
    mp[str2] = 2;
    auto it = mp.find(str1);
    if (it != mp.end()) {
        std::cout << it->second << std::endl; // 输出 1
    }
    return 0;
}

在上面的代码中，我们定义了一个结构体 `cmp`，其中重载了 `()` 运算符，用于比较两个 `char*` 类型的键。我们在定义 `map` 时指定了这个比较函数，这样 `map` 就会使用我们自定义的比较函数来比较键的大小了。

在插入键值对时，我们使用了两个 `char` 数组 `str1` 和 `str2` 作为键，并分别对其赋值为 `"hello"` 和 `"world"`。由于 `char` 数组可以隐式转换为 `char*` 类型，因此我们可以直接将 `char` 数组作为 `map` 的键。

需要注意的是，在删除键时需要手动释放相应的内存。在上面的代码中，由于 `char` 数组的内存是在栈上分配的，因此不需要手动释放。如果使用 `malloc` 或 `new` 等动态分配内存的方式来创建 `char*`，则需要在删除键时手动释放相应的内存。

针对下面这段代码，怎么优化map表和funAll函数const string FUNC1 = "func1"; const string FUNC2 = "func2"; const string FUNC3 = "func3"; int func1(int a, int b) { return a + b; } float func2(int a, float b, float c) { return float(a) + b + c; } int func3(int a, const char *b) { int result = a; auto length = strlen(b); for (size_t i = 0; i < length; i++) { result += b[i] - '0'; } return result; } map<string, function<any(vector<any>)>> funcMap = { {FUNC1, [](vector<any> args) { return func1(any_cast<int>(args[0]), any_cast<int>(args[1])); }}, {FUNC2, [](vector<any> args) { return func2(any_cast<int>(args[0]), any_cast<float>(args[1]), any_cast<float>(args[2])); }}, {FUNC3, [](vector<any> args) { return func3(any_cast<int>(args[0]), any_cast<char *>(args[1])); }} }; int funAll(const string &key, const vector<any> args) { if (funcMap.find(key) == funcMap.end()) { return -1; } auto func = funcMap[key]; auto result = func(args); cout << any_cast<float>(result) << endl; return 0; }

函数名, vector<any> args)
{
auto func = funcMap.find(funcName);
if (func != funcMap.end())
{
return any_cast<int>((func->second)(args));
}
return 0;
}

针对这个问题，可以进行以下优化：

1.修改map表：可以使用unordered_map代替map，因为unordered_map使用哈希表，可以快速查找元素，而map使用红黑树，查找元素比较慢。

2.修改函数定义：可以将函数返回值类型设置为auto，让编译器自动推导返回值类型。

3.修改funAll函数：可以使用auto关键字来自动推导func的类型，以及使用const引用参数来避免不必要的复制。同时可以将if语句中的find()和end()合并为一个语句，提高代码的可读性和效率。

优化后的代码如下：

const string FUNC1 = "func1";
const string FUNC2 = "func2";
const string FUNC3 = "func3";

auto func1(int a, int b) {
return a + b;
}

auto func2(int a, float b, float c) {
return float(a) + b + c;
}

auto func3(int a, const char* b) {
int result = a;
auto length = strlen(b);
for (size_t i = 0; i < length; i++) {
result += b[i] - '0';
}
return result;
}

unordered_map<string, function<any(vector<any>&)>> funcMap = {
{FUNC1, [](vector<any>& args) { return func1(any_cast<int>(args[0]), any_cast<int>(args[1])); }},
{FUNC2, [](vector<any>& args) { return func2(any_cast<int>(args[0]), any_cast<float>(args[1]), any_cast<float>(args[2])); }},
{FUNC3, [](vector<any>& args) { return func3(any_cast<int>(args[0]), any_cast<const char*>(args[1])); }}
};

int funAll(const string& funcName, vector<any>& args) {
auto func = funcMap.find(funcName);
if (func != funcMap.end()) {
return any_cast<int>((func->second)(args));
}
return 0;
}