C字符串插入问题

我正在尝试创建一个函数，该函数可以将长度为len的字符数组插入到字符串类型的给定索引中。然而，它的行为方式是不应该的

尝试在初始数组末尾插入时，

buf

的内容按相反顺序插入到字符串的开头

i、 e.将

world

插入

Hello

成为

dlrowHello

当尝试插入初始情况的中间时，输出为<代码> Word你好< /Cord>< /P>

str->bytes.data

是正在修改的数组

str->bytes.usage

是该数组的长度

bool string_insert(string_t * const str, size_t index, 
        const char * const buf, size_t len)
{
    bool success = false;
    uint8_t orig_size = str->bytes.usage;
    uint8_t * temp;

    if (str->len < index){
        return false;
    }
    if(str->bytes.usage+len>=str->bytes.usage){
        temp = malloc(sizeof(char) * (str->bytes.usage + len));
    }   
    else {
        temp = malloc(sizeof(char) * (str->bytes.usage));
    }
    if (temp == NULL){
        success = false;    
    }
    else{
        if (index == 0){  //inserts at beginning

            for (int k = 0; k < len; k++){
                temp[k] = buf[k];

            }   
            for (int j = len; j < str->bytes.usage+len; j++){
                temp[j] = str->bytes.data[j - len];
            }
        }
        else if (index == str->bytes.usage){    //inserts at end
            for (int h = 0; h < str->bytes.usage; h++){
                temp[h] = str->bytes.data[h];
            }
            for (int g = 0; g < len; g++){
                temp[g+str->bytes.usage] = buf[g];  
            }

        }
        else{    //inserts in the middle
            for (int i = 0; i < index; i++){
                temp[i] = str->bytes.data[i];
            }
            for(int i = index; i < index + len; i++){
                temp[i] = buf[i-index];
            }
            for(int i = index + len; i < str->bytes.usage+len; i++){
                temp[i] = str->bytes.data[i-len];
            }
        }
        string_free(str);
        str->bytes.data = temp;
        str->bytes.dim = 2*str->bytes.usage;
        str->bytes.usage = orig_size+len;
        success = true;
    }
        return success;
}

bool string\u insert（string\u t*const str，size\u t index，
常量字符*常量大小（长度）
{
布尔成功=假；
uint8\u t orig\u size=str->bytes.usage；
uint8_t*温度；
如果（str->len<索引）{
返回false；
}
如果（str->bytes.usage+len>=str->bytes.usage）{
temp=malloc（sizeof（char）*（str->bytes.usage+len））；
}   
否则{
temp=malloc（sizeof（char）*（str->bytes.usage））；
}
if（temp==NULL）{
成功=错误；
}
否则{
如果（索引==0）{//在开头插入
对于（int k=0；kbytes.usage+len；j++）{
temp[j]=str->bytes.data[j-len]；
}
}
else if（index==str->bytes.usage）{//在末尾插入
对于（inth=0；hbytes.usage；h++）{
temp[h]=str->bytes.data[h]；
}
对于（int g=0；gbytes.usage]=buf[g]；
}
}
否则{//插在中间
对于（int i=0；ibytes.data[i]；
}
for（int i=index；ibytes.usage+len；i++）{
temp[i]=str->bytes.data[i-len]；
}
}
无字符串（str）；
str->bytes.data=temp；
str->bytes.dim=2*str->bytes.usage；
str->bytes.usage=orig_size+len；
成功=真实；
}
回归成功；
}

---

基本上，我只需要知道我是否失明，是否遗漏了一些明显的东西。

当索引为0时，它的顺序是否相反

if (index == 0){  //inserts at beginning of array

            for (int k = 0; k < len; k++){
                temp[k] = buf[k];

if（index==0）{//在数组开头插入
对于（int k=0；k

改为

if (index == 0){  //inserts at beginning of array

     for (int k = 0; k < len; k++){
            temp[k] = buf[len - k - 1];

if（index==0）{//在数组开头插入
对于（int k=0；k

您可以尝试类似的方法，而不是发布卷积

假设：

不是普通的C字符串

字符串实例没有包含足够的未使用内存，无法 两手空空

将在字符串1的偏移处插入字符串2

字符串\u t定义为：

类型定义结构 { 字符*pStr； 国际斯特伦； }弦乐

警告：未编译，也未测试

string_t *string_insert( 
    const string_t * originalStr, 
    const string_t * strToInsert, 
    size_t index )
{

    string_t  *newString = NULL;

    if( NULL != (newString =  malloc( sizeof( string_t )) ) )
    { // then malloc successful
        newString->pStr = NULL;
        newString->strLen = 0;

        // allocate enough room.
        if(NULL != (newString->pStr = 
                    malloc( originalStr->strlen + strToInsert->strlen )
        {// then mallooc successful
            newString->strLen = 
                origianlStr->strlen + strToInsert->strLen;

            //copy first part of originalStr to newString
            for( int i = 0; i < index; i++ )
            {
                newString->pStr[i] = originalStr->pStr[i];
            }

            // copy string to insert
            for( int j=0; j<strToInsert->strlen; j++ )
            {
                newStr->pStr[i+j] = strToInsert-pStr[j];
            }

            // copy last part of originalStr to newStr
            for ( int k = 0; k<newString->strLen; k++ )
            {
                newStr->pStr[i+j+k] = origianalStr->pStr[index+k];
            }
        }
        else
        {
            free( newString );
            newString = NULL;
        }
    }

    return newString
} // end function: string_insert

string\u t*string\u insert（
常量字符串\u t*原始字符串，
常量字符串\u t*strotinsert，
大小(指数)
{
string_t*newString=NULL；
if（NULL！=（newString=malloc（sizeof（string_t）））
{//那么malloc成功了吗
新闻字符串->pStr=NULL；
新闻字符串->strLen=0；
//分配足够的空间。
如果（NULL！=（新闻字符串->pStr=
malloc（原始文本->字符串+字符串插入->字符串）
{//那么mallooc成功了吗
新闻字符串->字符串=
原始STR->strlen+strToInsert->strlen；
//将originalStr的第一部分复制到newString
对于（int i=0；ipStr[i]=originalStr->pStr[i]；
}
//复制要插入的字符串
for（int j=0；jstrlen；j++）
{
newStr->pStr[i+j]=strotinsert pStr[j]；
}
//将originalStr的最后一部分复制到newStr
for（int k=0；kstrLen；k++）
{
newStr->pStr[i+j+k]=origianalStr->pStr[index+k]；
}
}
其他的
{
免费（新闻字符串）；
newString=NULL；
}
}
返回新闻字符串
}//结束函数：string\u insert

您有

    if (str->len < index){

if（str->len

---

，但您无法将任何内容分配给

str->len

请尝试创建一个并向我们展示，包括结构定义和如何调用函数。此外，您应该学习如何使用调试器，然后您可以逐行遍历代码以查看实际发生的情况。除了字符串不是0之外，代码看起来很好是设计的吗？我忘了考虑，我会给它一个测试。调试器……DCV.当它故意在开始插入时，它工作得很好。但是，当它试图插入末尾时，它会在开始时向后插入它所在的字符数组的位置，因此index＝0是开始和STR->字节。结束了，其他一切都在中间。

    if (str->len < index){