C++ 常量映射及其大小

我有一个

std:：map

，在运行时无法更改。因此，我已将其标记为

const

，但无法将其标记为

constexpr

，因为它具有非文字类型

我可以在编译时推断此映射的

大小吗

#include <map>
#include<string>

int main (){
    const std::map <int, std::string> my_map { 
      { 42, "foo" }, 
      { 3, "bar" } 
    };

    constexpr auto items = my_map.size();
    return items;
}

：10:35:注意：非constexpr函数“size”不能用于
恒量表达式

constexpr auto items = my_map.size();

               ^       ~~~~~~~~~~~~~

constexpr auto items = my_map.size();

我可以在编译时推断此映射的
大小吗

#include <map>
#include<string>

int main (){
    const std::map <int, std::string> my_map { 
      { 42, "foo" }, 
      { 3, "bar" } 
    };

    constexpr auto items = my_map.size();
    return items;
}

不可以。因为
my_map
不是编译时常量，所以不能在编译时使用它

该标准没有提供编译时映射，但是应该有库，或者如果您真的需要，您可以自己创建库

我可以在编译时推断此映射的
大小吗

#include <map>
#include<string>

int main (){
    const std::map <int, std::string> my_map { 
      { 42, "foo" }, 
      { 3, "bar" } 
    };

    constexpr auto items = my_map.size();
    return items;
}

不可以。因为
my_map
不是编译时常量，所以不能在编译时使用它

该标准不提供编译时映射，但应该有库，或者如果确实需要，您可以自己创建库。
如果您通过模板函数初始化映射，这是可能的

template<class... Args>
std::pair<std::integral_constant<std::size_t, sizeof...(Args)>, std::map<int, std::string>>
make_map(Args&& ...args)
{
    return {{}, std::map<int, std::string>({std::forward<Args>(args)...})};
}

int main() {
    const auto& p = make_map(
         std::make_pair( 42, std::string("foo") ), 
         std::make_pair( 3, std::string("bar") ) 
    );

    constexpr std::size_t size = std::decay_t<decltype(p.first)>::value;
    const auto& my_map = p.second;
    //or const auto my_map = std::move(p.second);
}

模板
std:：pair
生成映射（Args&&…Args）
{
返回{}，std:：map（{std:：forward（args）…}）；
}
int main（）{
const auto&p=生成地图(
std:：make_pair（42，std:：string（“foo”），
std:：make_pair（3，std:：string（“bar”））
);
constexpr std:：size\u t size=std:：decation\u t:：value；
const auto&my_map=p.second；
//或const auto my_map=std:：move（每秒）；
}
如果通过模板功能初始化地图，则有可能

template<class... Args>
std::pair<std::integral_constant<std::size_t, sizeof...(Args)>, std::map<int, std::string>>
make_map(Args&& ...args)
{
    return {{}, std::map<int, std::string>({std::forward<Args>(args)...})};
}

int main() {
    const auto& p = make_map(
         std::make_pair( 42, std::string("foo") ), 
         std::make_pair( 3, std::string("bar") ) 
    );

    constexpr std::size_t size = std::decay_t<decltype(p.first)>::value;
    const auto& my_map = p.second;
    //or const auto my_map = std::move(p.second);
}

模板
std:：pair
生成映射（Args&&…Args）
{
返回{}，std:：map（{std:：forward（args）…}）；
}
int main（）{
const auto&p=生成地图(
std:：make_pair（42，std:：string（“foo”），
std:：make_pair（3，std:：string（“bar”））
);
constexpr std:：size\u t size=std:：decation\u t:：value；
const auto&my_map=p.second；
//或const auto my_map=std:：move（每秒）；
}
不幸的是，您不能在constexpt上下文中使用std:：map和std:：string。如果可能的话，考虑切换到数组和StrugIVIEW：

int main() {
  constexpr std::array my_map{
      std::pair<int, std::string_view>{ 42, "foo" },
      std::pair<int, std::string_view>{ 3, "bar" }
  };
  constexpr auto items = my_map.size();
  return items;
}

intmain（）{
constexpr std:：数组我的映射{
std：：对{42，“foo”}，
std：：对{3，“条”}
};
constexpr auto items=my_map.size（）；
退货项目；
}

然后使用constexpr std算法
不幸的是，在constexpt上下文中不能使用std:：map和std:：string。如果可能的话，考虑切换到数组和StrugIVIEW：

int main() {
  constexpr std::array my_map{
      std::pair<int, std::string_view>{ 42, "foo" },
      std::pair<int, std::string_view>{ 3, "bar" }
  };
  constexpr auto items = my_map.size();
  return items;
}

intmain（）{
constexpr std:：数组我的映射{
std：：对{42，“foo”}，
std：：对{3，“条”}
};
constexpr auto items=my_map.size（）；
退货项目；
}

然后使用constexpr std算法
您使用的是哪种版本的Cpp？这可能与此处相关，
constepr
s只能从其他
constepr
s中推断出来。您使用的是哪个版本的Cpp？这可能与此处相关，
constepr
s只能从其他
constepr
s中推导出来。如果需要
map
，则可以从该数组构造贴图。如果需要
map
，则可以从该数组构造贴图