C++ 如果某个字符与数组中的前一个字符相同，则跳过该字符

我问了一个类似的问题，但遗漏了一个重要的细节。我正在对字符数组（cstring）进行一些文本处理。输入数组被复制到输出数组，但某些字符被更改（例如a->b）。这是通过使用switch语句完成的。我想要的是，如果在一行中找到两个或多个特定字符，则只有其中一个被复制到新数组中（因此我不希望在一行中有两个空格）

这就是我到目前为止得到的结果，它不会跳过某些字符行中的两个或更多字符：

char cleanName[ent->d_namlen];
    for(int i = 0; i < ent->d_namlen; i++)
    {
        switch(ent->d_name[i])
        {

            case 'a' :
                cleanName[i] = 'b';//replace a's with b's (just an example)
                break;
            case ' ' ://fall through
            case '-' :
            case '–' :
            case '—' :
                cleanName[i] = '_';//replace spaces and dashes with spaces
                break;
            ....//more case statments
           default: 
                cleanName[i] = ent->d_name[i];
  }
}

charcleanname[ent->d_namlen]；
对于（int i=0；id_namlen；i++）
{
开关（ent->d_名称[i]）
{
案例“a”：
cleanName[i]=“b”；//用b替换a（只是一个示例）
打破
案例“”：//失败
案例'-'：
案例–：
案例'-'：
cleanName[i]=''；//将空格和破折号替换为空格
打破
..//更多案例说明
违约：
cleanName[i]=ent->d_name[i]；
}
}

例如，如果一行中的两个字符被下划线替换，我该怎么做？如果（ent->d|u name[I]！=previous（ent->d|u name[I]！='-'&&ent->d|u name[I]！='-'&&ent->d|u name[I]！=''，我是否只执行

语句

这可能更像是一个算法问题，而不是特定于实现的问题。

输入示例：abbc--d-e

输出：bbbc_d_e
（为了简单起见，假设“a”映射到“b”，但实际上还有更多）
对于此类文本处理算法，我将使用状态机。
对于此类文本处理算法，我将使用状态机。
最简单的方法是在现有转换后与自定义谓词一起使用：

cleanName.erase(std::unique(std::begin(cleanName), std::end(cleanName),
    [](char c, char d) { return c == '_' && d == '_'; }), std::end(cleanName));

对于
char
数组：

length = std::unique(cleanName, &cleanName[length],
    [](char c, char d) { return c == '_' && d == '_'; }) - cleanName;
cleanName[length] = '\0';

最简单的方法是在现有转换之后与自定义谓词一起使用：

cleanName.erase(std::unique(std::begin(cleanName), std::end(cleanName),
    [](char c, char d) { return c == '_' && d == '_'; }), std::end(cleanName));

对于
char
数组：

length = std::unique(cleanName, &cleanName[length],
    [](char c, char d) { return c == '_' && d == '_'; }) - cleanName;
cleanName[length] = '\0';

需要注意的一点是，按照索引的工作方式，您需要意识到cleanName的长度不一定与输入数组的长度相同。因此，您需要注意索引i。
需要注意的一点是，按照索引的工作方式，您需要意识到cleanName的长度不一定与输入数组的长度相同。因此，您需要注意索引i。
我的建议是将最后找到的字符保留在临时变量中。这样，如果出现相同的字符，您可以忽略它。有两种方法：

在开关后添加while语句，该语句使用的每个字符都等于最后找到的字符。如果cstring有大量重复字符，这将非常有用：

 char cleanName[ent->d_namlen];
 char parent;
    for(int i = 0; i < ent->d_namlen; i++)
    {
        switch(ent->d_name[i])
        {
            case 'a' :
                cleanName[i] = 'b';//replace a's with b's (just an example)
                parent = ent->d_name[i];
                break;
            case ' ' ://fall through
            case '-' :
            case '–' :
            case '—' :
                cleanName[i] = '_';//replace spaces and dashes with spaces
                parent = ent->d_name[i];
                break;
            ....//more case statments
           default: 
                cleanName[i] = ent->d_name[i];
        }
        while((parent == ent->d_name[i++]) && ent->d_name[i++] != NULL)
            i++;
    }

charcleanname[ent->d_namlen]；
半焦父代；
对于（int i=0；id_namlen；i++）
{
开关（ent->d_名称[i]）
{
案例“a”：
cleanName[i]=“b”；//用b替换a（只是一个示例）
parent=ent->d_name[i]；
打破
案例“”：//失败
案例'-'：
案例–：
案例'-'：
cleanName[i]=''；//将空格和破折号替换为空格
parent=ent->d_name[i]；
打破
..//更多案例说明
违约：
cleanName[i]=ent->d_name[i]；
}
while（（parent==ent->d_name[i++]）&&ent->d_name[i++]！=NULL）
i++；
}

这里唯一的问题是，如果您有一个由各种交错空格和破折号组成的序列，它可能无法识别它并保留各种“\u1”。一种解决方案是保留一个父级集合，而不是一个字符

另一种方法是在每次迭代中比较当前字符和下一个字符。保留“父”变量，并且在每个开关情况下，您将当前字符与父字符进行比较，如果它们相同，则不将其添加到cleanName cstring中。
我的建议是将最后找到的字符保留在临时变量中。这样，如果出现相同的字符，您可以忽略它。有两种方法：

在开关后添加while语句，该语句使用的每个字符都等于最后找到的字符。如果cstring有大量重复字符，这将非常有用：

 char cleanName[ent->d_namlen];
 char parent;
    for(int i = 0; i < ent->d_namlen; i++)
    {
        switch(ent->d_name[i])
        {
            case 'a' :
                cleanName[i] = 'b';//replace a's with b's (just an example)
                parent = ent->d_name[i];
                break;
            case ' ' ://fall through
            case '-' :
            case '–' :
            case '—' :
                cleanName[i] = '_';//replace spaces and dashes with spaces
                parent = ent->d_name[i];
                break;
            ....//more case statments
           default: 
                cleanName[i] = ent->d_name[i];
        }
        while((parent == ent->d_name[i++]) && ent->d_name[i++] != NULL)
            i++;
    }

charcleanname[ent->d_namlen]；
半焦父代；
对于（int i=0；id_namlen；i++）
{
开关（ent->d_名称[i]）
{
案例“a”：
cleanName[i]=“b”；//用b替换a（只是一个示例）
parent=ent->d_name[i]；
打破
案例“”：//失败
案例'-'：
案例–：
案例'-'：
cleanName[i]=''；//将空格和破折号替换为空格
parent=ent->d_name[i]；
打破
..//更多案例说明
违约：
cleanName[i]=ent->d_name[i]；
}
while（（parent==ent->d_name[i++]）&&ent->d_name[i++]！=NULL）
i++；
}

这里唯一的问题是，如果您有一个由各种交错空格和破折号组成的序列，它可能无法识别它并保留各种“\u1”。一种解决方案是保留一个父级集合，而不是一个字符

另一种方法是在每次迭代中将当前字符与下一个字符进行比较。保留“parent”变量，在每个开关情况下，将当前字符与父字符进行比较，如果它们相同，则不将其添加到cleanName cstring中。
下面是一个关于
unique\u copy
算法和：

#包括
#包括
#包括
#包括
#包括
字符转换（字符c）
{
开关（c）{