Funktion zum Entfernen verbotener Zeichen

Deklarieren Sie eine Zeichenfolge, die die ungültigen Zeichen enthält: "\\/:?"<>|". Alles, was Sie tun müssen, ist zu prüfen, ob sich der Char im Array befindet. Verwenden Sie dazu eine native Funktion oder schreiben Sie eine Methode, CharInString(char* needle, string* haystack)die den Inhalt des bereitgestellten Heuhaufens durchläuft, um zu prüfen, ob sich die Nadel darin befindet.

Ihre Schleife sollte so aussehen:

string illegalChars = "\\/:?\"<>|"
for (it = s->begin() ; it < s->end() ; ++it){
    bool found = illegalChars.find(*it) != string::npos;
    if(found){
        *it = ' ';
    }
}

Es ist wartungsfreundlicher und lesbarer. Sie können feststellen, ob Sie ein Zeichen ganz leicht dupliziert haben, und da Sie es mit jeder beliebigen Zielzeichenfolge und beliebiger Zeichenfolge illegaler Zeichen, die Sie gerade für sich selbst erstellt haben, eine generische RemoveIllegalChars(string* targetString, string* illegalChars)Methode erstellen können, die an einer beliebigen Stelle in Ihrem Programm verwendet werden kann.

_{Ich benutze diese Zeiger möglicherweise falsch. Mein C ++ fu ist schwach ... vorerst.}

Sie könnten immer transform verwenden

#include <algorithm>
#include <string>
#include <iostream>

const std::string forbiddenChars = "\\/:?\"<>|";
static char ClearForbidden(char toCheck)
{
    if(forbiddenChars.find(toCheck) != string::npos)
    {
         return ' ';
    }

    return toCheck;
}

int main()
{
    std::string str = "EXAMPLE:";
    std::transform(str.begin(), str.end(), str.begin(), ClearForbidden);
    std::cout << str << std::endl;
    return 0;
}

Eine Sache, die ich an Ihrer Funktion ändern würde (zusätzlich zu der Empfehlung von Jonathan, zum Speichern der verbotenen Zeichen einen String zu verwenden), ist der Argumenttyp von removeForbiddenCharto string&anstelle von string*. Im Allgemeinen wird es in C ++ als empfehlenswert angesehen, wenn möglich Verweise über Zeigern zu verwenden (siehe zum Beispiel diesen Eintrag in der C ++ - faq-lite).

Eine weitere, geringfügige kosmetische Änderung, die ich empfehlen würde, ist das Umbenennen der Funktion in removeForbiddenChars(Plural), da dies mehr beschreibt.

Oder, hier ist noch eine andere Möglichkeit, indem Sie alle Elemente aus der STL verwenden:

#include <algorithm>
#include <string>
#include <iostream>

bool isForbidden( char c )
{
    static std::string forbiddenChars( "\\/:?\"<>|" );

    return std::string::npos != forbiddenChars.find( c );
}

int main()
{
    std::string myString( "hell?o" );

    std::replace_if( myString.begin(), myString.end(), isForbidden, ' ' );

    std::cout << "Now: " << myString << std::endl;
}

C verfügt über eine hilfreiche Funktion size_t strcspn(const char *string, const char *delimiters), die Sie zusätzlich zu implementieren können. Die ASCII-Version ist ziemlich schnell. Es verwendet einen Bitvektor, um die Trennzeichen zu testen.

Lösung ohne bedingte Verzweigung.
Platz für Zeitoptimierung.

Vereinfachter Algorithmus:

void removeForbiddenChar(string* s)
{
    for (string::iterator it = s->begin() ; it < s->end() ; ++it)
    {
        // replace element with their counterpart in the map
        // This replaces forbidden characters with space.
        (*it) = charMap[*it];
    }
}

Oder die C ++ 0x-Version:

void removeForbiddenChar(std::string* s)
{
    std::transform(s->begin(), s->end(), [](char c) => {return charMap[c];});
}

Benötigen Sie einfach die Daten:

char    charMap[] =
                            // The majority of characters in this array
                            // map the poistion to the same character code.
                            //  charMap['A']  == 'A'
                            // For forbidden characters a space is in the position
                            //  charMap['<']  == ' '
                            //  Note: \xxx is an octal escape sequence
                            "\000\001\002\003\004\005\006\007"
                            "\010\011\012\013\014\015\016\017"
                            "\020\021\022\023\024\025\026\027"
                            "\030\031\032\033\034\035\036\037"
                            "\040\041 \043\044\045\046\047" // replaced \042(") with space
                            "\050\051\052\053\054\055\056 " // replaced \057(/) with space
                            "\060\061\062\063\064\065\066\067"
                            "\070\071 \073 \075  " // replaced \072(:)\074(<)\076(>)\077(?) with space
                            "\100\101\102\103\104\105\106\107"
                            "\110\111\112\113\114\115\116\117"
                            "\120\121\122\123\124\125\126\127"
                            "\130\131\132\133 \135\136\137" // replaced \134(\)
                            "\140\141\142\143\144\145\146\147"
                            "\150\151\152\153\154\155\156\157"
                            "\160\161\162\163\164\165\166\167"
                            "\170\171\172\173\174\175\176\177"
                            "\200\201\202\203\204\205\206\207"
                            "\210\211\212\213\214\215\216\217"
                            "\220\221\222\223\224\225\226\227"
                            "\230\231\232\233\234\235\236\237"
                            "\240\241\242\243\244\245\246\247"
                            "\250\251\252\253\254\255\256\257"
                            "\260\261\262\263\264\265\266\267"
                            "\270\271\272\273\274\275\276\277"
                            "\300\301\302\303\304\305\306\307"
                            "\310\311\312\313\314\315\316\317"
                            "\320\321\322\323\324\325\326\327"
                            "\330\331\332\333\334\335\336\337"
                            "\340\341\342\343\344\345\346\347"
                            "\350\351\352\353\354\355\356\357"
                            "\360\361\362\363\364\365\366\367"
                            "\370\371\372\373\374\375\376\377";

Ähnlich wie strcspnis strpbrk, aber anstatt Offsets zurückzugeben, wird ein Zeiger auf die nächste Übereinstimmung und NULL zurückgegeben, wenn keine weiteren Übereinstimmungen vorhanden sind. Dies macht den Austausch so einfach wie:

while ((filename = strpbrk(filename, "\\/:?\"<>|")) != NULL)
    *filename++ = '_';