如果函数被称为常量表达式，则有条件地static_assert
是一种在编译时进行条件检查的机制。它用于在编译时对一个条件进行验证，如果条件不满足，则会导致编译错误。这种机制可以用于在编译时对函数的输入参数或返回值进行验证，以确保其满足特定的条件。
常量表达式是指在编译时可以被完全计算出来的表达式，它的值在编译时就已经确定，而不是在运行时才确定。常量表达式可以用于编译时优化、模板元编程等场景。
有条件地static_assert是通过在函数内部使用static_assert语句来实现的。static_assert语句接受一个编译时的布尔表达式作为参数，如果该表达式的值为false，则会导致编译错误，并输出一个用户指定的错误信息。
有条件地static_assert可以用于对函数的输入参数进行验证，例如，可以使用static_assert来确保函数的输入参数满足特定的范围或类型要求。同时，它也可以用于对函数的返回值进行验证，以确保函数的返回值满足特定的条件。
在腾讯云的云计算平台中，可以使用C++编程语言来实现有条件地static_assert。腾讯云提供了丰富的云计算产品和服务，例如云函数（https://cloud.tencent.com/product/scf）和云编译（https://cloud.tencent.com/product/tcb）等，可以帮助开发者在云端快速构建和部署应用程序。
总结：有条件地static_assert是一种在编译时进行条件检查的机制，用于对函数的输入参数或返回值进行验证。它可以帮助开发者在编译时发现潜在的问题，并提供更加可靠和安全的代码。在腾讯云的云计算平台中，可以使用C++编程语言来实现有条件地static_assert，并结合腾讯云的云计算产品和服务进行开发和部署。
相关·内容
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
回答已采纳
让我们从示例()开始：
constexpr int len(int v) {
if (std::is_constant_evaluated()) {
// static_assert(v > 0); // ERR: 'v' is not a constant expression
return v;
} else {
return 0;
}
}
using A = std::array<int, len(3)>;
问题是，static_assert不会编译(gcc / clang最新的1
浏览 1提问于2020-08-10得票数 3
回答已采纳
3回答
无效的静态断言行为
、、、
我正在尝试用GCC v4.3.x设置一个静态断言(在main函数之外)：
#define STATIC_ASSERT(cond) extern void static_assert(int arg[(cond) ? 1 : -1])
STATIC_ASSERT( (double)1 == (double)1 ); // failed
但是当我使用浮点数时，断言总是失败。
可以正确地运行这个静态断言吗？
浏览 0提问于2009-12-23得票数 2
回答已采纳
2回答
若条件导致误差的参数比较
、、、、
我试着比较一个函数参数在一个constexpr if语句中。
下面是一个简单的例子：
constexpr bool test_int(const int i) {
if constexpr(i == 5) { return true; }
else { return false; }
}
但是，当我用GCC 7用以下标志编译它时：g++-7 -std=c++1z test.cpp -o test，我得到以下错误消息：
test.cpp: In function 'constexpr bool test_int(int)':
test.cpp:3:21: error: &#
浏览 7提问于2017-07-28得票数 1
回答已采纳
目前，您不能使用static_assert来验证constexpr函数的参数，即使对它的所有调用实际上都是constexpr。这是有意义的，因为编译器仍然必须为这个函数创建一个非constexpr实例化，以防其他模块试图调用它。可悲的是，即使函数是static或匿名命名空间，情况也是如此。
然而，C++20将引入一个新的关键字consteval，它类似于constexpr，但它不允许以非参数方式调用函数。在这种情况下，编译器可以确定函数参数在编译时总是已知的。因此，理论上应该可以使用static_assert对它们进行验证。
问题是:标准允许吗？
示例：
#include <iostr
浏览 0提问于2019-07-26得票数 20
1回答
函数模板的原型如下：
template <int pot>
inline int gridMaxSelection(Eigen::Vector3f* grads, bool* map_out,
int w, int h, float THFac);
名字是这样的：
if (sparsityFactor == 1)
numGoodPoints = gridMaxSelection<1>(grads, map, w, h, THFac);
else if (sparsityFactor == 2)
浏览 0提问于2020-12-19得票数 0
下面是cppreference中的示例：
constexpr double power(double b, int x)
{
if (std::is_constant_evaluated() && !(b == 0.0 && x < 0)) {
// A constant-evaluation context: Use a constexpr-friendly algorithm.
if (x == 0)
return 1.0;
double r = 1.0, p = x > 0 ? b : 1.0 / b;
浏览 0提问于2019-12-23得票数 1
我现在正在学习如何使用static_assert。到目前为止，我学到的是，static_assert的论点必须是常量表达式。对于下面的代码，我不知道为什么参数reference不是常量表达式:它被声明为const，并由整数常数0初始化
int main()
{
const int &reference = 0;
static_assert(reference);
}
gcc的错误消息指出，reference不能在常量表达式中使用：
error: 'reference' is not usable in a constant expression.
是否
浏览 4提问于2022-09-20得票数 -2
回答已采纳
2回答
此代码与clang和gcc一起编译得很好。
template<size_t n>
struct N {
static constexpr size_t v = n;
};
template<size_t n>
constexpr bool operator<(N<n>, size_t n2) {
return n < n2;
}
template<typename N>
constexpr void foo(N v) {
static_assert(v < 5);
}
int main()
{
浏览 1提问于2018-09-15得票数 9
回答已采纳
2回答
void foo(void* arg)
{
}
int main(int argc, char** argv)
{
foo((void*)1);
return 0;
}
编译器有没有什么标准来定义传递给foo的整型文字常量的默认大小(以字节为单位)？
浏览 0提问于2010-12-24得票数 1
回答已采纳
constexpr uint32_t BitPositionToMask(int i,int Size){
static_assert(i < Size,"bit position out of range");
return 1 << i;
}
这就产生了：
error: non-constant condition for static assertion
关于GCC，4.6.2我是没有得到什么，还是这是GCC的错误？
浏览 5提问于2013-07-10得票数 11
回答已采纳
我对“原子约束”一章很好奇
上面写着
替换后E的类型必须完全是bool。不允许转换
和
f(0); // error: S<int>{} does not have type bool when checking #1,
// even though #2 is a better match
唉哟。这意味着在使用要求条款时没有？这不是一个令人沮丧的吗？
因为我可以看到某些模板类型在遍历表达式后是如何导致bool的，而不是其他模板类型。现在我们又需要使用enable_if之类的东西了。很痛吗？
浏览 0提问于2018-11-27得票数 1
回答已采纳
我有一个关于编译时函数的问题。我理解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
回答已采纳
1回答
文字和常数函数，编译时评估
、、、、
我试图通过用户定义的文字实现一个令人愉悦的(简单、直截了当、没有TMP、没有宏、没有不可读的复杂代码、没有奇怪的语法)编译时哈希，我发现显然GCC对常量表达式的理解与我的理解有很大的不同。
由于代码和编译器的输出超过了一千字，所以没有进一步的限制：
#include <cstdio>
constexpr unsigned int operator"" _djb(const char* const str, unsigned int len)
{
static_assert(__builtin_constant_p(str), "huh?")
浏览 8提问于2013-06-21得票数 2
回答已采纳
1回答
我需要写这个函数fibo。如果这个数字太大，它应该显示为编译错误( main函数的最后一行)，main函数应该保持原样。有什么建议吗？ #include <iostream>
int fibo(int n)
{
if (n <= 1)
return n;
//if (n>=300) throws ... ?
return fibo(n - 1) + fibo(n - 2);
}
int main()
{
static_assert(fibo(7) == 34);
const int k = fibo(9);
浏览 32提问于2020-08-11得票数 1
回答已采纳
1回答
我用clang和gcc (主干版本)测试了下面的代码。有人能解释为什么普通X结构的情况不能工作，而by值捕获和使用const引用的包装用例都工作得很好。
struct X {
constexpr X(const int &v) : x(v) {}
constexpr int Get() const { return x; }
private:
const int& x;
};
constexpr X f(const X& r) {
return r;
}
struct Y {
constexpr Y(const int &v) : x(v
浏览 1提问于2020-08-18得票数 4
回答已采纳
1回答
访问类成员
、、
如何访问非静态类成员？
class A
{
int value_ = 0;//I want to access this member in class inheriting from A
};
template<class X = A>
class Y :X
{
static_assert(value_ == 0,"Non-zero not allowed");//here I want to access value_ from X which is A by default. Is this possible?
};
浏览 1提问于2012-10-21得票数 0
回答已采纳
6回答
静态断言非常方便地在编译时进行检查。一个简单的静态断言成语如下所示：
template<bool> struct StaticAssert;
template<> struct StaticAssert<true> {};
#define STATIC_ASSERT(condition) do { StaticAssert<(condition)>(); } while(0)
这对像这样的东西很好
STATIC_ASSERT(sizeof(float) == 4)
以及：
#define THIS_LIMIT (1000)
...
STATIC
浏览 3提问于2010-05-25得票数 7
回答已采纳
2回答
常数数组参考参数
、、、
请有人解释一下为什么下面的标记行编译得很好：
template<typename T, int N>
constexpr
int get_size(T (&)[N])
{
return N;
}
int main()
{
int xs[10];
constexpr int y = get_size(xs); // HERE.
static_assert(10 == y, "wrong size");
}
从直觉上看，get_size(xs)不是一个常量表达式，因为xs本身并不是，所以我不明白它为什么工作。
浏览 0提问于2013-10-16得票数 4
回答已采纳
2回答
我很想知道为什么我下面代码中的第二个static_assert不能工作。看起来，即使数组c是对a的引用，数组的大小也嵌入到类型中，因此在编译时应该可用。
#include <array>
int main()
{
std::array<int,2> a = {1,2};
std::array<int,2> b = {2,3};
std::array<int,2>& c = a;
static_assert(a.size() == b.size(), "a.size==b.size");
浏览 3提问于2020-08-09得票数 7
回答已采纳
我最近正在学习C++，我注意到了一个，它的一部分是这样的：
struct B
{
explicit B(int) { }
explicit operator bool() const { return true; }
};
int main()
{
B b2(2); // OK: direct-initialization selects B::B(int)
if (b2) ; // OK: B::operator bool()
}
的介绍告诉我，“当表达式在if语句或循环中使用时”，该表达式( b2 )的结果将隐式转换为bool类型。
浏览 0提问于2019-01-29得票数 13
回答已采纳
1回答
这个指针总是一个运行时结构吗？
、、、、
我正在学习关于this指针的C++。我从标准中看到了以下：
表达式e是一个核心常量表达式，除非对e的计算遵循抽象机器的规则计算下列表达式之一：
this，但在作为e的一部分计算的constexpr函数或constexpr构造函数中除外；
我不明白上述声明的意思。我认为this指针是一个运行时构造，因此它不能在编译时上下文中使用。但上述说法似乎表明，在上述情况下，情况并非如此。我的第一个问题是这是什么意思。有人能给我举个例子吗?这样我就能理解这句话的意思了。
我试图创建一个，以更好地理解语句的含义，但是程序并没有像预期的那样工作(这意味着它产生了错误，而我认为它应该按照引
浏览 4提问于2022-04-29得票数 0
回答已采纳
由于constexpr的扩展版本(我认为来自C++14)，您可以声明可用作“真实”constexpr的constexpr函数。也就是说，代码是在编译时执行的，或者可以作为内联函数运行。所以什么时候可以有这个程序：
#include <iostream>
constexpr int foo(const int s) {
return s + 4;
}
int main()
{
std::cout << foo(3) << std::endl;
const int bar = 3;
std::cout << foo(
浏览 7提问于2017-10-24得票数 34
回答已采纳
当我偶然发现一种奇怪的行为时，我正试图static_assert一些类型的特征，以确保一个定制类型具有预期的noexcept保证。上面减少的片段说明了这个问题：
struct DefaultOnly
{
constexpr DefaultOnly() noexcept(false) {};
};
static_assert(std::is_nothrow_default_constructible_v<DefaultOnly>);
对于这种简单的类型，GCC 8通过了static_assert，而Clang 7失败了。我不知道哪个编译器是对的。这是其中一个编译器中的一个b
浏览 0提问于2018-12-23得票数 2
回答已采纳
6回答
以下C++11程序：
int x = 42;
void f()
{
int y = 43;
static_assert(&x < &y, "foo");
}
int main()
{
f();
}
没有与gcc 4.7一起编译，因为它抱怨：
error: ‘&y’ is not a constant expression
这符合我的直觉。y的地址可能会随着每次调用f而发生变化，因此在翻译期间当然不能计算它。
然而，5.19 expr.const中的要点似乎不排除它是一个常量表达式。
我看到的唯一
浏览 3提问于2013-08-21得票数 20
回答已采纳
我的理解是，这个(无意义的)代码是无效的C++14：
class Point {
public:
constexpr double setX(double newX) { return x = newX; }
private:
double x;
};
我正在努力弄清楚C++14标准(仍然是正式草案)的哪一部分不允许它。对constexpr函数的限制列在7.1.5/2中。(很抱歉格式化错误。我想不出怎样才能把它打得好看。)
常设委员会职能的定义应满足下列限制：
它不应是虚拟的(10.3)；
其返回类型应为文字类型；
每种参数类型都应是文字类型；
其函数体应为=
浏览 4提问于2014-08-06得票数 5
3回答
等价三值算子的若？
、、、
也许我遗漏了一些东西，但我找不到任何提示:在C++17中是否存在一个与constexpr if等价的三值运算符？
template<typename Mode>
class BusAddress {
public:
explicit constexpr BusAddress(Address device) :
mAddress(Mode::write ? (device.mDevice << 1) : (device.mDevice << 1) | 0x01) {}
private:
uint8_t mAddress = 0
浏览 6提问于2016-12-07得票数 63
回答已采纳
1回答
#include <cstddef>
template<typename... Types>
constexpr std::size_t getArgCount(Types&&...) noexcept
{
return sizeof...(Types);
}
struct A
{
int n;
void f()
{
static_assert(getArgCount(n) > 0); // not ok, why?
}
};
int main()
{
int n;
s
浏览 0提问于2019-08-31得票数 12
回答已采纳
2回答
在标准文件P0092R1中，Howard Hinnant写道：
template <class To, class Rep, class Period,
class = enable_if_t<detail::is_duration<To>{}>>
constexpr
To floor(const duration<Rep, Period>& d)
{
To t = duration_cast<To>(d);
if (t > d)
--t;
return t;
浏览 0提问于2015-11-15得票数 8
我想在我的static_assert项目中使用C++11来做一些编译时检查。
据我理解，static_assert不会在运行时执行，对吗？
如果是这样的话，当我通过执行有关编译的命令(如gcc ... )来编译我的项目时，编译器会将static_assert构建到二进制文件中，或者static_assert将被完全忽略，就像注释一样？
浏览 12提问于2021-12-23得票数 0
回答已采纳
考虑以下代码：
constexpr const int A = 42;
const int &B = A;
static_assert(&A == &B, "Bug");
constexpr const int &C = B;
static_assert(&A == &C, "Bug");
int main() { return 0; }
它完全被clang版本3.3所接受，而g++ (SUSE ) 4.8.1 20130909 [gcc-4_8-分支修订202388拒绝了它，因为：
bug2.cpp:5:1
浏览 0提问于2014-03-05得票数 5
回答已采纳
我有一些类，我希望在编译时由需要某种级别验证的初始化器列表进行初始化。
我首先尝试了static_assert，但无法编译，错误为“静态断言的非常数条件”。
什么是导致构建错误的最好方法？
class foo {
public:
constexpr foo(std::initializer_list<bar> items) {
for(auto &&i: items) {
if(i == 12) // example validation logic
// fail the build
浏览 9提问于2020-02-21得票数 1
回答已采纳
在C++11 constexpr函数中，第二条语句(如assert() )是不可能的。static_assert()很好，但如果函数被调用为“normal”函数，则无法工作。逗号接线员可以来帮忙。assert()，但是很难看，有些工具会对它发出警告。
考虑一下这样的“getter”，它在断言之外是完全可靠的。但是我想为运行时和编译时间保留某种断言，但不能仅仅依赖于'constexpr‘上下文来重载。
template<int Size>
struct Array {
int m_vals[Size];
constexpr const int& getElem
浏览 1提问于2020-01-23得票数 9
回答已采纳
如何正确地在constexpr函数中执行static_assert？例如：
constexpr int do_something(int x)
{
static_assert(x > 0, "x must be > 0");
return x + 5;
}
这不是有效的C++11代码，因为常量表达式函数只能包含返回语句。我不认为标准对此有例外，尽管，GCC 4.7不允许我编译这段代码。
浏览 0提问于2011-12-25得票数 57
回答已采纳
我有以下代码：
#include <iostream>
template<int I>
class A
{
public:
inline constexpr static int size() { return I; }
};
template<typename T>
inline constexpr auto size(const T& arg) noexcept -> decltype(arg.size())
{
return arg.size();
}
template<typename T>
inline
浏览 0提问于2019-07-04得票数 1
回答已采纳
1回答
为什么在中，第一个调用不编译，第二个调用编译？
consteval auto foo(auto x) {
static_assert(x);
}
int main(){
foo(42); // error: non-constant condition for static assertion
foo([]{}); // OK
}
如果我正确理解，第一个是错误的，因为lvalue-rvalue转换不是一个常量表达式。为什么第二个没问题？
浏览 10提问于2022-09-17得票数 0
回答已采纳
请参考以下代码片段： #include <type_traits>
#include <string_view>
constexpr std::size_t strlen(char const* s) {
std::size_t n = 0;
while (*s++ != '\0')
++n;
return n;
}
template <std::size_t>
struct X {};
int main() {
constexpr auto pf = __PRETTY_FUNCTION
浏览 65提问于2019-04-25得票数 14
回答已采纳
鉴于以下结构：
struct ExampleStruct {
char firstMember[8];
uint64_t secondMember;
};
是否有一种方法可以编写静态断言来验证secondMember的偏移量是否为8个字节的倍数？
浏览 10提问于2016-10-07得票数 9
回答已采纳
1回答
好吧，这可能是个愚蠢的问题，但我完全不理解第12.1.6.2章-- c++编程语言的constexpr函数下的条件求值。这是整个非常简短的文本。
不计算条件表达式的分支，而该分支不被接受到constexpr函数中。这意味着未使用的分支可能需要运行时评估。例如：
返回(low<=i && i<high)？I:抛出out_of_range()；} constexpr = 0；constexpr = 99；// .常数int val = check(f(x，y，z))；
您可能会认为低和高是在编译时已知的配置参数，而不是在设计时知道的，而f(x，y，z)计算的是一些依赖
浏览 3提问于2014-09-30得票数 3
回答已采纳
我实现了这样一个constexpr数组：
template <typename T>
class const_array {
const T* p;
unsigned n;
public:
template <unsigned N>
constexpr const_array(const T(&a)[N]): p(a), n(N) { }
constexpr unsigned size() const { return n; }
};
int main(int argc, char* argv[]) {
// works
stat
浏览 9提问于2017-01-02得票数 14
回答已采纳
1回答
在dcl.conexpr/3 ()中，包含在“或不包含的复合语句”中意味着什么？
例如：
constexpr int f(bool b) {
return b ? ([]() { goto x; x: return 1; })() : 2;
}
int main() {}
构成f:s主体的复合语句不包含goto语句吗？
对于这个例子，我没有从Clang或GCC那里得到错误信息。
浏览 0提问于2015-07-25得票数 3
1回答
考虑以下方案：
#include <iostream>
#include <type_traits>
constexpr int f() {
if (std::is_constant_evaluated())
return -1;
else return 1;
}
int main() {
int const i = f();
std::cout << i;
}
It (魔盒)。
但是，如果在编译时计算函数时使函数throw：：
#include <iostream>
#include <type_traits
浏览 0提问于2019-09-06得票数 38
回答已采纳
这就是代码
#include<stdio.h>
#include<stdbool.h>
#define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))
struct my_struct {
int a, b;
// char c;
};
int main() {
bool cond = 1;
BUILD_BUG_ON((sizeof
浏览 1提问于2015-07-19得票数 5
1回答
N4527 5.20 expr.constp3
积分常量表达式是整数或非作用域枚举类型的表达式，隐式转换为prvalue，其中转换的表达式是核心常量表达式。
5.20 expr.constp5
常量表达式是一个glvalue核心常量表达式，其值指的是一个常数表达式的允许结果(如下所定义)，或者是一个prvalue核心常量表达式，其值是一个对象，对于该对象及其子对象：
(5.1) -每个非静态引用类型的数据成员都是一个实体，该实体是一个常数表达式的允许结果，以及
(5.2) -如果对象或子对象是指针类型的，则它包含具有静态存储持续时间的对象的地址、该对象结束后的地址(5.7)、函数的地
浏览 3提问于2015-07-20得票数 3
回答已采纳
我有一个常量表达式函数，如下所示：
constexpr int foo(int bar)
{
static_assert(bar>arbitrary_number, "Use a lower number please");
return something_const;
}
然而，用GCC 4.6.3编译这段代码总是告诉我
错误：'bar‘不能出现在常量表达式中
我试过这样的东西
constexpr int foo(constexpr const int bar)
{
static_assert(bar>arbitrary_number
浏览 1提问于2012-03-20得票数 9
回答已采纳
4回答
基于。
考虑以下代码
template<typename T, int N>
struct A {
typedef T value_type; // save T to value_type
static const int size = N; // save N to size
};
听着，我可以使用value_type和size作为模板参数。
typedef A<int, 2> A1;
typedef A<A1::value_type, A1::size + 3> A2; // OK, A2 is A<int,5>
现在，我想对指
浏览 3提问于2009-12-16得票数 5
我正在编写一个计算二项式系数的函数：binom(N, K)
我想检查在编译时N和K都是N >= K的无符号类型整数，但这有问题。
这是我的密码：
template <typename N>
concept Unsigned = std::is_unsigned_v<N>;
template <Unsigned U>
constexpr double binom(U N, U K) {
static_assert(N >= K);
double d = 1.0;
while (K) {
d *= stati
浏览 3提问于2020-03-31得票数 0
回答已采纳
4回答
我尝试过使用来执行静态断言，但是如果在模板的方法中使用它，则不会得到编译错误。
例子如下：
#include <iostream>
#define STATIC_ASSERT(expr, msg) \
{ \
char STATIC_ASSERTION__##msg[(expr)?1:-1]; \
(void)STATIC_ASSERTION__##msg[0]; \
}
template <typename T >
浏览 3提问于2013-01-31得票数 0
回答已采纳
当试图用static_assert作为参数计算逗号运算符时，编译失败
void fvoid() {}
int main() {
int a = (1, 2); // a=2
int b = (fvoid(), 3); // b=3
int d = ( , 5);
// ^
// error: expected primary-expression before ',' token. OK
int c = (static_assert(true), 4);
// ^~~~~~~~~~~~~
浏览 4提问于2016-11-17得票数 7
回答已采纳
1回答
在计算常量表达式以初始化constexpr时，可以抛出异常。例如，这里有一个例子，在这个例子中，常量表达式的计算被防止溢出：
#include <iostream>
#include <stdexcept>
constexpr int g(int n, int n0, int n1) {
return n == 0? n1: g(n - 1, n1, n0 + n1);
}
constexpr int f(int n) {
return n < 42? g(n, 0, 1): throw std::out_of_range("too b
浏览 2提问于2014-01-01得票数 15
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
