Question

我试图用另一个String的部分覆盖字符串的一部分。

基本上，我想访问字符串的给定索引，从另一个字符串的另一个给定索引中写入给定数量的字符。

所以像memcpy(stringa[indexa], stringb[indexb], length);这样的函数，除了这不起作用。

使用strncpy也足够了。

根据要求提供更多代码：

void mymemset(char* memloc, char* cmd, int data_blocks[], int len)
{
    int i = 0;
    while(i < len)
    {
        //missing part. Where I want the "memcpy" operation to take place
        i++;
    }
    return;
}

memloc是我们要覆盖的字符串，cmd是我们要覆盖的字符串，data_blocks包含有关我们应该写入memloc的位置的信息，而len是我们正在执行的操作数。所以我想在位置data_blocks[i]覆盖，一次覆盖cmd 8个字符。

编辑：我想我忘记了&，很遗憾让你感到困惑并感谢你的时间。这似乎有效：

void mymemset(char* memloc, char* cmd, int data_blocks[], int len)
{
    int i = 0;
    while(i < len)
    {
        memcpy(&memloc[data_blocks[i]], &cmd[i*8], 8);
        i++;
    }
    return;
}

从cmd一次占用8个字节，将它们存储在memloc由data_blocks[i]给出的索引处。如评论所述，data_blocks包含有关memloc中可用的不同索引的信息，并且可以对字符串cmd进行细分。

Answer 1

假设stringa和stringb声明如下

char stringa[] = "Hello" ;
char stringb[] = "World" ;

这应该有效：

memcpy(&stringa[1], &stringb[1], 2) ;

您的示例不应编译，或者如果编译可能会崩溃或导致未定义的行为：

memcpy(stringa[1], stringb[1], 2) ;

Answer 2

您的命名令人困惑：memset适用于字节。如果您操纵字符串，则需要采取额外的预防措施：考虑\0。

我想你想要这样的东西：

void my_str_overwrite(char* dest, const char* ref, int idx, size_t count)
{
    size_t input_len = strlen(dest);
    if(input_len <= idx+count)
    {
        // Error: not enough space
    }
    for(size_t i=0; i<count; i++)
    {
        dest[idx+i] = ref[i];
    }
    return;
}

如果我理解正确的话，您不需要传递整个data_block[]数组，只需对此数组的一个元素感兴趣，该元素包含副本的偏移量。
由于您不修改cmd，因此应const
上面的代码不处理NULL终止字节，如果它实际上是一个字符串，应该附加到memloc

所以我想在位置data_blocks [i]覆盖，一次从cmd 8个字符覆盖。

这个令人困惑。如果您知道每次调用函数时只需要复制8个字节，那么在上面的代码中使count成为函数中的局部变量并修复它size_t count = 8;

Answer 3

如果字符串大小相同，则可以使用memcpy：

#include <strings.h>

char text[] = "Hello James!";
char name[] = "Jenny";
char* pos = strstr(text, "James");
memcpy(pos, name, strlen(name)-1); // for the '\0'

如果他们不是那么你必须重新分配字符串，因为长度会改变

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

#define STR "Hello James!"

void replace(char** src, char* find, char* rep) {
    char* ret = NULL;
    char* pos = strstr(*src, find);
    if (!pos)
        return; // no changes
    int l = (1 + strlen(*src) + strlen(rep) - strlen(find));
    ret = (char*)malloc(sizeof(char) * l);
    ret[l-1] = 0;

    int ind = (int)(pos - *src);
    strncpy(ret, *src, ind);
    printf("ind: %d; %s\n", ind, ret);
    strncpy(&ret[ind], rep, strlen(rep));
    strncpy(&ret[ind+strlen(rep)], &pos[strlen(find)], strlen(pos)-strlen(find));
    printf("%s\n", ret);
    free(*src);
    *src = ret;
}

int main() {
    char *str = NULL;
    str = (char*)malloc(sizeof(char) * (strlen(STR)+1));
    assert(str);
    strcpy(str, STR);
    printf("before: %s\n", str);
    replace(&str, "James", "John");
    printf("after: %s\n", str);

    free(str);
    return 0;
}

此代码未经优化。

用另一个字符串的部分覆盖字符串的一部分

3 个答案: