我可以创建std::set的常量表达式对象吗？
可以创建std::set的常量表达式对象。std::set是C++标准库中的一个容器，用于存储一组唯一的元素，并按照特定的排序规则进行排序。常量表达式是在编译时就能够确定其值的表达式。
在C++11标准中，std::set的构造函数被标记为constexpr，意味着可以在编译时使用常量表达式来创建std::set对象。constexpr构造函数允许在编译时进行初始化，并且可以在常量表达式中使用。
例如，以下代码演示了如何创建一个常量表达式的std::set对象：
#include <set>
constexpr std::set<int> createSet()
{
return {1, 2, 3, 4, 5};
}
int main()
{
constexpr std::set<int> mySet = createSet();
// 使用mySet进行其他操作
return 0;
}在上述代码中，createSet()函数被声明为constexpr，并返回一个包含整数1到5的std::set对象。然后，在main()函数中，使用常量表达式mySet来接收createSet()函数返回的std::set对象。
需要注意的是，使用常量表达式创建的std::set对象在编译时就被初始化，因此不能在运行时修改其内容。如果需要在运行时修改std::set对象，可以使用普通的非常量表达式来创建。
腾讯云提供了丰富的云计算产品和服务，其中包括云服务器、云数据库、云存储等。您可以通过访问腾讯云官方网站（https://cloud.tencent.com/）了解更多关于腾讯云的产品和服务信息。
相关·内容
我尝试了下面的代码。
template <int VAL>
void printVAL()
{
for(int i=0;i<VAL; i++){
cout << " i value is "<<i<<endl;
}
}
实例化: printVAL<100>()
当我使用(std::string s )作为非类型模板参数时，编译器向我发出了以下错误：
"class std::basic_str<char>' is not a valid type for
浏览 3提问于2013-04-25得票数 1
回答已采纳
考虑下面的代码示例
#include <iostream>
#include <experimental/optional>
std::experimental::optional<int> dflt(42);
template<const std::experimental::optional<int>& Dflt>
void foo() {
if (Dflt) {
std::cout << "default is set" << std::endl;
浏览 1提问于2018-03-13得票数 5
回答已采纳
有人能澄清为什么这是合法的C++代码吗？(是的，我在问我的代码为什么工作;)
#include <iostream>
#include <vector>
int main()
{
const std::size_t N = 10;
int a[N]{}; // value-initialize it to get rid of annoying un-initialized warnings in the following line
std::cout << a[5] << std::endl; // got a
浏览 8提问于2014-12-21得票数 3
回答已采纳
我有一些我不理解的链接问题。
以下是源代码：
#include <iostream>
template < typename T >
struct CompressedEnums {
CompressedEnums () : data(0) {}
T get() const {
return (T)(data);
}
void set(const T& value) {
data = value;
}
unsigned data;
};
namespace Bbs_deta
浏览 0提问于2012-02-09得票数 2
回答已采纳
我试图实例化如下所示的一组字符串：
class POI {
public:
...
static const std::set<std::string> TYPES { "restaurant", "education", "financial", "health", "culture", "other" };
...
}
现在，当我这样做时，我会得到这些错误(所有这些都在这一行上)：
error: field initializer is not constant
static
浏览 0提问于2015-09-07得票数 4
回答已采纳
在我的团队中，我见过很多人检查空指针，如下所示：
SomeClass *pSc = new SomeClass;
if ( NULL == pSc )
{
// cope with error
}
我知道这是行不通的，因为c++中的新操作符会抛出一个std::bad_alloc异常，而不是返回NULL。我也知道std：：没有人能使他们预期的真正发生。所以我写了一个这样的例子：
#include <iostream>
#include <limits>
#include <new>
浏览 2提问于2016-05-30得票数 2
回答已采纳
3回答
在我工作的项目中，我看到的代码与下一个非常相似：
std::string str = (std::string() += "some string") += "some other string";
由于显而易见的原因，我不能重现原始代码，但我可以说它使用了自定义的String和operator<<，其行为与std::string的operator+=相同。
除了创建/销毁不必要的临时对象之外，我觉得这里有一些非常不对劲的地方，但我不知道具体是什么。
临时对象是const吗？是，因为operator +=改变了对象，这段代码是如何编译(VS2010)
浏览 0提问于2013-07-22得票数 3
回答已采纳
我对constexpr编程比较陌生，并试图在constexpr上下文中对string_view对象进行一些基本操作。在我的例子中，所有的字符串在我的源代码中都以文字形式开始，所以看起来它们应该是常量表达式。我发现我可以从字符串文本构造一个constexpr string_view，没有任何问题。
但是，如果我试图调用一个带有字符串文字的constexpr函数，该函数接受一个string_view参数，那么编译就会失败。参见下面的示例()：
#include <string_view>
// this doesn't compile; the compiler compla
浏览 6提问于2020-12-07得票数 3
回答已采纳
我有一些类似的东西
class Base {
public:
explicit Base(int* i) noexcept { type = new int; *type = *i; };
constexpr Base(std::nullptr_t) : type(nullptr) { };
~Base() { cout << "Destroying!" << endl; delete type; };
protected:
int* type;
};
class Derived : public Base {
pub
浏览 0提问于2014-11-27得票数 2
回答已采纳
(这是对问题的跟进。)
因此，我想专门问一个问题，以理解我收到的中引用的标准，我的确切问题是在标题中。
老实说，即使是在上，我也不明白为什么标准会这么说。
然而，下面是一个很小的例子：
#include <array>
int main() {
auto arr = std::array<int,3>{{1,2,3}};
constexpr auto size1 = arr.size(); // OK
auto const& array = arr;
constexpr auto size2 = array.size(); //
浏览 0提问于2020-12-10得票数 3
回答已采纳
我被MSVC无意中的C++函数匹配咬了。我可以将其简化为以下测试用例：
#include <iostream>
enum Code { aaa, bbb };
struct MyVal {
Code c;
MyVal(Code c): c(c) { }
};
void test(int i, MyVal val) {
std::cout << "case " << i << ": value " << val.c << std::endl;
}
void te
浏览 3提问于2016-12-09得票数 6
回答已采纳
Ideone测试用例：
代码：
#include <iostream>
#include <sstream>
#include <vector>
#include <map>
#include <list>
#include <set>
#include <stdint.h>
template <typename T> std::ostream& write(std::ostream& os, T const& x);
template <typename T>
浏览 1提问于2011-10-05得票数 5
回答已采纳
3回答
在C++17中，此代码是非法的：
constexpr int foo(int i) {
return std::integral_constant<int, i>::value;
}
这是因为即使可以在编译时计算foo，编译器仍然需要生成在运行时执行它的指令，从而使模板实例化成为不可能。
在C++20中，我们将有consteval函数，这些函数需要在编译时进行计算，因此应该删除运行时约束。这意味着这个代码是合法的吗？
consteval int foo(int i) {
return std::integral_constant<int, i>::val
浏览 0提问于2019-05-14得票数 87
回答已采纳
我正在尝试编写一些编译时字符串合成功能。如果在结尾处注释掉代码部分，下面的代码就会编译。
#include <iostream>
constexpr const char a[] = "hello ";
constexpr const char b[] = "dear ";
constexpr const char c[] = "world!";
constexpr size_t size(const char* s)
{
int i = 0;
while(*s!=0) {
++i;
浏览 8提问于2022-06-06得票数 1
这是我问题的出发点。一些没有编译的代码。
class MyClass
{
// for sorting
auto lambda = [](const auto& x, const auto& y)
{
return x.x < y.x;
};
// something that needs a custom way to sort
std::set<SomeOtherClass, lambda> mySet;
};
编译器产生的错误是
error: non-static data membe
浏览 3提问于2022-08-16得票数 1
目前，我的代码库中有这个模板函数，它在C++17中运行得很好：
/** This function returns a reference to a read-only, default-constructed
* static singleton object of type T.
*/
template <typename T> const T & GetDefaultObjectForType()
{
if constexpr (std::is_literal_type<T>::value)
{
static constex
浏览 10提问于2022-11-21得票数 0
回答已采纳
3回答
我有两段片段。
第一个片段：
#include <string>
template <typename T>
constexpr bool foo(T&&) {
return false;
}
int main() {
std::string a;
if constexpr (foo(a)) {
}
}
第二个片段：
#include <string>
template <typename T>
constexpr bool foo(T&&) {
return fals
浏览 0提问于2018-07-21得票数 2
回答已采纳
我正在尝试创建一个类，它遵循构建器模式，并且在编译时完全运行(在C++20中使用新的consteval关键字)，但是我所做的任何尝试都不起作用。例如，这是行不通的：
#include <vector>
class MyClass
{
private:
std::vector<int> data;
public:
consteval MyClass& setData()
{
this->data = {20};
return *this;
}
consteval std::vect
浏览 5提问于2022-06-04得票数 2
回答已采纳
1回答
我很难理解gcc-8.2.0和clang-7.0.0为什么拒绝以下代码(实时代码)：
#include <array>
int main() {
constexpr std::array<int,3> v{1,2,3};
constexpr auto b = v.begin(); // error: not a constexpr
return 0;
}
有错误
error: '(std::array<int, 3>::const_pointer)(& v.std::array<int,3>::_M_
浏览 0提问于2018-10-24得票数 28
回答已采纳
1回答
我正在尝试使用boost::hana创建一组独特的类型，并且需要将所有内容都保持不变。
我的尝试如下：
#include <iostream>
#include <boost/hana.hpp>
namespace hana = boost::hana;
template < class ...Xs >
constexpr auto get_set( Xs &&...xs)
{
constexpr auto f = []( auto set, auto element )
{
using Type = de
浏览 2提问于2018-10-04得票数 0
回答已采纳
1回答
类中的c++常量指针
、、、
日安！我的编译器说：“请帮助我的代码，我尝试使用指向非常数的const指针来创建constexpr类，并在将来更改非常量变量。”
"error: ‘Actuator{const Pin{1ul, 1ul}, const Pin{1ul, 2ul}, const Pin{1ul, 3ul}, ((velocity_type*)(& velocity))}’ is not a constant expression"，
对象act1总是存在的，因为它用于ARM嵌入式设备的代码
代码：
#include <cstddef>
typedef std::size_t
浏览 4提问于2017-05-03得票数 1
回答已采纳
3回答
我试图使用默认的原始指针作为默认模板参数。我看到，非类型模板参数仅限于整数类型、枚举、指针和引用。对于引用，我没有问题，但是当我尝试使用指针时，我面临这样的错误：
error: non-type template argument of type 'Engine *' is not a constant expression.
这是我的代码：
#include <iostream>
#include <memory>
using std::cout;
using std::endl;
class Engine
{
public:
void s
浏览 0提问于2019-09-05得票数 4
回答已采纳
有人能解释一下这种行为吗？
使用编译器标志std=c99，我得到以下错误：
b1的“初始化元素不是常量”。
b2的“.‘令牌之前的预期表达式”
b3没事。
当不使用-std=c99时，所有行都可以。当不使用静态b1时是可以的。我在用GCC。
typedef struct A_tag {
int v;
int w;
} A;
typedef struct B_tag {
A super;
int x;
int y;
} B;
void test(){
static B b1 = ((B){.super={.v=100}, .x=10
浏览 7提问于2013-12-21得票数 1
回答已采纳
2回答
常量表达式未定义的行为
、、、
我一直在用constexpr做实验。在我的测试编译器(g++ 4.6)上，这无法编译，并出现关于越界访问的错误。编译器是否需要在编译时发现这一点？
#include <iostream>
constexpr const char *str = "hi";
constexpr int fail() {
return str[1000]; // Way past the end!
}
template <int N>
struct foo {
static void print() { std::cout << N <<
浏览 27提问于2011-09-15得票数 18
回答已采纳
我已经成功地实现了一个使用和操作const std::string_view&作为模板参数的结构。现在，我很难在std::array<_, std::string_view>上迭代地这样做。我用GCC 10.3 / C++17。
我的第一个模板函数接受一个std::string_view并创建一个新的、经过修改的std::string_view。在我的例子中，这是一个参数"ToUpper“函数。我在下面的代码中将它简化为Fake，它只提供相同的std::string_view。我希望将此方法(Fake)应用于std::array中的每个元素，并将其作为std::ar
浏览 5提问于2022-01-21得票数 1
2回答
Linux内核源代码有很多这样的数组文字：
enum {
FOO,
BAR
};
static const char* const names[] = {
[FOO] = "foo", /* wtf is this? */
[BAR] = "bar",
};
在这里，每一行都显式地表示所提供值的数组中的索引，而不是依赖于排序。
我不知道要搜索的短语--这叫什么？定义它的标准是什么？(或者它是GNU扩展？)我能用C++或纯C来做这件事吗？在使用gcc的实验中，我发现在test.c中使用上面的代码，
$ gcc --version
gcc (Ubu
浏览 1提问于2013-07-11得票数 21
回答已采纳
1回答
c++中的常数整和双
、、、、
我遇到了一个奇怪的案子。
// this does not work, and reports:
// constexpr variable 'b' must be initialized by a constant expression
int main() {
const double a = 1.0;
constexpr double b = a;
std::cout << b << std::endl;
}
// this works...
int main() {
const int a = 1;
constexpr in
浏览 1提问于2019-10-23得票数 7
2回答
使用变量实例化模板函数
、、、
我在一个类中有三个指针，每个指针都是模板结构的实例化。我试图使用返回类型相应不同的get<>()方法检索它们中的任何一个。
//Example program
#include <iostream>
#include <map>
#include <string>
#include <boost/shared_ptr.hpp>
#include <boost/variant.hpp>
#include <boost/any.hpp>
class CBase {};
enum en {Aa = 1, Bb = 2
浏览 3提问于2016-05-19得票数 0
回答已采纳
1回答
有人知道为什么没有警告就编译了吗？
int main()
{
const int i = 1024;
std::initializer_list<size_t> i_l = { i }; // no warning
return 0;
}
但不是
int main()
{
const int i = pow(2,10);
std::initializer_list<size_t> i_l = { i }; // warning
return 0;
}
警告：
non-constant-expression cannot be narrowed
浏览 1提问于2016-12-20得票数 5
回答已采纳
背景
我想要实现的是:我正在尝试实现类似于Java枚举的东西。具有一些附加功能的枚举)。我想出了一个使用两个类的解决方案，其中一个类表示一个值，另一个类作为可能值的枚举，使用静态变量来表示每个值。我希望它是枚举的真正替代，包括在模板实例化中使用枚举值的可能性。要使其工作，枚举值需要是一个常量表达式(constexpr)。但是，我不确定我是否正确地使用了这个程序。
“守则”
下面是我想出的代码：
class EnumType {
public:
enum Enum {val_A, val_B, val_C};
friend class EnumTypeList;
En
浏览 0提问于2013-06-28得票数 1
回答已采纳
2回答
#include <utility>
struct A {
constexpr auto one(int a) {
return std::integral_constant<int, _data[a]>{};
}
constexpr int two(int a) const {
return _data[a];
}
int _data[10];
};
int main() {
constexpr auto ex = A{{1,2,3,4,5,6,7,8,9,
浏览 4提问于2015-05-06得票数 4
回答已采纳
2回答
虽然我以前使用过这样的代码，而且很明显编译器有足够的信息可以工作，但我真的不明白为什么会这样编译：
template <class T, class I>
auto foo(const T& t, I i) {
return std::get<i>(t);
}
int main()
{
std::cerr << foo(std::make_tuple(3,4), std::integral_constant<std::size_t, 0>{});
return 0;
}
生动的例子：。
似乎是gcc和clang一
浏览 3提问于2017-09-18得票数 18
回答已采纳
我读过std::is_constant_evaluated()的定义，但我仍然不知道为什么(1)不与最新的GCC：error: 'x' is not a constant expression合作
template<auto v>
struct s
{};
constexpr void f(int x)
{
if (std::is_constant_evaluated())
{
// constexpr int z=x; (1)
// s<x> a; (2)
}
}
int main(int a
浏览 1提问于2019-08-13得票数 2
回答已采纳
我想在一个由static_assert创建的array上在template中做一个parameter pack。
考虑以下代码：
template<typename... Args>
auto constexpr CreateArrConst(Args&&... args)
{
std::array arr
{
args...
};
return arr;
}
template<typename... Args>
auto constexpr CreateArrConst_NotWorking(Args&&.
浏览 3提问于2022-06-02得票数 1
1回答
唯一指针与const正确性
、、、、
我没想到这段代码会编译：
#include <iostream>
#include <memory>
class A
{
public:
inline int get() const
{
return m_i;
}
inline void set(const int & i)
{
m_i = i;
}
private:
int m_i;
};
int main()
{
const auto ptr = std::make_unique< A >
浏览 1提问于2015-11-06得票数 8
请考虑以下代码：
typedef union { float v; unsigned u; } T;
constexpr T x = { .u = 0 };
constexpr float f(void)
{
return x.v;
}
这个代码有效吗？
请求：
$ g++ t506a.cpp -c -std=c++20 -pedantic -Wall -Wextra
<nothing>
$ clang++ t506a.cpp -c -std=c++20 -pedantic -Wall -Wextra
t506a.cpp:3:17: error: constexp
浏览 14提问于2022-05-21得票数 2
回答已采纳
2回答
假设我的代码是这样的：
#include <set>
#include <math.h>
typedef int OtherTypes;
struct MyType
{
double Field1;
OtherTypes MoreFields;
MyType(double blah) :
Field1(blah)
{
}
bool operator < (const MyType &That) const
{
// Does not use any other
浏览 0提问于2012-08-31得票数 1
回答已采纳
运行此代码时，Clang (3.9.1)和GCC (7，快照)将"1“、"2”打印到控制台。
但是，MSVC无法编译此代码：
source_file.cpp(15)：错误C2668：‘字典：：set’：对重载函数的模糊调用
source_file.cpp(9)：注:可以是“无效字典：：set(Int64_t)”
source_file.cpp(8)：注:或“无效字典：：set(const char *)”
source_file.cpp(15)：注意:当试图匹配参数列表‘(未签名的int)’时
#include <iostream>
static cons
浏览 5提问于2017-02-27得票数 3
回答已采纳
1回答
C++错误:转换为非标量类型
、、、、
我似乎在下面的代码段中出现了一个特殊的错误(忽略多余的头文件和空白的主函数，我只想将这个问题隔离到一个可编译的.cpp文件中，以便在这里发布)。它表示从“我定义的某个类型”到“非标量类型”的“某种定义类型”的错误转换。
这个特定示例中的代码应该将一组字符串列表作为一个输入参数(命名输入)，将对字符串列表的引用作为另一个输入参数(命名输出)，并从输入中的列表中计算最长的公共字符串前缀列表，并将结果存储到输出中。
编译器错误消息(也包括在相应行中的注释如下：
lcp.cpp:28:47:错误:请求将“std::list<std::basic_string<char> >:
浏览 1提问于2012-11-07得票数 5
看看这个例子()：
#include <memory>
union U {
int i[1];
};
constexpr int foo() {
U u;
std::construct_at(u.i, 1);
return u.i[0];
}
constexpr int f = foo();
gcc和msvc成功地编译了这个程序，但是clang抱怨道：
不允许在常量表达式中构造没有活动成员的联合成员“i”的子对象。
哪个编译器是对的？我认为clang在这里是错误的，因为C++20的隐式对象创建()应该使这个程序有效(因为数组应该是隐式创
浏览 6提问于2022-01-01得票数 19
在从MS Visual Studio2008迁移到MS Visual Studio2017并使用v140工具集进行编译后，我在定义类中是否存在特定的成员变量时遇到了问题。在我的例子中，它不是一个简单的变量，而是一个静态常量引用。它在不到2008年的时候运行良好。
下面是我的代码的一个摘录，它不能编译
#include <iostream>
#include <string>
struct ActivityEntry
{
static const std::string& AutoIncrementName;
};
template< type
浏览 0提问于2017-12-13得票数 1
3回答
我有一个静态的const成员，希望将它设置为最大整数。我正在尝试以下几点：
const static int MY_VALUE = std::numeric_limits<int>::max();
但是，得到以下错误：
错误:静态数据成员的类内初始化器不是常量表达式。
有什么解决办法吗？函数如何不返回常量表达式？
编辑： the -std=c++11修复了这个问题。我的室友告诉我，编译器(preC++11)不够聪明，无法决定std::numeric_limits::max()不变异任何其他东西，因此不被认为是常量。这可能是造成这个错误的原因吗？
浏览 5提问于2016-02-20得票数 7
回答已采纳
我目前正在做一个小项目，在这个项目中我操作一个枚举：
enum ThreeVal_t {T='T',F='F',U='U'};
我想创建Atom。定义如下：
class Atom :
{
private:
std :: string name;
ThreeVal_t val;
static int id;
public:
//constructors
Atom();
Atom(const Atom &at);
Atom(const ThreeVal_t at);
Atom
浏览 163提问于2019-11-10得票数 0
回答已采纳
1回答
何时构造constexpr对象相对于具有静态存储持续时间的非constexpr非本地对象？他们是否在任何其他对象的初始化之前，即在动态初始化之前就开始了他们的生活？
我正在考虑是否应该使用一个来比较std::string和某些关键字：
class string_literal
{
// private members
public:
constexpr string_literal(char const* b);
bool operator== (std::string const& other) const;
bool operator!= (std:
浏览 4提问于2014-01-01得票数 13
回答已采纳
1回答
我在玩一些指数把戏，想看看我可以去哪里，发现一个奇怪的错误.首先，普通的不太老的指数：
template<std::size_t...>
struct indices {};
template<std::size_t N, std::size_t... Indices>
struct make_indices:
make_indices<N-1, N-1, Indices...>
{};
template<std::size_t... Indices>
struct make_indices<0, Indices...>:
浏览 4提问于2013-04-15得票数 8
我想在constexpr中创建一个广泛的C++20数据存储库，成千上万个希望加载为“文本段”的原生C++对象，即将需求分页到进程中并在实例之间共享(生成代码)。
对象之间相互引用，需要通过各种属性进行索引，交叉引用等等，所有这些都希望在编译时完成。这需要constexpr (关联的)容器，但不能用模板化(按大小、哈希大小等)来完成。容器，因为一切都需要保持多态。
首先，这似乎是不可能的，因为C++20 说非瞬态分配过于脆弱，即不允许从constexpr计算中泄漏动态分配的内存。
同时，C++20 说要支持constexpr std::vector。在后一篇文章中，我看到了所有成员，包括标记为c
浏览 1提问于2021-02-16得票数 0
回答已采纳
有没有可能有一个有着固定论点的羔羊呢？是否有可能使下面的示例工作？
下面提供的ForEach函数使用索引0、1、2调用给定的lambda 3次：
template <class Func, std::size_t... index>
inline constexpr void ForEach(Func && f, std::index_sequence<index...>)
{
(f(index), ...);
}
template <class Func>
inline constexpr void ForEach(Func &a
浏览 1提问于2019-07-08得票数 2
回答已采纳
GCC9已经实现了std::is_constant_evaluated。我玩了一点，我意识到这有点棘手。这是我的测试：
constexpr int Fn1()
{
if constexpr (std::is_constant_evaluated())
return 0;
else
return 1;
}
constexpr int Fn2()
{
if (std::is_constant_evaluated())
return 0;
else
return 1;
}
int main()
{
constexpr int test1 = F
浏览 1提问于2019-01-18得票数 25
回答已采纳
我已经创建了一个函数，将多个较小的值连接成一个更大的值，同时保留值的bianry表示(例如。从多个int argb构建unsigned char r, g, b, a)。我知道我也可以通过改变价值观来实现这一点，但这不是问题的关键。
但是，如果我使用该函数实际从这些值生成一个整数，msvc将引发一个编译器错误：
error C3615: constexpr function 'Color::operator int' cannot result in a constant expression
note: failure was caused by call of undefi
浏览 2提问于2018-12-21得票数 14
回答已采纳
我有一个关于编译时函数的问题。我理解static_assert应该只与类型一起工作，这些类型可以在编译时进行评估/计算。因此，它不适用于std::string (但是，在gcc10中不支持array：：string)，而是使用std：：数组(当我在编译时知道大小时)。我正在看杰森·特纳的“C++周刊”，所以这段片段来自的这集。
代码在这里：
#include <array>
#include <algorithm>
template<typename Key, typename Value, std::size_t Size>
struct Map fin
浏览 4提问于2020-10-01得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
