Questions tagged «c++»

我正在尝试了解以下代码片段 片段1 template <typename T> struct A { static constexpr int VB = T::VD; }; struct B : A<B> { }; gcc9和clang9都不会在此处引发错误。 问：为什么要编译此代码？A<B>从B继承时，我们不是实例化吗？B中没有VD，因此编译器不应该在这里抛出错误吗？ 片段2 template <typename T> struct A { static constexpr auto AB = T::AD; // <- No member named AD in B }; struct B : A<B> { …

9 c++  templates  language-lawyer 

说我有一个看起来像这样的类（这只是一个例子）： class A { double *ptr; public: A() : ptr( new double[100] ) {} A( const A &other ) { other.ptr[7] = 15; } void doNotChangeMyData() const { ptr[43] = 14; } void changeMyData() { ptr[43] = 14; } ~A() { delete[] ptr; } }; 该const在拷贝构造函数和两个doNotChangeMyData功能让这个ptr不能改变的; 但是，这仍然允许我修改指向的数组的内容ptr。 有没有一种方法可以防止仅ptr在const实例中更改数组的内容，而不能“小心”（或远离原始指针）？ 我知道我可以做类似的事情 void …

9 c++  const 

我正在与一位同事讨论关于lock_guard的问题，他提出lock_guard可能比Mutex :: lock（）/ Mutex :: unlock（）慢一些，原因是实例化和取消了类lock_guard的成本。 然后，我创建了一个简单的测试，令人惊讶的是，使用lock_guard的版本几乎比使用互斥锁:: lock（）/互斥锁:: unlock（）的版本快两倍。 #include <iostream> #include <mutex> #include <chrono> std::mutex m; int g = 0; void func1() { m.lock(); g++; m.unlock(); } void func2() { std::lock_guard<std::mutex> lock(m); g++; } int main() { auto t = std::chrono::system_clock::now(); for (int i = 0; i < 1000000; …

9 c++  mutex 

我知道它std::array是完全分配在堆栈中的，但是这个问题是由需要考虑两点的安全问题引起的： 输入的数据在std::array销毁时将归零或随机化 输入中的数据std::array将被锁定，因此无论是崩溃还是交换内存，它都不会进入磁盘 通常情况下，用std::vector的解决方案是创建一个自定义分配器的是做这些事情。但是，对于std::array，我没有看到如何执行此操作，因此也没有看到这个问题。 我能做的最好的事情是： template <typename T, std::size_t Size> struct SecureArray : public std::array<T, Size> { static_assert(std::is_pod<T>::value, "Only POD types allowed") static_assert(sizeof(T) == 1, "Only 1-byte types allowed") virtual ~SecureArray() { std::vector<uint8_t> d = RandomBytes(Size); // generates Size random bytes std::memcpy(this->data(), d.data(), Size); } } 但这显然缺少内存锁定，std::array这使首先要使用的性能方案变得复杂std::array。 有更好的解决方案吗？

9 c++  arrays  c++11  cryptography  allocator 

分配： 将以下自然语言表达式转换为C ++表达式。假定所有变量都是非负数或布尔值（值为true或false）。 自然语言： a和b都为假，或者c为真，但不是两个都为真。 我的解决方案： (a==0 && b==0)xor(c==1) 教授的解决方案： (!a && !b) != c 问题： 我认为我稍微理解了第一个括号，通过说“ not-a”和“ not-b”，我认为a和b一定是错误的，只要ab在开始时就假定为非零。对？ 但是说“不等于c”的部分呢？ 我不了解教授的解决方案，有人可以为我分解一下吗？ 感谢您的帮助！

9 c++  logic 

在C ++草案标准中多次使用“强烈发生于”这一短语。 例如：终止 [basic.start.term] / 5 如果具有静态存储持续时间的对象的初始化强烈发生在对std :: atexit的调用之前（请参见[support.start.term]），则对该函数的调用将传递给std :: atexit在调用对象的析构函数之前进行排序。如果对std :: atexit的调用强烈发生在具有静态存储持续时间的对象的初始化完成之前，则在调用传递给std :: atexit的函数之前对对象的析构函数的调用进行排序。如果对std :: atexit的调用在另一次对std :: atexit的调用之前强烈发生，则传递给第二个std :: atexit的函数的调用在传递给第二个std :: atexit的函数之前被排序。第一个std :: atexit调用。 并在 数据竞赛 [intro.races] / 12中定义 评估A发生在评估D之前，如果发生以下情况之一 （12.1）A在D之前排序，或 （12.2）A与D同步，并且A和D都是顺序​​一致的原子操作（[atomics.order]），或 （12.3）对B和C进行求值，使得A在B之前排序，B仅发生在C之前，而C在D之前排序，或者 （12.4）有一个评估B，使得A强烈发生在B之前，而B强烈发生在D之前。 [注意：非正式地，如果A强烈地发生在B之前，那么在所有情况下A似乎都在B之前被评估。强烈发生在排除消耗操作之前。—尾注] 为什么引入“强烈发生”？直觉上，它与“之前发生的事情”有什么区别和关系？ 注释中的“在所有情况下，似乎A在B之前都被评估”是什么意思？ （注意：此问题的动机是Peter Cordes在此答案下的评论。） 标准报价附加草案（感谢Peter Cordes） 有序性和一致性[atomics.order] / 4 所有memory_order :: seq_cst操作（包括篱笆）上都有一个总顺序S，它满足以下约束。首先，如果A和B是memory_order ::: seq_cst运算，并且A强烈地发生在B之前，那么A在S中先于B.其次，对于对象M上的每对原子操作A和B，A的相干性在B之前，S必须满足以下四个条件： …

9 c++  multithreading  language-lawyer  memory-model  happens-before 

在https://docs.microsoft.com/zh-cn/cpp/parallel/concrt/reference/concurrent-vector-class?view=vs-2019#push_back中，push_back，begin，end被描述为并发安全 但是下面的代码是断言的。可能是因为元素已添加但尚未初始化。 struct MyData { explicit MyData() { memset(arr, 0xA5, sizeof arr); } std::uint8_t arr[1024]; }; struct MyVec { concurrency::concurrent_vector<MyData> v; }; auto vector_pushback(MyVec &vec) -> void { vec.v.push_back(MyData{}); } auto vector_loop(MyVec &vec) -> void { MyData myData; for (auto it = vec.v.begin(); it != vec.v.end(); ++it) { auto res …

9 c++  concurrency  concurrent-vector 

从功能和语法上来说，原型为int foo(void)和的函数之间是否有区别int foo(void *)？ 我知道，例如之间的差异，int bar(int)以及int bar(int *)-其中之一是寻找一个int，另一种是找一个int指针。void行为是否相同？

9 c++  c  function-prototypes 

谁能告诉我std :: atomic :: is_lock_free（）是否像constexpr一样不是静态的？使它为非静态和/或为非constexpr对我来说没有意义。

9 c++  multithreading  std  lock-free  stdatomic 

我正在为Linux使用Flutter Desktop。我正在调用一个方法MarkTextureFrameAvailable，应该标记要由引擎重新渲染的纹理。由于我正在为视频播放器编程，因此需要MarkTextureFrameAvailable从播放器的线程中进行调用。问题是引擎迫使我MarkTextureFrameAvailable从创建引擎的线程中调用（以及其他任何引擎方法）。 您可以看到所有对引擎的调用最终都在外壳程序中，该外壳程序始终进行检查以查看这些调用是否由创建该调用的同一线程进行： task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread() （ https://github.com/flutter/engine/blob/master/shell/common/shell.cc#L838） 这就是我创建颤振引擎的方式： int main(int argc, char **argv) { //.. flutter::FlutterWindowController flutter_controller(icu_data_path); // Start the engine. if (!flutter_controller.CreateWindow(800, 600, "Flutter WebRTC Demo", assets_path, arguments)) { return EXIT_FAILURE; } // Register any native plugins. FlutterWebRTCPluginRegisterWithRegistrar( flutter_controller.GetRegistrarForPlugin("FlutterWebRTCPlugin")); // Run until the window is closed. flutter_controller.RunEventLoop(); return EXIT_SUCCESS; } …

9 c++  multithreading  flutter 

前提：我正在使用甚至没有C ++ 11（带有std::atomic<int>）的ARM嵌入式（几乎是裸机）环境，因此请避免回答“ 仅使用标准C ++”std::atomic<int> ”：我不能。 这个AtomicInt的ARM 实现正确吗？（假设ARM体系结构是ARMv7-A） 您看到一些同步问题吗？是否volatile需要/有用？ // File: atomic_int.h #ifndef ATOMIC_INT_H_ #define ATOMIC_INT_H_ #include <stdint.h> class AtomicInt { public: AtomicInt(int32_t init = 0) : atom(init) { } ~AtomicInt() {} int32_t add(int32_t value); // Implement 'add' method in platform-specific file int32_t sub(int32_t value) { return add(-value); } int32_t …

9 c++  arm  embedded  atomic  volatile 

我有一个列表，希望不同的线程从中获取元素。为了避免在列表为空时锁定保护该列表的互斥锁，请empty()在锁定之前进行检查。 如果对电话的呼叫在list::empty()100％的时间内都不正确，则可以。我只想避免崩溃或中断并发list::push()和list::pop()调用。 我是否可以肯定地认为VC ++和Gnu GCC有时只会empty()出错并且没有比这更糟的了？ if(list.empty() == false){ // unprotected by mutex, okay if incorrect sometimes mutex.lock(); if(list.empty() == false){ // check again while locked to be certain element = list.back(); list.pop_back(); } mutex.unlock(); }

9 c++  multithreading  optimization  race-condition  stdlist 

我试图理解/阐明将捕获传递给lambda时生成的代码，尤其是在C ++ 14中添加的广义init捕获中。 提供下面列出的以下代码示例，这是我目前对编译器将生成的内容的理解。 情况1：按值捕获/默认值捕获 int x = 6; auto lambda = [x]() { std::cout << x << std::endl; }; 等于： class __some_compiler_generated_name { public: __some_compiler_generated_name(int x) : __x{x}{} void operator()() const { std::cout << __x << std::endl;} private: int __x; }; 因此，存在多个副本，一个副本要复制到构造函数参数中，而另一个副本要复制到成员中，这对于矢量等类型而言将是昂贵的。 情况2：按引用捕获/默认按引用捕获 int x = 6; auto lambda …

9 c++  lambda  c++14  move