如何正确地将C字符串传递给可变参数模板函数内的lambda

Question

这是我的复杂情况：

我有一个使用variadic模板和lambda的函数：

template<typename...Args>
void foo(Args...args) {
    // the arguments are passed to the lambda
    _func = [args...](){ do_sth(args...); };
}

在观察特定事件时，将触发lambda _func 。 我的问题是，我传递的一些参数是C字符串，它们可能指向临时的std字符串，如下所示：

const char *pStr = __temp_std__string__.c_str();

鉴于我打电话给foo(pStr); ，当_func时，pStr指向的临时字符串已被释放。 我想知道是否存在处理此问题的通用方法。 我正在使用C ++ 11。

编辑：

也许我应该发布我的整个故事，因为你们许多人建议传递std :: string而不是C字符串，有理由我无法摆脱它。

我正在使用cocos2d-x开发游戏，它部署了C ++ 11。 我想要做的是当玩家改变他们的语言偏好 （从UI中选择） 时支持标签的自动本地化 。

我已将文本保存在几个文件中，并且每个文件都包含单个语言的本地化文本，它们基本上属于以下结构：

{
    "key1" : "_localized_text1_",
    "key2" : "_localized_text2_",
    ...
}

我的想法是观察语言偏好变化的事件（通过通知），我会得到一个表示该语言的密钥，以便从正确的文件中获取本地化的文本。 以下是我在对象类Label实现它的方法：

class Label {
    // this method would update the label's displayed text
    void setString(const std::string& text);

    // set a callback for changing language
    void setOnLanguageChangeFunc(std::function<void(Notification*)> func);

    // set a localised text, which would be updated on changing language
    void setLocalizeString(const std::string& key);
};

核心函数是setLocalizeString （我跳过其他两个方法的实现，因为它们的声明足够直观）：

void Label::setLocalizeString(const std::string& key) {
    // the callback lambda
    auto callback = [=](Notification *pNotification){
      setString(LOCALIZED_STRING(key)); 
    }

    // assign the lambda
    setOnLanguageChangeFunc(callback);
}

其中LOCALIZED_STRING是用键获取本地化字符串的宏助手; 并且lambda callback将在setOnLanguageChangeFunc保存为Label本地成员变量。

这在大多数情况下都很有效，使情况变得复杂的是，本地化文本中涉及格式说明符 ，例如：

{
    ...
    "keyN" : "%s eats %d cookies",
    ...
}

这种格式占位符在代码中动态传递：

// formatStr = "Tom eats 5 cookies"
std::string formatStr = StringKit::stringWithFormat("%s eats %d cookies", "Tom", 5);

其中StringKit是一个格式化字符串的实用程序，它接受可变参数，这些参数将传递给vsnprintf以产生输出。 现在你知道为什么我需要传递C字符串而不是std :: string，这只是因为格式化字符串的基础方法。

现在我必须修改Label::setLocalizeString以便它可以消化可能的可变参数：

template<typename... Args>
void setLocalizeString(const std::string& key, Args... args)
{
    // the callback lambda
    auto callback = [=](Notification *pNotification){
         setString(StringKit::stringWithFormat(LOCALIZED_STRING(sKey), args...)); 
    }

    // assign the lambda
    setOnLanguageChangeFunc(callback);
}

这是它的用例：

// on changing language, the label would display "Tom eats 5 cookies"
pLabel->setLocalizeString("keyN", "Tom", 5);

这个案例就像一个魅力，因为C字符串参数是全局的，但是当它从临时的std :: string传递时：

std::string tempStr = "Tom";
pLabel->setLocalizeString("keyN", tempStr.c_str(), 5);

由于指向的std :: string已经消失，因此C字符串“Tom”将失去调用lambda回调的值。

我尝试了几种方法，比如玩元组的东西，或者在lambda中捕获一个基本类型的包装类，但它们都不能解决问题。 但是，我认为应该存在一些棘手的解决方案。

Answer 1

此问题与lambdas或可变参数函数无关 - 如果只是存储字符串，也会出现此问题：

const char* global_storage;

int main()
{
    {
        std::string s = "hi";
        global_storage = s.c_str();
    }

    // !!! `global_storage` points to deleted memory!
    use(global_storage);
}

你需要确保字符串足够长。 使用std::string而不是const char*是一个很好的起点：

std::string global_storage;

int main()
{
    {
        std::string s = "hi";
        global_storage = std::move(s);
    }

    // OK, local string was moved into `global_storage`.
    use(global_storage.c_str());
}

如果你真的需要使用C风格的字符串，只需将它存储在lambda / whatever中作为std::string ， 然后在需要使用它时调用.c_str() ，而不是在存储它时。

Answer 2

在将它存储在lambda中时，需要将char const*参数转换为std::string 。 这是一种可能的方式，我可以建议：

#include <iostream>
#include <tuple>
using namespace std;

template<typename T, typename R = conditional_t<is_same<T, char const*>::value, string, T>>
R bar (T &&value) {return value;}

template<class Ch, class Tr, class Tuple, std::size_t... Is>
void print_tuple_impl(std::basic_ostream<Ch,Tr>& os,
                      const Tuple & t,
                      std::index_sequence<Is...>)
{
    using swallow = int[]; // guaranties left to right order
    (void)swallow{0, (void(os << (Is == 0? "" : ", ") << std::get<Is>(t)), 0)...};
}

template<class Ch, class Tr, class... Args>
decltype(auto) operator<<(std::basic_ostream<Ch, Tr>& os,
                          const std::tuple<Args...>& t)
{
    os << "(";
    print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
    return os << ")";
}

template<typename...Args>
decltype(auto) foo(Args...args)
{
    return [args = make_tuple(bar(args)...)] () { cout<< args; return; };
}

int main() {
    string *s = new string("Hello, World!");
    const char *p = s->c_str();
    auto f = foo(1, p, 3.14);
    delete s;
    f();
    return 0;
}

函数foo返回lambda，它将可变参数存储为元组，其中每个char const*元素自动转换为std::string 。 之后你可以释放临时字符串。 现在释放后释放lambda应该是安全的。

IdeOne.com