C++ Can'；t将Map声明并分配为const

我刚刚删除了一个设置为4个小时未回答的问题。通过一些尝试和错误，我基本上能够自己回答这个问题，并且似乎对它有很好的处理能力，除了一件。为什么我不能将我的地图声明为常量，或者我做错了？完整的例子在底部

类内标题

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

如果我从声明和定义中删除const，它将编译并工作，因此它不是世界末日。但是，既然这应该是静态的，那么它不应该是const类型吗

这是它所使用的功能：

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;
}

编辑：除非删除常量，否则不会编译的完整示例：

#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;
}

#包括
#包括
#包括
类转换器{
公众：
转换器（）；
std:：string ConvertToLowerCase（std:：string）；
const std:：map UppercaseConvert；//删除要编译的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（字符：word）{
if（大写转换[字符]）{
ConvertedString.push_back（大写转换[字符]）；
}
else ConvertedString.push_back（字符）；
}
返回转换字符串；
}
int main（）{
变频器；
std:：cout
const UppercaseConvert=
是一个语法错误。当您引用一个已经存在的变量时，只需在此处使用其名称
UppercaseConvert
。您不会重复其声明或限定符的某些部分


让我们来谈谈这一行：

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' } };

这称为赋值。您正在将
UppercaseConvert
已有的值更改为不同的值

因此，不可能将
UppercaseConvert
设为
const
，也不可能有这一行。因为如果它是
const
，则无法更改其值

我猜您打算做的是初始化
UppercaseConvert
。初始化意味着提供一个值，该值将在变量创建时保留。按照您目前编写该变量的方式，该变量被初始化为空映射，您稍后尝试更改映射以在其中包含条目。构造函数主体在e成员变量已完成初始化


在注释中，您似乎也希望映射是静态的。这可能是一个好主意。对于
静态
成员，您不在构造函数中放入任何内容。这是因为构造函数用于构造类的实例。但是静态成员与任何特定实例都没有关联。静态成员表示在该成员的总体立场

类定义应包含：

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

重要提示：即使此行包含
=
符号，它也不是赋值。这是一个声明。赋值和声明之间的区别在于，在赋值中，您引用的是一个已经存在的变量；在声明中，您创建的变量由类型说明符表示。实际上，您可以（而且很可能应该）从这一行中省略
=
。但我加入它是为了说明这一点，因为您将看到人们在这里使用
=


如注释中所述，您还需要更改行
UppercaseConvert[character]
。
map:：operator[]
只能用于非常量映射，因为其行为的一部分是在映射中不存在字符时添加新条目

循环可以是：

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

如果您还计划在其他地方查找映射，那么最好将查找代码分离为自己的函数。
请发布真实代码。
const std:map
是一个语法错误。
const UppercaseConvert=
也是一个语法错误。如果您没有准确显示所做的，很难说您做错了什么。看，你在用不相关的细节分散自己的注意力。还有一个原因是准备一个好主意。“因为这应该是静态的”-如果它应该是静态的，那么为什么不将其设置为静态的呢？我修复了std:：map，我将编写一个示例，但代码可以工作。重要的是，如果使用const键入map，它将无法编译。请给我一些，我将把它转换为一段代码。我在底部添加了一个完整的示例，但问题是相同的，更多的是一个问题n academic“我对const和map有什么不理解”与不起作用的代码相比……很明显，它不起作用……但为什么它不起作用呢？也许你应该说，如果它不是静态的，你可以使用构造函数的初始值设定项列表，在每个类的基础上使用构造函数初始化它。无论哪种方式，[]运算符对常量映射不起作用-您需要调用at（）函数。我想我明白了。我之所以在这两个位置都添加了常量，是因为这是类中所说的（与任何类一样，它过于简化）.所以我有用const声明的方法ie:我想我明白了。我之所以在这两个地方都添加了const，是因为这就是类中所说的（与任何类一样，它过于简化了）。所以我有用const声明的类方法ie:bool GetSomeValue（）const；然后定义bool class:：GetSomeValue（））const{}；因此，虽然我基本上了解如何将其与map一起使用，但差异非常模糊。最后，您能告诉我这行的内容是：char ch=it==UppercaseConvert.end（）？character:it->second；我从未见过这一点，所以不确定如何解释它。函数声明完全不同
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' } };

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