我正在开发一个使用C++并使用Linux GNU C Compiler编译的应用程序.但是,我想调用一个函数,因为用户使用CtrlC 键来中断脚本.我该怎么办？任何答案将不胜感激.
我不能想到在规范中也有尾调用优化的真正的RAII语言,但我知道许多C++实现可以作为特定于实现的优化来实现.
这给那些那些实现了一个问题:因为析构函数,并在自动变量的作用域结束时被调用不是由一个单独的垃圾收集例程,是不是违反TCO的约束,递归调用必须在最后的指令功能结束？
例如:-
#include <iostream>
class test_object {
public:
test_object() { std::cout << "Constructing...\n"; }
~test_object() { std::cout << "Destructing...\n"; }
};
void test_function(int count);
int main()
{
test_function(999);
}
void test_function(int count)
{
if (!count) return;
test_object obj;
test_function(count - 1);
}
"构建......"将写入999次,然后"破坏......"再写999次.最终,test_object在展开之前将自动分配999个实例.但假设一个实现有TCO,那么1000个堆栈帧是存在还是仅存在1？
递归调用之后的析构函数是否与事实上的TCO实现要求相冲突？
C++11 引入了一种新的内存模型，让“运行”C++11 代码的抽象机器有关于多线程的概念。它还引入了一组内存顺序，内存加载/存储操作遵循这些顺序。
C++20 的维基百科页面说它有
修改后的内存模型。
它给出的参考资料说 C++11 的内存模型有许多缺陷，C++20 将对其进行修改。
有人可以举例说明 C++11 的内存模型带来的问题，以及 C++20 中的问题如何解决吗？
相关问题： C++11的内存模型介绍
我正在解决在给定数组中找到不同整数的数量的基本问题。
我的想法是声明一个std::unordered_set，将所有给定的整数插入到集合中，然后输出集合的大小。这是我实现此策略的代码：
#include <iostream>
#include <fstream>
#include <cmath>
#include <algorithm>
#include <vector>
#include <unordered_set>
using namespace std;
int main()
{
int N;
cin >> N;
int input;
unordered_set <int> S;
for(int i = 0; i < N; ++i){
cin >> input;
S.insert(input);
}
cout << S.size() << endl;
return 0;
}
这种策略几乎适用于所有输入。在其他输入情况下，它超时。
我很好奇我的程序为什么会超时，所以我cout << i << endl;在 for 循环中添加了一行。我发现当我进入输入案例时，53000循环的第一次左右迭代几乎会立即通过，但之后100每秒只会发生几次迭代。
我已经阅读了O(N)如果发生大量冲突，散列集如何以插入结束，所以我认为输入在std::unordered_set.
然而，这是不可能的。std::unordered_set用于整数的哈希函数将它们映射到自身（至少在我的计算机上），因此不同整数之间不会发生冲突。我使用写在这个链接上的代码访问了哈希函数。
我的问题是，输入本身是否有可能 …
我正在寻找一种方法来检测模板类是否具有方法begin,end和resize.
我尝试了这个答案的修改版本：
#include <iostream>
#include <vector>
// SFINAE test
template <typename T>
class has_method
{
typedef char one;
struct two { char x[2]; };
template <typename C> static one test( decltype(&C::begin) ) ;
template <typename C> static two test(...);
public:
enum { value = sizeof(test<T>(0)) == sizeof(char) };
};
int main(int argc, char *argv[])
{
std::cout << has_method<std::vector<int>>::value << std::endl;
return 0;
}
然而，这会打印 0。有趣的是，这将适用于cbeginandcend但不适用于begin, end …
该标准定义了几个“发生在之前”关系，这些关系将古老的“之前排序”扩展到多个线程：
\n\n\n
[intro.races]11 评估 A简单地发生在评估 B 之前，如果
\n(11.1) \xe2\x80\x94 A 在 B 之前排序，或者
\n
\n(11.2) \xe2\x80\x94 A 与 B 同步，或者
\n(11.3) \xe2\x80\x94 A 只是发生在 X 之前，并且X 只是发生在 B 之前。[注10：在没有消耗操作的情况下，发生在之前和简单发生在关系之前是相同的。\xe2\x80\x94 尾注]
\n12 评估 A强烈发生在评估 D 之前，如果：
\n(12.1) \xe2\x80\x94 A 在 D 之前排序，或者
\n(12.2) \xe2\x80\x94 A 与 D 同步，并且 A 和 D 都是顺序一致的原子操作\n([atomics.order] )，或
\n(12.3) \xe2\x80\x94 存在评估 B 和 C，使得 A 在 B 之前排序，B 仅发生在 C 之前，并且 C 在 D 之前排序，或者 …
适用于类的语法不适用于概念：
template <class Type>
concept C = requires(Type t) {
// ...
};
template <class Type>
concept C<Type*> = requires(Type t) {
// ...
};
MSVC 对于“专业化”行的说法是：error C7606: 'C': concept cannot be explicitly instantiated, explicitly specialized or partially specialized。
为什么概念不能专门化？有理论上的原因吗？
我有一个偶数大小的向量，我想将其转换为成对的向量，其中每对始终包含两个元素。我知道我可以使用简单的循环来做到这一点，但我想知道是否有一个很好的标准库工具可以做到这一点？可以假设原始向量始终包含偶数个元素。
例子：
vector<int> origin {1, 2, 3, 4, 5, 6, 7, 8};
vector<pair<int, int>> goal { {1, 2}, {3, 4}, {5, 6}, {7, 8} };
在此代码中，
template<class T, class U>
concept always_true = true;
template<class T>
concept always_true_if_tagged = always_true<T, typename T::tag>;
struct A {
using tag = int;
};
static_assert(always_true_if_tagged<A>);
static_assert(!always_true_if_tagged<int>); //GCC says this failed
GCC 表示第二个断言失败。Clang 和 MSVC 都同意编译它。
我最初认为它是不正确的，不需要诊断，因为temp.constr.normal#1.4
概念 ID 的范式
C<A1, A2, ..., An>是 的约束表达式的范式C，在替换A1, A2, ..., An每个C原子约束中的参数映射中的各自模板参数后。如果任何此类替换导致无效类型或表达式，则该程序格式错误；无需诊断。
替换T::typename tag是 的参数映射always_true，因此格式错误；无需诊断。
所以我的前两个问题是
解决方案之一是检查之前的嵌套类型名。所以参数映射always_true不会发生。
template<class T>
concept always_true_if_tagged =
requires …我在 Ubuntu 20.04 LTS 上使用 clang++ 10，-fsanitize-undefined-trap-on-error -fsanitize=address,undefined,nullability,implicit-integer-truncation,implicit-integer-arithmetic-value-change,implicit-conversion,integer
我的代码正在生成随机字节
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<uint8_t> dd(0, 255);
...
ch = uint8_t(dd(gen));
最后一行导致消毒程序报告未定义的行为位于bits/random.tcc中
template<...> void mersenne_twister_engine<...>::
_M_gen_rand(void) {
const _UIntType __upper_mask = (~_UIntType()) << __r;
const _UIntType __lower_mask = ~__upper_mask;
for (size_t __k = 0; __k < (__n - __m); ++__k)
{
_UIntType __y = ((_M_x[__k] & __upper_mask)
| (_M_x[__k + 1] & __lower_mask));
_M_x[__k] = (_M_x[__k + __m] ^ (__y >> 1)
^ ((__y & 0x01) ? __a : 0)); …