Question

我正在编写一个对文本进行编码的程序，以便将其放入URL中。我让用户输入一个字符串，如果它包含特殊字符（＃，％，＆amp;，？等），则将它们替换为相应的字符代码（％23，％25，％26，％3F等）。问题是特殊字符的长度为1，代码长度为3.代码最终替换特殊字符后的字符。这是我用来替换的代码。

char *p = enteredCharStr;
while ((p = strstr(p, specialCharArr[x])) != NULL )
{
    char *substr;
    substr = strstr(enteredCharStr, specialChar[x]);
    strncpy(substr, charCodesArr[x], 3);
    p++;
}

使用我的程序输入的示例输出：“this = this＆amp; that”

this%3Dis%26at

我希望输出为：

this%3Dthis%26that

如何实现我在C中尝试做的事情（无库）？

Answer 1

解决此问题的一种方法是分配第二个字符串，该字符串是enteredCharStr的三倍，并逐个复制字符，当您看到特殊字符时，请写入重播。你希望它是它的三倍，因为在最坏的情况下你需要替换几乎所有的角色。

Answer 2

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

int isspecial(int c){
    static char table[] = "#%&?=<>"; //add etc..
    return strchr(table, c) ? 1 : 0;
}

char *encode(const char *s){
    size_t capa = 1024;
    char *buff=malloc(capa*sizeof(char));
    size_t size = 0;
    for(;*s;++s){
        if(size + 3 > capa){
            capa += 32;
            buff = realloc(buff, capa*sizeof(char));
        }
        if(isspecial(*s)){
            size+=sprintf(buff+size, "%%%02x", *s);
        } else {
            size+=sprintf(buff+size, "%c", *s);
        }
    }
    if(size == capa){
        buff=realloc(buff, (size+1)*sizeof(char));
    }
    buff[size++]='\0';

    return realloc(buff, size*sizeof(char));
}

int main(void){
    char *enteredCharStr = "this=this&that";
    char *p = encode(enteredCharStr);
    printf("%s\n", p);
    free(p);
    return 0;
}

Answer 3

你需要创建一个新字符串。这是一个例子：

char *str = "abc$ddd";
char *p = str;
char *buf = malloc(strlen(str)+1);
char *pbuf = buf;
while(*p) {
  if(*p != '$') *pbuf ++ = *p;
  p++;
}

它将从str复制到buf所有非$，每字节字节数。

请注意，在您的情况下，您需要正确计算新字符串的大小。

Answer 4

C'字符串'是固定大小的字符数组，因此没有内置的插入概念。您实际上是在询问如何将n个字符插入数组的中间。

我想到了一个策略：

在长度为x的数组的位置i处插入长度为n的字符串：

将数组大小调整为n+x大小（使用realloc之类的内容）。
将位置i以外的每个角色随机播放到位置i+x。
将您的字符串写入现在由此shuffle操作释放的x位置。

或者，分配一个足够大的新数组来保存你的目标字符串（即应用了所有的替换），然后通过从目标数组复制直到遇到你想要的字符将结果写入其中替换，然后从替换字符串中复制，然后继续从原始源数组中读取。

Answer 5

我正在逐个复制字符，如果我看到一个特殊的字符，（在此代码中只有“＃”）我复制3个字符，将索引增加到输出缓冲区3。您还可以更聪明地猜测缓冲区大小，并且可能遍历整个操作，每次超出时都会使缓冲区的大小加倍。

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

int main(int argc, char* argv[]){
    if (argc != 2) {
        exit(1);
    }
    char* input = argv[1];
    int bufferSize = 128;
    char* output = malloc(bufferSize);
    int outIndex = 0;
    int inIndex = 0;

    while(input[inIndex] != '\0'){
        switch (input[inIndex])
        {
            case '#':·
                if(outIndex + 4 > bufferSize){
                    // Overflow, retry or something.
                    exit(2);
                }
                output[outIndex]   = '%';
                output[outIndex+1] = '2';
                output[outIndex+2] = '3';
                outIndex = outIndex + 3;
                inIndex  = inIndex + 1;
                break;
            // Other cases
            default:
                if(outIndex + 2 > bufferSize){
                    exit(2);
                }
                output[outIndex] = input[inIndex];
                outIndex = outIndex + 1;
                inIndex = inIndex + 1;
                break;
        }
    }
    output[outIndex] = '\0';

    printf("%s\n", output);
    return 0;
}

C - 用字符串替换char

5 个答案: