错误:之前的constexpr成员变量缺少模板参数
这个错误提示是在C++中遇到的问题。让我们来解释一下：
在C++中，constexpr是用于声明常量表达式的关键字。常量表达式是在编译时求值的表达式，可以在编译时确定其值，并在运行时保持不变。而在声明constexpr成员变量时，如果缺少模板参数，就会出现上述错误。
下面是一个修正错误的示例：
template <typename T>
class MyClass {
static constexpr T myConstant = T(5); // 添加模板参数 T
};在这个示例中，我们添加了模板参数T来修正错误。现在，我们可以在类模板MyClass中声明一个constexpr成员变量myConstant，并为其指定一个初始值。
关于常量表达式的优势是它可以在编译时进行计算，从而提供更高的性能和优化机会。常量表达式可以用于优化编译时计算的情况，例如数组大小的计算、循环展开等。
在云计算领域中，常量表达式的应用场景相对较少，但在编写高性能的云原生应用程序时，了解常量表达式的概念可以帮助优化代码和提升执行效率。
腾讯云提供了多个与云计算相关的产品，包括云服务器、云数据库、云存储等。您可以在腾讯云官方网站查找相关产品的更多信息和文档。
参考链接：
相关·内容
1回答
考虑以下MCVE代码：
struct Id { static inline int id(int c) {return c;} };
template <class C>
class Foo {
C m_bar;
public:
Foo() = default;
Foo(int) : m_bar{bar} {} // Fails in clang, compiles in gcc/msvc
Foo(int, int) : m_bar(bar) {} // Compiles with all gcc/clang/msvc
Foo(int, i
浏览 0提问于2021-08-12得票数 1
回答已采纳
1回答
很抱歉，我的问题有点复杂，下面是：
我有一个帮助器结构，它包含声明如下的任何非类型模板参数：
template<typename T, T t>
struct Method {
using Type = T;
constexpr static T method = t;
};
我用它来存储一个成员函数指针，以便在编译时使用。
然后，我有一个名为TestClass的类，它的类型为Method类型，它的一个方法作为参数：
struct TestClass {
void setFoo(int n) {}
using MethodToCall = Meth
浏览 0提问于2016-02-15得票数 2
回答已采纳
3回答
下面的代码可以在VisualStudio2019和gcc 10.2 (和其他gcc版本)上用-std=c++11编译，但在clang (版本9、10和11)上失败。
#include <map>
#include <string>
struct repo {
static constexpr const char *x = "sth";
};
int main() {
// 1) This compiles
std::map<std::string, int> m1 = { {repo::x, 3} };
浏览 6提问于2021-02-01得票数 6
回答已采纳
简单的问题，这合法吗？
template<class T>
struct foo {
using type = std::conditional<IF_CONDITION<T>::value, constexpr int, int>::type;
};
编译器错误：“错误："constexpr”在这里无效“无法找到任何关于此的文档。因为这是编译时的条件，这似乎至少在理论上是可以做到的。
浏览 2提问于2018-01-10得票数 1
回答已采纳
struct Config
{
int version = 1;
};
template<Config& config /* , ... */>
struct Peripheral
{
const Config config_ = config;
static_assert(config_.version > 1, "Config version must be greater than 1");
/* ... */
};
Config myConfig;
int main()
{
myConfig.v
浏览 7提问于2022-06-15得票数 -1
回答已采纳
1回答
变量模板的部分专门化
、、、、
我知道我可以部分专门化类模板，我知道我不能部分指定函数模板。
那呢？我找不到关于它们是否可以部分专门化的文档。
浏览 25提问于2018-08-31得票数 7
回答已采纳
2回答
template <typename T>
struct A
{
static constexpr T obj {};
static constexpr bool noexcept_copy = noexcept( T{obj} );
static void UsesCopy() { T{obj}; }
static constexpr int C = 1;
};
struct NoCopy
{
constexpr NoCopy() = default;
NoCopy(const NoCopy&) = delete;
浏览 1提问于2019-08-22得票数 21
回答已采纳
是否可以在内联constexpr函数中使用变量模板而不公开变量模板本身？
例如，它编译并工作：
template<typename T> constexpr T twelve_hundred = T(1200.0);
template<typename T>
inline constexpr T centsToOctaves(const T cents) {
return cents / twelve_hundred<T>;
}
但这并不能编译：
template<typename T>
inline constexpr T cents
浏览 3提问于2017-02-15得票数 4
回答已采纳
2回答
那么，这是一个错误还是故意的(使用VS2017更新15.3.4)？
以下内容不编译，因为CustomType是一个非文字的。
class A
{
public:
// ... some constructors
inline constexpr auto Value() const { return _value; }
private:
const CustomType _value;
}
但这完全没问题：
template< //... some templates
>
class A
{
public:
// ... some const
浏览 4提问于2017-09-14得票数 0
回答已采纳
2回答
我目前正在学习如何使用模板元编程来编写c++中的函数代码
下面是我对递归斐波纳契序列生成器的尝试
template<int i, int x = 0, int y = 1>
struct Fib : Fib<i-1, y, x+y> {};
template<int x, int y>
struct Fib<0, x, y> {
enum { value = x };
};
这似乎可以很好地获得价值。但是，当试图将一个变量作为参数传递给像Fib<i>::value这样的模板时，我会得到编译器错误：the value of ‘
浏览 6提问于2021-06-13得票数 1
回答已采纳
3回答
模板化常数变量
、、、
我想确认这段代码是否合法(还是不合法？)C++17。
#include <iostream>
template<int N> inline constexpr float MyConst;
template<> inline constexpr float MyConst<1> = 1.1f;
template<> inline constexpr float MyConst<2> = 2.2f;
int main ()
{
std::cout << MyConst<1> <&l
浏览 4提问于2021-04-29得票数 7
回答已采纳
1回答
最近，我一直在使用C++20的新constexpr std::vectors (我在使用GCC v12)，遇到了一个小问题(这实际上是的一个扩展，但我觉得做一个新的会更好)。我一直试图使用constexpr std::vector作为类的成员，但这似乎不起作用，因为您不能用constexpr对它们进行注释，因此constexpr函数认为它们不能在编译时进行计算，所以现在我尝试使用模板参数，如下所示：
#include <array>
template<int N, std::array<int, N> arr = {1}>
class Test
{
pub
浏览 3提问于2022-06-04得票数 1
回答已采纳
1回答
使用clang成功编译了以下代码，但是gcc失败了：
struct fn
{
template <typename ... Args>
static constexpr bool call (Args ... ) { return true; }
};
template <typename ... T>
static constexpr bool f = false;
template <typename ... Ts, bool F = fn::call(f<Ts> ...)>
void hoge (
浏览 2提问于2015-05-12得票数 8
回答已采纳
3回答
我有自己的固定大小数组类型，我希望可以从constexpr构建std::initializer_list，而不必显式定义size模板参数。
我想我可以使用模板演绎指南，但看起来它并没有将std::initializer_list::size()作为一个函数来处理。
下面是一个尝试为std::array (类似于我的类型并有相同问题)编写一个演绎指南的示例：
namespace std
{
template<typename T> array(initializer_list<T> initialiserList) -> array<T, initia
浏览 0提问于2019-01-06得票数 14
回答已采纳
为什么width在第一次实例化之后不保留它的const状态？
template<typename T, const std::size_t N>
class ProjectionTest
{
std::array<T, N*N> _arr;
public:
ProjectionTest() : width(N)
{ }
const std::size_t width = 0;
};
ProjectionTest<int, 9> test;
ProjectionTest<int, test.width> tes
浏览 2提问于2016-10-27得票数 1
回答已采纳
在下面的C++11代码中，函数get是constexpr，但它试图通过非constexpr构造函数构造实例。
template <typename T>
struct S
{
S() {}
static constexpr S get() { return S(); }
};
int main()
{
// S<int> s1;
// auto s2 = s1.get();
}
虽然这段代码与GCC一起编译，但是我们在处理消息时使用的编译器失败了。
函数的返回是非常数的.
在这种情况下，我们开始讨论是否允许编译器发出错误。我认为
浏览 3提问于2015-08-14得票数 1
回答已采纳
2回答
在下面的代码中，我正在寻找一个可移植的单行替换#define。替换应该将单词APPLE隐藏在Foo对象的命名空间中。
class Foo {
public:
#define APPLE 123
Foo(int a) : a_(a) { }
};
// elsewhere in another file
Foo f(APPLE);
我试着让它更友好一些，并且使用Intel 2017编译器进行了工作：
class Foo {
public:
static constexpr int APPLE = 123;
Foo(int a) : a_(a) { }
};
浏览 0提问于2018-10-18得票数 4
2回答
我创建了一个模板函数，它以一个成员函数作为参数。
但是，由于类必须在作为成员函数参数的一部分使用之前被声明，所以我必须使它成为一个单独的参数：
template<typename C, void (C::*Method)(void)>
function<void(C*)> methodWrap()
{
}
这意味着当显式实例化模板时(我希望在编译时生成这些包装器，而不是将成员指针作为参数传递)，我必须在使用它时输入它两次：
function<void(C*)> someFunc = wrapMethod<SomeClass, &SomeClas
浏览 5提问于2015-12-16得票数 4
回答已采纳
1回答
推导成员变量类型
、、、
编辑:我忘了回调“捕获”了outer的outer指针。
我正在尝试初始化某个类及其成员。
类是，而不是模板。
它的成员是模板。它以“函数类型”为模板，用于封装类的回调。(我不能使用std::function，因为这是时间关键代码。)
此外，我希望编译器将推导出回调对象的模板类型(提供给成员)。
代码应该是这样的(假设所有的锅炉板都存在)：
template<typename func_t>
class inner : public inner_abstract_base
{
public:
func_t m_cb;
inner(func_t cb):m_cb(cb)
浏览 3提问于2020-11-09得票数 0
1回答
我有一个关于SFINAE的问题，我遇到了一个意外的编译错误：)这是我的代码: sfinae.h：
#include <iostream>
#include <type_traits>
template <typename T>
struct RouteManager
{
template <typename ROUTER, typename u = void>
struct hasMethod : std::false_type
{
};
template <typename ROUTER>
struct hasMethod&
浏览 0提问于2018-08-21得票数 0
以下内容适用于gcc 4.8：
class Value {
private:
static std::vector<float> compile_time_vector;
const bool compile_time_bool;
static bool f(void) {
compile_time_vector.push_back(2.3);
return true;
}
public:
template <typename
浏览 5提问于2013-12-07得票数 6
回答已采纳
1回答
基本的问题是，是否可以从专门的模板方法中添加或删除constexpr。
让我们假设以下代码：
//this is my general vector template with a constexpr default ctor
template<typename T, typename STORE>
struct alignas(16) vec {
union {
STORE st;
struct { T x; T y; T z; T w; };
};
inline explicit constexpr vec() noex
浏览 3提问于2015-11-30得票数 1
我试图了解下面的代码片段是否应该按照标准编译。当我尝试用三个主要编译器的最新版本编译它时，会发生以下情况：
✓ Clang (版本7.0.0，带有-std=c++17标志)：编译良好；
✓ GCC (版本8.2，带有-std=c++17标志)：也编译精细；
❌ MSVC (版本19.16，带有/std:c++17标志)：编译器错误(见下文)。
发生此错误的原因是MSVC编译器似乎试图实例化std::optional<void>，尽管代码已被丢弃。GCC和Clang似乎不这么做。
标准清楚地定义了在这种情况下应该发生什么吗？
#include <option
浏览 1提问于2019-01-10得票数 22
回答已采纳
我使用的是一个boost::array，其格式为< char，const std::size_t >
void test(const std::size_t XXX)
{
boost::shared_ptr<boost::array<unsigned char, XXX>> buf(new boost::array<unsigned char, max_size>);
.
.
.
};
test(100);
test(20);
这是领导
对于错误：
error C2971：'boost::array‘：t
浏览 6提问于2012-04-27得票数 1
回答已采纳
1回答
我已经很熟悉SFINAE，以及如何使用它来启用基于传递类型的特定模板(通过使用std::enable_if)。然而，我最近开始从事一个项目，我想做以下工作:在使用SFINAE时，基于提供的枚举值创建一个类专门化。现在，我知道基于枚举值进行专门化是可能的，因为我以前已经这样做过(如下所示)：
enum Specifier
{
One,
Two,
Three
}
template <Specifier>
class Foo
{
public:
void Bar();
}
template<>
void Foo<Specifier::One&
浏览 1提问于2020-11-19得票数 3
回答已采纳
2回答
我试图使用嵌套的constexpr lambdas创建一个匆匆的接口，但是编译器并不认为它是一个常量表达式。
namespace hana = boost::hana;
using namespace hana::literals;
struct C1 {};
template < typename T,
std::size_t size >
struct Array {};
constexpr auto array_ = [] (auto size) {
return [=] (auto type) {
return han
浏览 3提问于2017-04-27得票数 7
回答已采纳
2回答
下面的代码合法吗？
template <auto Lambda>
struct A {};
int main () {
auto lmb = [](int i){return i*i;};
A<lmb> a;
return 0;
}
我注意到g++可以很好地编译它，而clang++返回error: a non-type template parameter cannot have type '(lambda at main.cpp:...)'。
浏览 7提问于2020-06-11得票数 6
我正在读“游戏编程宝石”一书。我现正以正规化为例：
//Sine class
template<double &x, unsigned N>
struct Sine
{
static constexpr double val = x * (1.0 - x * x / (2.0 * N + 2) / (2.0 * N + 3)) * Sine<x,N+1>::val;;
};
//
template<const double &x>
struct Sine<x, 10>
{
static constexpr doub
浏览 2提问于2014-12-31得票数 1
回答已采纳
我有一个属于这个类的大小变量。我想将它用作std::array的大小，但我无法这样做。我发现了一些提到警员的文章，但到目前为止没有什么有用的。你能帮帮我吗?
#include<array>
#include<iostream>
class MyClass{
private:
int size; //variable I need to copy the content and make it constant.
void calculateSize(int x){
size = 2 * x;
浏览 5提问于2020-01-03得票数 1
回答已采纳
3回答
以下代码提供了一个未定义的引用链接错误：
template<int>
struct X {
static constexpr int x = 0;
};
template<>
constexpr int X<1>::x;
int main()
{
return X<1>::x;
}
但我不知道为什么。
可以定义一个数据成员而不专门化整个模板吗？
需要澄清的是:这段代码编译得很好，但是给出了一个链接器错误(未定义-引用)。
浏览 3提问于2017-12-19得票数 7
回答已采纳
1回答
以下编译没有错误：
template<int j, int i>
struct TemplateClass {
int arr[i];
};
struct A {
inline static constexpr int n = 123;
};
template<int j> struct B {
void func() {
A a;
TemplateClass<j, a.n> c;
}
};
int main() {
B<456> b;
b.func();
}
但是，使用
浏览 0提问于2019-03-11得票数 3
回答已采纳
我刚开始了解一些模板基础。事实上，直到现在我才接受这是一个事实，但我不太明白为什么这是坏的原因：
template <typename T,bool hasFoo>
struct Broken {
void foobar(){
if (hasFoo){T::foo();}
else { std::cout << "BROKEN" << std::endl;}
}
};
int main(){
Broken<int,false> t;
t.foobar();
}
虽然
浏览 8提问于2015-11-11得票数 3
回答已采纳
我正在用C++17编写一个类，我希望为浮点类型以及一些自定义类型编写重载转换操作符。这是一个可重复的例子。有更多的转换需要添加模板，但如果我能够解决这些，其余的应该是相似的。
class A {
};
class B : public A {
};
class C: public A {
};
class Missing {
public:
Missing() {}
Missing(Missing &) = default;
template<typename T,typename=typename std::enable_if_t<std::is_f
浏览 0提问于2019-02-05得票数 1
回答已采纳
2回答
我想使用一个常量表达式成员函数来初始化一个常量表达式成员变量，但是它没有编译。当我将函数移出类时，它是正常的。为什么会发生这种情况？有没有办法使用类成员常量表达式函数来初始化成员常量表达式变量？
我使用的是Apple LLVM版本8.0.0 (clang-800.0.38)。
谢谢你的帮助。
constexpr static int Add_Ext(int a, int b) { return a + b; }
class Foo
{
public:
constexpr static int Add_InClass(int a, int b) { return a + b; }
浏览 0提问于2016-12-17得票数 6
2回答
我试图在类定义之外定义一个静态成员变量。它的工作原理是预期的。但是，由于某种原因，我放置在类定义中的static_assert没有编译。为什么？
错误信息是：
note: 'Foo<unsigned int>::var' was not initialized with a constant expression
注释掉static_assert语句可以编译代码。
代码
#include <iostream>
#include <cstdint>
#include <concepts>
template < std::un
浏览 11提问于2022-08-10得票数 1
回答已采纳
考虑以下代码：
template<typename T>
struct S { static constexpr int bar = T::foo; };
struct U: S<U> { static constexpr int foo = 42; };
int main() { }
编译它，用错误拒绝它：
2:错误:在“U”中没有名为“foo”的成员
结构S{静态常数int bar = T::foo；}；
哪个编译器是对的？
这是否是因为U 在我们试图在S中使用它的时候
在这种情况下，它应该被认为是GCC的错误，但我想知道我是否在之前搜索/打开一个问题的
浏览 7提问于2016-06-14得票数 16
回答已采纳
2回答
无法推断模板参数
、、
我有以下类结构，它试图生成编译时生成的树层次结构
struct NodeBase{
virtual constexpr uint32_t size() const = 0;
virtual constexpr bool empty() const = 0;
constexpr NodeBase(){};
};
template <size_t L>
class Node : NodeBase{
private:
const uint32_t * const ptr;
const std::array<const NodeBase &,
浏览 6提问于2015-07-24得票数 0
回答已采纳
2回答
以为基础，
类作用域中的可变模板是静态数据成员模板。
举的例子如下：
struct matrix_constants {
template <typename T>
using pauli = hermitian_matrix<T, 2>;
然而，下列所有定义都有错误：
struct foo
{
template <typename T>
T pi = T{3.14};
};
template <typename T>
struct foo2
{
template <typename U =
浏览 2提问于2014-01-31得票数 2
回答已采纳
1回答
Constexpr算子新
、、、
新加入的运算符是否有可能超载？类似于：
constexpr void * operator new( std::size_t count );
其原因是要在重载的操作符体内执行constexpr函数，其中count参数值将是输入数据.由于操作符是由以下人员调用的：
SomeClass * foo = new SomeClass();
数据类型的大小是在编译时知道的，不是吗？(count== sizeof(SomeClass))所以计数可以看作是编译时间常数吗？
constexpr void * operator new( std::size_t count )
{
if constexp
浏览 0提问于2018-11-21得票数 5
1回答
静态常量表达式变量与函数
、、、
将浮点常量声明为static constexpr变量和下面示例中的函数之间有区别吗，或者这只是一个风格问题？
class MY_PI
{
public:
static constexpr float MY_PI_VAR = 3.14f;
static constexpr float MY_PI_FUN() { return 3.14f; }
}
浏览 0提问于2013-04-30得票数 56
回答已采纳
我们有一个类似于fmtlib的格式化库，它允许我们格式化这样的字符串：
int foo = 1;
double bar = 2.3;
FMT("foo={} bar={}", foo, bar);
我们最近在编译时增加了对格式字符串的解析，允许我们在格式字符串中直接指定宽度、精度等。
// print foo with width=5, pad with 0; print bar with width 6, precision 2
// as decimal floating point
FMT("foo={:05} bar={:6.2f}", foo, bar
浏览 13提问于2022-09-09得票数 4
回答已采纳
代码的目标是使我能够在代码中以未排序的坐标-稀疏表示来表示2D数组(即每个x, y, value条目的列表按任何顺序排列)，但将这个转换后的at编译时转换为该数组更容易访问的行稀疏表示(即指向行的指针数组，其中空行为空指针)。
代码
#include
#include
#include
namespace ct_sparse {
template::value_t fill_value> struct lut;
template struct def;
namespace {
template
struct SlotAr
浏览 0提问于2023-02-01得票数 3
首先，让我们定义这个问题。我们在一个更大的项目中有很多类类型。这些类型中有一堆是由我们不控制输出的工具生成的。这意味着我们无法控制它们的继承链，它们的实现可能非常复杂。还有现有的工具可以智能地推出这些类型，使用宏来构建复杂的结构，比如复杂的开关case语句，以及其他重复的实现，在这些实现中，模板根本不会对其进行裁剪。但我想要一些额外的弹性和安全的类型系统，只要有可能。因此，我还希望能够利用带有静态断言的TypeLists和type_traits来使用清晰、可读的错误消息来限制某些接口。但是，我在编写将这些类型分组为集群的代码时遇到了很多困难，而且我不理解标题中提到的错误。如果我遇到一个明显的X
浏览 1提问于2022-08-19得票数 0
回答已采纳
1回答
我逐渐了解到C++14附带了可变模板。
template<typename T>
constexpr T pi = T(3.1415926535897932385);
我的问题是--当我们使用变量模板而不是普通变量时？请给我举个例子。
浏览 1提问于2014-08-20得票数 1
回答已采纳
1回答
考虑如下
struct dummy{};
dummy d1;
dummy d2;
template<dummy* dum>
void foo()
{
if (dum == &d1)
; // do something
else if (dum == &d2)
; // do something else
}
现在，可以这样调用foo
foo<&d1>();
foo<&d2>();
一切都如期而至。但以下并不是
constexpr dummy* dum_ptr = &d
浏览 4提问于2016-12-11得票数 14
回答已采纳
这是正确的
constexpr int* p = nullptr;
声明constexpr指针(而不是指向constexpr int的指针)？
这个定义
int* constexpr p = nullptr;
给出编译错误。
浏览 0提问于2019-05-20得票数 6
回答已采纳
2回答
我正在尝试编写一个通过强制constexpr求值的函数。一个模板。我写了这段代码，但它只适用于int (注意，对于GCC来说，它会给出递归深度错误)：
#include <iostream>
template<int val>
constexpr int force_constexpr() { return val; }
constexpr int triangle(int n)
{
return n ? n + triangle(n - 1) : 0;
}
int main(void)
{
std::cout << force_con
浏览 14提问于2020-03-13得票数 2
回答已采纳
1回答
我的编译器不允许使用以下定义，因为std::string有一个非平凡的析构函数(当成员没有时，teststr不能拥有一个平凡的dtor )：
class teststr
{
private:
std::string _m;
public:
constexpr teststr(std::string value) : _m(value) {};
constexpr std::string m() const { return _m; }
void m(std::string value) { _m = value; }
};
但是，允许(据我所知) testst
浏览 4提问于2014-12-28得票数 5
回答已采纳
2回答
在类定义中，对于定义一个声明为const (而不是内联或constexpr)的文本类型的静态数据成员，constexpr有一个问题：
// S.h
struct S
{
static int const i; // not specified inline or constexpr
};
// S.cpp
#include "S.h"
constexpr int const S::i = 42; // definition, not declaration
// main.cpp
#include "S.h"
int main()
{
return S:
浏览 3提问于2017-10-13得票数 1
1回答
在回答时，我使用gcc ()和clang ()尝试了以下代码：
typedef long (*func)(int);
long function(int) { return 42; }
struct Test
{
static constexpr func f = &function;
};
template<func c>
struct Call
{
static void f()
{
c(0);
}
};
int main()
{
Call<Test::f>::f();
}
我不确定哪个编译器是
浏览 2提问于2013-04-07得票数 9
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
