Question

我陷入了另一个C问题。如何在第一个字符串之前插入第二个字符串连接两个字符串？

这就是我想出的。不幸的是，我坚持所有这些指向chars，char数组等的指针。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char* argv[] )
{
  char* output;
  int i;
  for(i = 9; i > 0; i--)
  {
    unsigned int value = (unsigned int)i;
    char buffer[20];
    sprintf(buffer, "%u", value);
//    strcat(ouput, buffer);  // append before the string.
    // first loop: 9
    // second loop: 89
    // third loop: 789
  }

  printf("%s", output);
}

我如何更正我的代码才能使其正常工作？我想我必须以某种方式将输出变量设置为空。我什么时候需要固定宽度的char数组或指针？ 20只是我的随机猜测。

Answer 1

我很困惑，因为您发布的代码与您声明的问题完全无关。（好吧，他们都使用字符串，但就是这样）

  char* src  = "Hello, ";
  char* dest = "World!";

  char* temp;
  temp = malloc(strlen(src) +strlen(dest) + 1);
  strcpy(temp, src);
  strcat(temp, dest);

  dest = temp;

除非dest是组合字符串的足够大小的固定缓冲区。如果是，则将最后一行替换为：

  strcpy(dest, temp);
  free(temp);

现在，如果你想专门构建数字列表，那么让我们尝试另一种方法：

  char buffer[10];
  buffer[9] = '\0';  // null terminate our string.
  char* output;    
  int i;    
  for(i = 9; i > 0; i--)    
  {    
       // this is a fast way of saying, sprintf("%u", i); 
       // works only for single digits
       char d = (char)('0' + i); 

       buffer[i-1] = d;
       output = &buffer[i-1];
       printf("%s", output);
   }

Answer 2

通常，你应该避免这种情况开始。对你的例子来说，最明显的解决方案是简单地向上计数。当这不合适时，用于反转构建字符串的顺序的递归解决方案仍然允许您从头到尾生成字符串：

int build_string(int value, char *string) { 
    char temp[10];

    if (value > -1)
        build_string(value-1, string);

    sprintf(temp, "%d", value); // use snprintf if available.
    strcat(string, temp);
    return string;
}

int main() { 
    char result[20] = {0};
    build_string(9, result);
    printf("%s", result);
    return 0;
}

Answer 3

您可以将字符串末尾的整数追加为：

int i;
char buffer[20];
for(i = 0; i < 10; i++) {
        sprintf(buffer+i, "%u", i);
}
printf("%s", buffer); // prints 0123456789

Answer 4

对于您声明的问题（在另一个字符串前插入一个字符串），此代码将完成此任务 - 但没有错误检查。它假定目标缓冲区中有足够的空间用于现有字符串和新前缀：

/* Insert string t in front of string s in string s */
char *strinsert(char *s, const char *t)
{
    char           *p = s + strlen(s);
    char           *q = p + strlen(t);
    char           *r = s;

    while (p >= s)
        *q-- = *p--;
    while (*t)
        *s++ = *t++;
    return(r);
}

它的作用是按正确的位数复制现有的字符串，以便在开头有新的字符串空间。

Answer 5

假设目标缓冲区足够大并且源和目标不重叠：

// not sure what order to put the params - the usual C way is destination
// followed by source, but it's also potentially confusing that the result of 
// prepend(foo,bar) is "<bar><foo>".
char* prepend(char *restrict dest, const char *restrict src) {
    size_t len = strlen(src);
    memmove(dest + len, dest, strlen(dest));
    return memcpy(dest, src, len);
}

如果缓冲区可能重叠（例如，如果src是dest的后半部分），则此方法不起作用。

如果目标缓冲区不够大，那么有人必须为结果分配新内存，在这种情况下，问题是“源”和“目标”消失 - 它们都是“源”而且都不是“目的地”。

如何连接两个字符串，其中源字符串应该在目标字符串之前添加？

5 个答案: