这些超载有必要吗？

Question

我必须编写一个库，其中包含一个采用两个字符串参数的函数：

void foo(const std::string& arg1, const std::string& arg2);

我的库将由一些不喜欢 C++ 并且只使用 const char* 的人使用。

为了满足他们的喜好，我更改了原型：

void foo(const char* arg1, const char* arg2);

并使我的第一个版本成为一个简单的内联调用：

inline void foo(const std::string& arg1, const std::string& arg2)
{
  foo(arg1.c_str(), arg2.c_str());
}

当然，感谢 std::string 构造函数，只需使用第一个版本。编写此重载只是避免在有人仅传递 const char* 的情况下实例化无用的 std::string。

但现在我想知道：这种重载真的有必要还是只是过早的优化？

另外，我觉得这在某种程度上不完整：我是否还应该写 void foo(const char* arg1, const std::string& arg2) 和 void foo(const std:: string& arg1, const char* arg2) 重载？如果我有 3 个、4 个或更多 (n) 个参数怎么办？我应该写 2ⁿ 重载吗？

简而言之，您是否遇到过类似的情况？你做了什么选择，为什么？

谢谢。

Answer 1

在我看来，有两个重载来处理组织内共存的两种不同的编程风格是合理的。

从技术上讲，这不仅仅是一种优化：

1. const char* 可以是extern "C"，因此对于来自其他语言的绑定可能有用，或者甚至来自跨越 dll 边界且标准库实现不兼容的其他 C++ 代码。
2. 转换为 std::string 可能会抛出 bad_alloc，因此如果它不能以其他方式失败，那么 const char* 版本会很有用（如果您有C 样式字符串并希望在 nothrot 上下文中使用它。

另请注意，原则上 c_str() 可能会抛出 bad_alloc，但我怀疑任何实现实际上都会抛出异常。

2ⁿ 重载对我来说似乎不值得 - 如果有人混合 string 和 char* 那么这不仅仅是编程风格的差异，他们由于某种原因实际上正在使用混合格式。由于他们已经在使用两者，因此他们可以自行转换。

这一切都假设该函数足够简单，您很乐意使用 const char* 参数来实现实际工作。如果基于 string 的实现要简单得多（例如，如果需要大量代码才能使其异常安全），那么无论如何，这可能会提高效率，因此不要提供任何重载，让它们的 const char* 转换为 string。

Answer 2

只要您想使用 C++（而不是 C），第二个似乎就没有必要了，如果您有这样的情况：

void foo(const std::string& arg1, const std::string& arg2);

您可以使用 std::string 和 的所有组合来调用它>char* 为：

char *ca, *cb;
std::string sa, sb;
//...
foo(ca,cb); //char*, char*
foo(sa,cb); //std:string, char*
foo(sa,sb); //std::string, std::string
foo(ca,sb); //char*, std::string

Answer 3

如果 const char * text 永远不为 null，则可以使用 string，因为它有隐式构造函数，因此 string 类版本就足够了。另一方面：如果 const char * text 可能为 null，则会生成运行时错误。

还有一件事：在 DLL 接口上，STL 并不是一个很好的选择。因此，如果该函数是 DLL 接口的一部分，则可以使用 C 样式字符串。

我可以这样做：

#include <string>
using namespace std;

void foo( const string arg0, const string arg1 )
extern "C" _declspec( dllexport ) void foo( const char * arg0, const char * arg1 )
{
  string string_arg0, string_arg1;
  if ( arg0 != 0 )
    string_arg0 = arg0;
  if ( arg1 != 0 )
    string_arg1 = arg1;
  foo(string_arg0, string_arg1);
}

Answer 4

在这种情况下，您可能只需使用 (const char*,const char*) 并要求每个使用 std::string 的人都使用 c_str()。这样就不会有任何内存分配开销，只有人们必须编写额外的 c_str() 。

Answer 5

我的库将被一些不喜欢 C++ 的人使用，
仅用于 const char*。

告诉他们要勇敢地学习他们的编译器编译的语言。您采用 std::string，因为这就是 C++ 中的做法，如果他们不喜欢它，那么他们可以获得 C 编译器。

Answer 6

我认为你目前的做法是正确的。在其中重载 const char* 并提供一个也提供 std::string 服务的包装器。

如果你的同事要使用 C 风格的字符指针，那么最好这样做（现在的方式）。参见以下案例；

char *p = 0;
foo(p);

void foo (const string &s)
{  // runtime error
}

演示。正如您所看到的，字符指针可能并不总是与 std::string 配合良好；那么为什么要冒险呢。即使人们可能不会进行这样的编码；但为了长期可维护性，您仍应避免此类潜在危险。

在函数内部，您始终可以选择使用 const char* 中的 std::string 并编写您的算法。