Karte nicht als const deklarieren und zuweisen

Question

Ich löschte gerade eine Frage, die für 4 Stunden unbeantwortet hatte. Ich habe es größtenteils durch Versuch und Irrtum für mich selbst beantworten können und scheint es bis auf ein Stück gut zu handhaben. Warum kann ich meine Karte nicht als Const deklarieren oder mache ich es falsch? Das vollständige Beispiel befindet sich unten.

in Klasse Kopf

const std::map <char, char> UppercaseConvert; 

in Klassenkonstruktors

const UppercaseConvert = { { 'A','a' },{ 'B','b' },{ 'C','c' },{ 'D','d' },{ 'E','e' },{ 'F','f' }, 
        { 'G','g' },{ 'H','h' },{ 'I','i' },{ 'J','j' },{ 'K','k' },{ 'L','l' }, 
        { 'M','m' },{ 'N','n' },{ 'O','o' },{ 'P','p' },{ 'Q','q' },{ 'R','r' }, 
        { 'S','s' },{ 'T','t' },{ 'U','u' },{ 'V','v' },{ 'W','w' },{ 'X','x' }, 
        { 'Y','y' },{ 'Z','z' } }; 

Es wird kompilieren und arbeiten, wenn ich die const von beide Deklaration und Definition zu entfernen, damit es nicht das Ende der Welt ist. Aber, da dies statisch sein sollte, sollte es nicht den const Typ haben?

Dies ist die Funktion, die sie in verwendet wird:

std::string BCLogic::ConvertToLowerCase(FString word) { 
    std::string ConvertedString; 
    for (char character : word) { 
    if (UppercaseConvert[character]) { 
     ConvertedString.push_back(UppercaseConvert[character]); 
    } 
    else ConvertedString.push_back(character); 
    } 
return ConvertedString; 
} 

Edit:

#include <iostream> 
#include <string> 
#include <map> 


class Converter { 

public: 
    Converter(); 
    std::string ConvertToLowerCase(std::string); 
    const std::map <char, char> UppercaseConvert; //remove const to compile 


}; 

Converter::Converter() { 
    //remove const to compile 
    const UppercaseConvert = { { 'A','a' },{ 'B','b' },{ 'C','c' },{ 'D','d'},{ 'E','e' },{ 'F','f' }, 
    { 'G','g' },{ 'H','h' },{ 'I','i' },{ 'J','j' },{ 'K','k' },{ 'L','l' }, 
    { 'M','m' },{ 'N','n' },{ 'O','o' },{ 'P','p' },{ 'Q','q' },{ 'R','r' }, 
    { 'S','s' },{ 'T','t' },{ 'U','u' },{ 'V','v' },{ 'W','w' },{ 'X','x' }, 
    { 'Y','y' },{ 'Z','z' } }; 
} 

std::string Converter::ConvertToLowerCase(std::string word) { 

    std::string ConvertedString; 
    for (char character : word) { 
     if (UppercaseConvert[character]) { 
      ConvertedString.push_back(UppercaseConvert[character]); 
     } 
     else ConvertedString.push_back(character); 
    } 
    return ConvertedString; 
} 


int main() { 
    Converter ThisConverter; 

    std::cout << "Enter a word in Caps:"; 
    std::string word; 
    std::getline(std::cin, word); 
    word = ThisConverter.ConvertToLowerCase(word); 
    std::cout << "\n Your converted word is : " << word << std::endl; 
    return 0; 
} 

Answer 1

const UppercaseConvert = ist ein Fehler Syntax: vollständiges Beispiel, dass, wenn Sie const entfernen wird nicht kompiliert. Wenn Sie auf eine bereits existierende Variable verweisen, verwenden Sie einfach ihren Namen UppercaseConvert hier. Sie wiederholen einige Teile seiner Deklaration oder Qualifier nicht.

---

reden Lassen Sie uns über die Linie:

UppercaseConvert = { { 'A','a' },{ 'B','b' },{ 'C','c' },{ 'D','d'},{ 'E','e' },{ 'F','f' }, 
{ 'G','g' },{ 'H','h' },{ 'I','i' },{ 'J','j' },{ 'K','k' },{ 'L','l' }, 
{ 'M','m' },{ 'N','n' },{ 'O','o' },{ 'P','p' },{ 'Q','q' },{ 'R','r' }, 
{ 'S','s' },{ 'T','t' },{ 'U','u' },{ 'V','v' },{ 'W','w' },{ 'X','x' }, 
{ 'Y','y' },{ 'Z','z' } }; 

Dies wird Zuordnung genannt. Sie ändern den Wert, den UppercaseConvert bereits hat, um einen anderen Wert zu haben.

So ist es nicht möglich UppercaseConvertconst zu sein und auch diese Linie zu haben. Denn wenn es const ist, dann können Sie seinen Wert nicht ändern.

Ich vermute, dass was Sie vorhatten, war initialisierenUppercaseConvert. To initialize bedeutet, einen Wert zu liefern, den die Variable bei ihrer Erstellung beibehält. So wie Sie es bisher geschrieben haben, wird die Variable zu einer leeren Karte erklärt, und Sie versuchen später, die Karte zu ändern, um Einträge darin zu haben. Der Konstruktorhauptteil wird ausgeführt, nachdem die Mitgliedsvariablen vollständig initialisiert wurden.

Link to further reading about initialization for non-static members

In Kommentaren es scheint, dass Sie auch die Karte statisch sein soll. Wahrscheinlich eine gute Idee. Für einen static Member fügen Sie nichts in den Konstruktor ein. Dies liegt daran, dass der Konstruktor zum Erstellen von Instanzen Ihrer Klasse verwendet wird. Ein statisches Element ist jedoch keiner bestimmten Instanz zugeordnet. Ein statisches Element bedeutet, dass es insgesamt eine Instanz dieses Elements gibt.enthalten

sollte der Klassendefinition:

static const std::map<char, char> UppercaseConvert; 

und dann in der .cpp Datei, in der Sie diese Klasse implementieren, aber außerhalb jeder Funktion, schreiben Sie die Definition mit initializer (und Sie nicht wiederholen Wort static hier):

const std::map<char, char> BCLogic::UppercaseConvert = 
{ { 'A','a' },{ 'B','b' },{ 'C','c' },{ 'D','d'},{ 'E','e' },{ 'F','f' }, 
{ 'G','g' },{ 'H','h' },{ 'I','i' },{ 'J','j' },{ 'K','k' },{ 'L','l' }, 
{ 'M','m' },{ 'N','n' },{ 'O','o' },{ 'P','p' },{ 'Q','q' },{ 'R','r' }, 
{ 'S','s' },{ 'T','t' },{ 'U','u' },{ 'V','v' },{ 'W','w' },{ 'X','x' }, 
{ 'Y','y' },{ 'Z','z' } }; 

Wichtiger Hinweis: obwohl diese Linie derenthältSymbol, es ist nicht eine Zuordnung. Dies ist eine Erklärung. Der Unterschied zwischen Zuordnung und Deklaration besteht darin, dass Sie bei der Zuweisung auf eine bereits existierende Variable verweisen; In einer Deklaration erstellen Sie eine Variable, wie sie von den Typbezeichnern angezeigt wird. In der Tat können Sie (und wahrscheinlich sollten) die = aus dieser Zeile weglassen. Aber ich habe es eingefügt, um diesen Punkt zu verdeutlichen, da Sie hier Leute sehen werden, die = verwenden.

---

Wie in den Kommentaren erwähnt, werden Sie auch die Linie UppercaseConvert[character] ändern müssen. Die map::operator[] kann nur auf nicht konstanten Karten verwendet werden, da ein Teil ihres Verhaltens darin besteht, einen neuen Eintrag hinzuzufügen, wenn das Zeichen nicht bereits in der Karte vorhanden war.

könnte die Schleife:

for (char character : word) 
{ 
    auto it = UppercaseConvert.find(character); 
    char ch = it == UppercaseConvert.end() ? character : it->second; 
    ConvertedString.push_back(ch); 
} 

Wenn Sie auch die Karte sich in anderen Orten suchen planen, dann würde es eine gute Idee sein, dass die Lookup-Code in seine eigene Funktion zu trennen.