如何在 C++ 中 * char + * char？

Question

这是我最近遇到的一个问题。

如果我要做这样的事情：

string str1 = "some";
string str2 = "thing";
cout << str1 + str2 << endl;

我会得到下一个输出：something

但我只有这个：

char *chr1 = "How do"
char *chr2 = "I do this?"

我需要得到以下输出

那么，我该怎么做？是的，我真的需要char *。

Answer 1

您需要创建大小为strlen(chr1) + strlen(chr2) + 1 + 1 的缓冲区，（最后+1，因为strlen 返回的字符串长度不带空终止符，但c-string 应以空终止符结尾）然后将第一个字符串复制到新缓冲区中str(n)cpy 然后使用str(n)cat。

char* buffer = new char[strlen(chr1) + strlen(chr2) + 1 + 1];
strcpy(buffer, chr1);
strcat(buffer, " ");
strcat(buffer, chr2);
// use buffer
delete[] buffer;

Answer 2

尽管 strcat() 可能是 ScarletAmanranth 已经提到的最佳解决方案，但还有另一个解决方案。

也可以先将 c-strings 转换为 std::string's，对它们执行任何所需的操作，然后将结果转换回 c-string。在某些情况下，这可能更适合您的需求。

示例：

const char* str1 = "foo";
const char* str2 = "bar";

std::string combined = std::string(str1) + str2; // notice std::string + char* => std::string

const char* result = combined.c_str();

优点：

• 可以写成 oneliner，无需进一步声明缓冲区等。
• 可能允许通过std::string 方法和相关函数更轻松地进行操作

缺点：

• 额外开销
• 只能获取const char*，如果需要char*，则必须再次复制c字符串

考虑返回的const char* 直接指向std::string 对象的内部缓冲区。因此，只要std::string 对象没有超出范围，指针就保持有效。因此，将其与 const char* result = (std::string(str1) + str2).c_str(); 之类的临时对象一起使用是一个非常糟糕的主意（而在函数调用中编写类似的东西是合法的，因为临时对象会一直保留到调用返回）。

Answer 3

在这种情况下，您需要使用strcat()。
正如 cmets 中所指出的，您需要像 char[] 这样的东西作为新字符串的缓冲区。

Answer 4

由于这是 C++，因此必须有人提出我将要提出的建议。使用stringstream。

#include <iostream>
#include <sstream>
#include <stdlib.h>
#include <string.h>

using namespace std;

int main() {
    char *chr1 = "How do";
    char *chr2 = "I do this?";
    stringstream ss;

    ss << chr1 << chr2;
    string result = ss.str();
    char* final = (char*) calloc(result.size()+1, sizeof(char));
    strcpy(final, result.c_str());

    cout << final << endl;

    delete [] chr1, chr2, final;

    return 0;
}

calloc(int size, sizeof([type])) 调用会分配您保留最终char* 所需的所有内存。像这样，您可以以更 C++ 的方式将两个字符放在一起。但是，您想要做的更像是 C，但既然您在 C++ 中，不妨尽可能多地使用属于 C++ 一部分的方法。

Answer 5

首先不需要字符串连接；您可以继续使用流插入运算符 << 执行有效的连接（而不是使用 + 来形成一个临时的 std::string 对象，然后流插入该结果字符串）：

std::string str1 = "some";
std::string str2 = "thing";
std::cout << str1 << str2 << std::endl;

因为这是流的属性而不是字符串，所以您可以使用char* 输入来做到这一点：

const char* chr1 = "How do "
const char* chr2 = "I do this?"
std::cout << chr1 << chr2 << std::endl;

// Output: How do I do this?

请注意，我为字符串文字添加了 必需 const；当且仅当您的 C 字符串不是由字符串文字初始化时，您才可以删除它。

Answer 6

几个考虑：

• 首先是you should declare chr1 and chr2 as const char *, not char *，因为尝试修改字符串文字是未定义的行为。
• 其次，operator +关于指针涉及指针运算，char *在这方面并不特殊。如果需要连接字符串，则需要分配一个缓冲区，在其中一个接一个地复制两个字符串。

• 现有答案使用普通的旧 C 函数（Paranaix 除外），但如果您制作了一个像 std::cout 这样使用的字符串流，那么在 C++ 中会更惯用：

  #include <string>
  #include <stringstream>
  std::ostringstream ss; ss << chr1 << " " << chr2;
  const std::string s = ss.str();
  const char *result = s.c_str(); // you can use this pointer during the scope of `s`.
  

Answer 7

通常答案是“使用 std::string”。

是的，我确实需要 char *。

不只是打印，我需要获取 char * 变量作为结果容器，我需要它来进一步使用。

...但在这种情况下：

#include <cstring>

std::size_t len1 = std::strlen(str1);
std::size_t len2 = std::strlen(str2);
// unique_ptr: automated lifetime management
// 1 for '\0' terminator
std::unique_ptr<char[]> buffer( new char[len1 + len2 + 1] );
std::copy_n(str1, len1, buffer.get());
std::copy_n(str2, len2, buffer.get() + len1);
buffer.get()[len1 + len2] = '\0'; // after this, buffer.get()
                                  // points to your string

Answer 8

我分享了我的代码，以便能够在另一个 auto* 中添加“char*”的文本，而无需通过字符串或 cstring：

#include <iostream>
using namespace std;

 int leng(char* tx){
     long long int n = 0;
     while(true){
         if(tx[n] == '\0'){
             break;
         }
         n += 1;
     }
         
     return n;
 }


int main(){
    char* t = "sffdsdssd";
    char* t2 = "axgdfb";
    long long int num = leng(t)+leng(t2);
    char g[num] = {0};
    long long int n = 0;
    for(n = 0; n < leng(t); n++){
        g[n] = t[n];
    }
    long long int num1 = leng(t);
    for(n = 0;  n < leng(t2); n++){
        g[num1+n] = t2[n];
    }
    char* resultado = (char*)g;
    cout << resultado;
    return 1;
}