理解在C++中放松的内存顺序
在C++中，放松的内存顺序是指对于多线程程序中的内存访问操作，编译器和处理器可以对其进行重排序或优化，而不必遵循严格的顺序。
放松的内存顺序可以提高程序的性能，但也可能导致一些问题，如数据竞争和不确定的行为。为了解决这些问题，C++提供了一些内存顺序的约束，以确保多线程程序的正确性。
C++中的内存顺序可以分为以下几种：
- 顺序一致性（sequentially consistent）：所有的内存访问操作都按照程序中的顺序执行，不会发生重排序。这是最严格的内存顺序，保证了多线程程序的正确性，但性能较低。
- 获取-释放顺序（acquire-release）：获取操作保证在之后的所有读写操作中可见，释放操作保证在之前的所有读写操作中可见。这种内存顺序提供了一定的灵活性，可以在保证正确性的前提下提高性能。
- 松散顺序（relaxed）：所有的内存访问操作都可以进行重排序或优化，不需要遵循严格的顺序。这种内存顺序提供了最大的灵活性和性能，但也可能导致一些问题，需要开发者自行保证程序的正确性。
在实际应用中，放松的内存顺序可以用于一些无竞争的场景，例如对于只读数据的访问，或者在开发者能够保证正确性的情况下使用。但对于存在竞争条件的情况，建议使用获取-释放顺序或顺序一致性来保证程序的正确性。
腾讯云提供了一系列的云计算产品，包括云服务器、云数据库、云存储等，可以满足不同场景下的需求。具体产品介绍和相关链接可以参考腾讯云官方网站：https://cloud.tencent.com/
相关·内容
1回答
C++标准说，对atomics的RMW (读-修改-写)操作将对原子变量的最新值进行操作。因此，在这些操作中使用memory_order_relaxed不会影响从多个线程并发执行的RMW操作。
我假设只有在RMW操作中存在一些内存屏障或栅栏时，即使指定的内存顺序是“放松的”，这种行为才是可能的。如果我的理解是错误的，请纠正我，如果没有使用这样的内存屏障，请解释这些操作是如何在最新值上工作的。如果我的理解是正确的，那么我是否可以进一步假设使用获取释放或Seq内存顺序不应该对RMW操作有额外的性能影响，比如ARM或Alpha之类的弱有序体系结构。提前谢谢。
浏览 2提问于2017-11-06得票数 5
回答已采纳
1回答
放松排序作为信号
、、、
假设我们有两条线。一个给一个“开始”，一个等待一个尝试去生产一些东西。
这段代码是正确的，还是因为缓存之类的原因，我可以有一个“无限循环”？
std::atomic_bool canGo{false};
void producer() {
while(canGo.load(memory_order_relaxed) == false);
produce_data();
}
void launcher() {
canGo.store(true, memory_order_relaxed);
}
int main() {
thread a{producer};
浏览 1提问于2019-07-05得票数 5
回答已采纳
1回答
以下一节可以从汉斯·博姆( Hans )的上找到(据我所知，这是一篇非常好的文章)：
纯序列一致性问题
不幸的是，在所有情况下保证顺序一致的处决成本太高。例如，重新考虑上面的程序。大多数处理器实际上并不是在执行每个线程中的第二个语句之前等待初始赋值完成。初始赋值只会导致值1保存在存储缓冲区中，在存储缓冲区中等待复制到内存，但对另一个处理器还不可见。如果这两个线程要在不同的处理器上以锁定的方式执行，则很可能r1和r2都为零，因为x和y的读取发生在写入对另一个线程可见之前。
类似地，编译器通常以违反顺序一致性的方式转换代码。例如，如果我们的初始示例是大型程序的一部分，编译器可能决定将一个或两个r
浏览 1提问于2014-02-14得票数 0
回答已采纳
下面是一段在C++算法头文件中编写的c++代码。 bool binary_search(vector<int>::iterator first, vector<int>::iterator last, int val)
{
first = lower_bound(first, last, val);
return (first != last) && !(val < *first);
} 我可以理解这个binary_search函数是如何工作的，但是我不明白为什么它使用“!(val < *first)”而不是(val ==
浏览 23提问于2020-07-03得票数 2
回答已采纳
我想我很了解C++原子库中各种C++标志的语义。
但是，我对以下情况感到困惑：
假设我们有两个线程--线程A (“主执行”线程)和线程B (线程B)，线程B是线程池的一部分，可以调度和运行任务。
如果我使用std::memory_order_acq_rel执行“读-写-更新”原子操作，那么对布尔变量执行非原子写入，其他线程会立即看到非原子写入吗？我认为答案是否定的，除非其他线程也访问执行“读-写-更新”操作的原子变量。
例如，给定一个全局std::atomic_flag变量X、一个全局bool值B和一个具有成员函数dispatch的线程池对象THREADPOOL，该对象将在另一个线程中执行任意
浏览 0提问于2015-06-29得票数 0
回答已采纳
嗨，我正在尝试理解无锁工作窃取出队的实现。目前，我正在阅读谷歌的filament here的一个实现。我最关心的是偷窃行动。 template <typename TYPE, size_t COUNT>
TYPE WorkStealingDequeue<TYPE, COUNT>::steal() noexcept {
do {
// mTop must be read before mBottom
int32_t top = mTop.load(std::memory_order_seq_cst);
// mB
浏览 37提问于2019-05-19得票数 0
1回答
我只是在练习理解C中的动态分配，我得到了一个分割错误错误。我不知道我在哪里弄错了。
int wordcount = 5;
char **args = (char**)malloc(wordcount * sizeof(char*));
for ( int i = 0; i < wordcount; i++) {
args[i] = (char*)malloc(167 * sizeof(char));
}
int c=0;
while(c < wordcount){
strcpy("hello\n", args[c]);
c++;
}
浏览 0提问于2018-05-19得票数 0
回答已采纳
我有一个包装文件，它将一个JSON文件读入字典。我使用os.system("command")命令在这个python文件中运行C++代码。C++代码接受命令行输入，这些输入是解析字典中的键值。
如何使用指令将变量作为C++代码的命令行输入传递？
浏览 2提问于2015-04-24得票数 1
回答已采纳
在C++中，我假定C++标准与如何在类中安排数据成员无关，就内存布局而言？我是否正确地认为，这取决于编译器的问题？
我非常感兴趣地学习对象和其他C++实体(structs等)是如何在物理内存中表示的(我知道列表是节点到节点，数组是连续内存--但是语言的所有其他方面)。
编辑:学习x86汇编程序有助于更好地理解C++吗？
浏览 3提问于2012-10-14得票数 3
回答已采纳
我读过GCC Wiki的关于C++的记忆障碍(以及它的棒极了)。
在我谈到这一点之前，我非常直截了当地说：
相反的方法是std::memory_order_relaxed。该模型通过消除发生前的限制，允许更少的同步。这些类型的原子操作还可以对它们执行各种优化，例如死存储删除和共用。所以在前面的例子中：
-Thread 1-
y.store (20, memory_order_relaxed)
x.store (10, memory_order_relaxed)
-Thread 2-
if (x.load (memory_order_relaxed) == 10)
{
assert
浏览 3提问于2020-10-12得票数 5
回答已采纳
2回答
C++多重继承顺序
、、、
我正在尝试理解继承顺序在C++中的影响。我在网上看了看，但我找不到一个明确而充分的答案……
因此，为了解决这个问题，假设有两个类:B类和C类。
现在，定义：
class A1 : public B, public C{ ... };
class A2 : public C, public B{ ... };
A1和A2有什么区别？
非常感谢!
浏览 0提问于2013-06-27得票数 27
回答已采纳
3回答
堆栈上的C数组
、、
在c(和c++)中，可以通过以下方式创建整数数组：
int a[const];
其中，const是编译时常量，或
int *a = (int *) malloc(...);
根据我的理解，第一个在堆栈上分配内存，第二个在堆上分配。现在，据我所知，堆栈上的内存是有序的，这样程序就可以根据需要弹出它。这意味着数组中的元素不一定按顺序存储，这听起来很奇怪。
这里到底发生了什么？
编辑：
谢谢各位的回复。随着你的回答和谷歌的一些跟进，我发现了我困惑的根源。我假设程序实际上只使用堆栈的顶部变量，然后一个接一个地打开/关闭它们。
浏览 0提问于2017-12-25得票数 0
回答已采纳
我在看赫伯·萨特的演讲：
看看两个例子(大约1:15马克)，一个对我来说是有意义的，而另一个则没有意义。
第一个示例(很有意义)：
注count是一个原子int。
在这里，使用轻松的内存排序被认为是正常的，因为线程退出发生在线程上的联接返回之前。这意味着放松的添加发生在放松负荷之前。
子线程：
while (...) {
if (...) {
count.fetch_add(1, memory_order_relaxed);
}
}
主螺纹：
int main() {
launch_workers();
join_workers();
cout << c
浏览 2提问于2020-10-16得票数 3
回答已采纳
4回答
内存模型与并发性
、、、、
我想知道C/C++内存模型，但我在所有文章、博客、youtube视频中都发现，“内存模型只需要并发性”。
有谁能向我解释一下为什么会这样？
我理解内存模型是一种抽象，允许程序员使用编程语言对底层内存系统进行推理(对吗？)因此，一般来说(独立于编程语言)，我们不需要单线程程序的内存模型吗？
谢谢!
浏览 0提问于2018-08-18得票数 1
回答已采纳
3回答
假设我们有一个简单变量(std::atomic<int> var)和2个线程( T1和T2 )，我们有以下T1代码
...
var.store(2, mem_order);
...
对于T2
...
var.load(mem_order)
...
另外，假设T2(load)执行时间比T1(存储)晚123‘s(按照C++标准的修改顺序)。我对这种情况的理解如下(针对不同的内存顺序)：
memory_order_seq_cst - T2负载有义务加载2。因此，它必须有效地加载最新值(就像RMW操作一样)。
memory_order_acquire/memory_order_re
浏览 3提问于2015-06-11得票数 7
回答已采纳
3回答
请参阅从带来的以下代码，第12页：
using namespace std::experimental::parallel;
std::atomic<int> x = 0;
int a[] = {1,2};
for_each(par, std::begin(a), std::end(a), [&](int n) {
x.fetch_add(1, std::memory_order_relaxed);
// spin wait for another iteration to change the value of x
while (x.load(std::mem
浏览 5提问于2017-03-13得票数 3
回答已采纳
1回答
我目前正在将一个Windows C++库移植到MacOS作为一个业余项目，作为一种学习体验。我偶然发现了一些使用Win互锁*函数的代码，因此我一直试图阅读这个主题。
在这里阅读相关的问题，我理解有不同的方式来做这些操作取决于操作系统。在Windows中互锁*，在MacOS中使用OSAtomic*，我和我还发现编译器对此具有内置(内在)操作。
读完后，我想知道内在的和OSAtomic的区别是什么?或者是互锁的*--我的意思是，如果我使用gcc的话，就不能在OSAtomic*还是gcc内置的东西之间做出选择？如果我用gcc在Windows上的话，也是一样。
我还读到了Windows上的互锁*作为内
浏览 1提问于2011-01-11得票数 0
回答已采纳
我在代码中定义了这个结构： #[repr(align(4))]
struct MetaDataDefn {
cncVersion: i32,
toDriverBufferLength: i32,
toClientsBufferLength: i32,
counterMetadataBufferLength: i32,
counterValuesBuferLength: i32,
clientLivenessTimeout: i64,
startTimestamp: i64,
pid: i64
} 我有一个函数，它接受一个指向内存块的原始指针，其中第一个字节对应
浏览 26提问于2019-06-16得票数 0
回答已采纳
在阅读了我的系统编程演讲材料之后，我偶然发现了内存模型和缓存一致性协议的关键概念。虽然它们作为独立的概念是有意义的，但它们是如何结合在一起的还不是很清楚。具体来说，在查看x86时，我使用的是一个执行TSO内存模型的ISA，以及一个使用MESIF缓存一致性协议的CPU (在Intel的例子中)。
一开始，这位教授引入了缓存一致性协议，以确保对芯片中的任何核心来说，它们似乎都访问了一个大的、单一的内存块。然后，在结束缓存一致性之后，他继续使用内存模型，特别是TSO (我们已经在并行编程类中引入了线性化-/顺序一致性)。以下是直接引用有关x86记忆模型的讲座材料：
64位x86处理器标准
浏览 4提问于2019-12-15得票数 3
回答已采纳
1回答
两个矩阵的C++有效元向匹配
、、、、
我正在使用C++和特征库来完成匹配任务。然而，这一结果效率很低。下面将描述任务和我当前的解决方案。
任务
该任务涉及两个大小相同的大型地图，mapL和mapR。匹配过程按行顺序进行。例如，r-th行的mapL中的元素将与mapR的r-th行中的元素匹配。两个匹配元素的值可能不完全相同，因此我需要在mapR中查找差异最小的元素。
为了计算差异，我执行以下步骤：
mapL.Extract的r-th行、mapR.Subtract的r-th行、mapL).Repeat的元素行中的提取元素，对于mapL.中的每个元素，都执行上述步骤
示例
一个例子将有助于理解上述过程。假设我们有
mapL = [ 1
浏览 2提问于2020-09-23得票数 1
4回答
并发和内存模型
、、、
我正在看视频由Herb在GPGPU和新的C++ AMP库。他谈到了内存模型，提到了弱内存模型，然后提到了强内存模型，我认为他指的是读/写排序等，但我不确定。
Google发现了一些关于记忆模型的有趣的结果(主要是科学论文)，但是有人能解释什么是弱记忆模型，什么是强记忆模型，以及它们与并发性的关系吗？
浏览 0提问于2011-08-27得票数 8
2回答
我正在阅读 C++常见问题解答网站。在那里我看到了下面的台词。
避免使用void* (如果您真的需要它们，可以将它们保存在低级函数和数据结构中，并向用户提供类型安全的接口，通常是模板)。
为什么void*在C++中被认为不安全？
浏览 0提问于2018-09-01得票数 3
回答已采纳
我最近正在学习cppcoro项目的代码。我有个问题。
if (waiter->m_refCount.fetch_sub(1, std::memory_order_release) == 1) // #218
{
waiter->m_awaiter.resume();
}
在第218行使用memory_order_release写，使用memory_order_acquire标志的m_refCount可以正确地加载第284行中的值。这是可以的。但fetch_sub是一个RMW运算。要正确读取第284行中的修改，是否还需要一个memory_order_aquire标志？所以
浏览 4提问于2020-12-07得票数 1
回答已采纳
我正在开发一些“空闲RAM”工具，该工具必须强制windows向所有应用程序发送'LOW_MEMORY'信号(该工具要求所有应用程序释放其未使用的数据，SQL服务器和文件缓存将被清除，这样您将得到大量额外的空闲空间)。
在C++中做这件事的最佳方法是什么?对我来说，最“自然”的解决方案是分配大量内存，但这是一种“好的”和“稳定的”方式吗？也许在c++或其他地方有WinAPI的本机函数吗？
附注：这个工具的概念来自于(我知道更好的方法是.购买一些RAM，但我现在必须编写这样的工具)：
浏览 3提问于2013-10-24得票数 6
回答已采纳
6回答
如果我有一个类，其中包含分配在堆上的私有静态数据，而这个数据永远不会改变，那么我应该在什么时候删除它？
据我所知，类本身永远不会被构造(因为类在C++中不是第一类对象)，那么就没有析构函数来删除静态数据了吗？我是C++的新手，所以很抱歉，如果我对c++的理解存在根本性的缺陷，或者答案是显而易见的！先谢谢你，艾尔。
浏览 0提问于2011-07-28得票数 24
回答已采纳
4回答
使用4个线程获取/发布语义
、、、、
我目前正在阅读安东尼·威廉姆斯的“行动中的C++并发”。他的一个清单显示了这段代码，他说z != 0可以触发这个断言。
#include <atomic>
#include <thread>
#include <assert.h>
std::atomic<bool> x,y;
std::atomic<int> z;
void write_x()
{
x.store(true,std::memory_order_release);
}
void write_y()
{
y.store(true,std::memor
浏览 2提问于2018-01-22得票数 29
回答已采纳
4回答
特别是在非托管语言(例如C++、C)中，我的理解是对字长数据的读/写是原子的。如果是这样的话，为什么人们在多线程环境中的读/写过程中仍然锁定(通过互斥)字长数据？
浏览 0提问于2013-07-08得票数 3
在我写的关于C++的书中，我一直在阅读关于STL容器的内容，特别是关于STL及其容器的部分。现在我确实理解了它们中的每一个都有自己的特定属性，并且我即将记住所有这些属性……但我还不能理解的是，它们都用在哪种场景中。
解释是什么？最好使用示例代码。
浏览 69提问于2009-01-23得票数 203
回答已采纳
1回答
这些记忆屏障是必要的吗？
、、、
我遇到了Singleton的get_instance函数的以下实现：
template<typename T>
T* Singleton<T>::get_instance()
{
static std::unique_ptr<T> destroyer;
T* temp = s_instance.load(std::memory_order_relaxed);
std::atomic_thread_fence(std::memory_order_acquire);
if (temp == nullptr)
{
浏览 9提问于2022-03-28得票数 4
我试图理解x86-64机器上C++中的一致性保证，如果在其他平台上有差异的话。具体来说，我想知道，如果一个线程在下一个线程读取变量之前写入变量，那么我会始终看到正确的值吗？关于这件事我读过一些相互矛盾的信息。
下面是一个示例，其中Shared在另一个线程中被更新，结果只在我们确定值被更新完后才被读取。这个总是打印1吗？它每次我测试它，但我不能真正证明它的榜样。
#include <iostream>
#include <thread>
#include <atomic>
std::atomic<bool> Done {false};
int S
浏览 0提问于2019-09-11得票数 5
回答已采纳
2回答
C++以与源相同的顺序在内存中存储变量，这是一条普遍的规则吗？所以，如果我连续定义了很多4字节成员变量，在32位顺序和32位结构编译器中以不同的隐私将它们放入内存中的连续单词中？
浏览 8提问于2020-10-06得票数 1
回答已采纳
1回答
我会尽我所能把这件事弄清楚。如果有什么我可以澄清的，请告诉我。
我正在在线从数据库中的SQL表下载信息到电话。在LogCat中，我已经能够浏览表并查看我想要的所有信息。我想知道如何最好地保存在电话上的信息。我认为没有必要建立一个新的本地数据库。我是应该用在线数据库中的信息创建一个游标，还是将其存储在某种结构中？
数据不需要存储很长时间，当应用程序关闭时，丢失它是正常的。，我希望能够以列表格式从SQL表中的一个列中看到信息，然后单击它，在另一个活动中查看来自该项行的所有信息。我已经在应用程序的另一部分中这样做了，但是它使用的是来自本地电话数据库的数据。
以下是一些有助于澄清的代码：
Log.d(
浏览 0提问于2011-11-30得票数 1
回答已采纳
3回答
我正在处理一些C#和C++非托管代码，在处理内存时有两件事我不理解。如果有人能帮我理解：
如果在C# (使用new)下动态分配变量，然后将变量传递给C++非托管代码。用户是否需要在C++非托管代码下手动释放该变量内存？
如果一个变量是在C++非托管(使用new)下动态分配的，然后传递给C#，那么可以说垃圾收集器会释放该内存吗？
浏览 1提问于2017-07-27得票数 3
回答已采纳
4回答
我使用的是Mingw的C++，它是GNC C++的windows版本。
我想要做的是:将C++对象序列化为XML文件，并从XML文件中动态反序列化对象。我查看TinyXML。它非常有用，而且(如果我理解错误，请纠正我)它基本上是在处理过程中添加所有节点，最后使用TixmlDocument::saveToFile(filename)函数将它们放入一个块中的文件中。
我正在进行实时处理，如何动态地写入文件并将以下结果附加到文件中？
谢谢。
浏览 3提问于2009-09-04得票数 3
回答已采纳
在并行多核体系结构的基本原理中，由Yan编写的p304定义了顺序一致性存储模型：
总之，我们可以将程序员对内存访问顺序的隐含期望表达为:从处理器中产生的内存访问应该按照程序顺序执行，并且每个访问都应该以原子方式执行。这种期望被正式定义为序贯一致性(SC)模型。以下是Lamport 37关于顺序一致性的S定义:如果任何执行的结果相同，好像所有处理器的操作都是以某种顺序顺序执行，并且每个处理器的操作按其程序指定的顺序进行，则多处理器是顺序一致的。
在p303上将内存访问的原子性定义为
一种期望，即每个内存访问都在瞬间进行，而不与其他内存访问重叠。在本例中，期望假设当进程P0写入共享变量x时，写入立
浏览 0提问于2021-02-09得票数 2
我正在将C++代码移植到C#中，我在C++代码中看到了这一点，
SHELLEXECUTEINFO shell;
memset(&shell, 0, sizeof(shell));
//the properties in shell are set
ShellExecuteEx(&shell);
所以现在我使用Process.Start()和ProcessStartInfo作为C#代码。我是否必须为ProcessStartInfo分配内存，还是在调用ProcessStartInfo构造函数时为我分配内存？为了满足我的好奇心，这种在C++中使用C++的方式是一种非托管语言的实践，还
浏览 6提问于2016-11-16得票数 2
回答已采纳
5回答
在C++中，我认为处理重新分配的一个更好的方法是使用STL向量，因为它保证连续存储位置。
我有几个问题要理解其中的区别：
在什么情况下，我需要更喜欢而不是向量？
还有什么东西(除了向量)与在C++中等价吗？
谢谢,
浏览 5提问于2009-04-15得票数 8
回答已采纳
我一直在研究C++ 11中的内存顺序语义，并且很难理解memory_order_acquire在CPU级别上是如何工作的。
根据偏好；
具有此内存顺序的load操作对受影响的内存位置执行获取操作:在此加载之前，不能对当前线程中的任何读或写进行重新排序。释放相同原子变量的其他线程中的所有写入在当前线程中都是可见的(请参见下面的版本-获取排序)。
我真正无法理解的部分是；
在此加载之前，不能对当前线程中的读或写进行重新排序。
如果CPU在到达“memory_order_acquire”部分之前已经重新排序命令，会发生什么情况？CPU是否恢复了已经完成的所有工作？如何保证这一点？
谢
浏览 2提问于2018-08-16得票数 0
回答已采纳
众所周知，当我们只使用一个原子变量来存储或加载 (： )时，就可以使用发布获取排序的。
但是，对于其他基本的无等待函数(例如:加法、减法、增量和递减)，这是正确的吗？
也就是说，对于弱的(arm-cpu，.)，next()函数在下面的C++代码中是否是安全的和强大(x86-cpu，.)内存模型，还是需要另一个障碍排序(较低/更高)？
#include <iostream>
#include <atomic>
using namespace std;
class progression_lf {
public:
progression_lf() : n(0) {}
浏览 3提问于2015-08-07得票数 2
回答已采纳
我的理解是，在C/C++中，按位运算符应该是与字节顺序无关的，并且按照您期望的方式运行。我希望确保我真正从64位值中获得最重要和最不重要的单词，而不用担心机器的字节顺序。下面是一个例子：
uint64_t temp;
uint32_t msw, lsw;
msw = (temp & 0xFFFFFFFF00000000) >> 32;
lsw = temp & 0x00000000FFFFFFFF;
这样行得通吗？
浏览 3提问于2010-02-04得票数 12
回答已采纳
1回答
如何存储类属性/字段
、、、、
我知道这个C++类的一个实例：
class A {
char c;
int iiii;
short ss;
};
在内存中是这样的：c| | | |i|i|i|i|s|s| | |
这个4/2的字母注释没有任何意义(但我认为我的观点很清楚)
1 byte for char，3 bytes of padding，4 bytes of int，2 bytes for the short和2 bytes of tail padding (平台依赖者，但它不会改变逻辑)
从C++标准(编译器不会更改示例中字段的顺序)：
分配具有相同访问控制(第11条)的(非联合)类的非静态数
浏览 2提问于2015-07-21得票数 8
回答已采纳
我一直在学习有效的C++，Meyer在其中一条准则中提到，如果我们在一个翻译单元中声明一个非本地静态对象，并在另一个翻译单元中定义它的定义，那么它会导致未定义的行为。通过编写一个返回对本地静态对象的引用的函数来解决此问题。
我的问题是：
本地静态对象如何管理各种翻译单元的编译？
编译器如何知道首先执行哪个转换单元？
如果以不正确的方式问这个问题，我很抱歉。我希望你能理解我的意思。
浏览 7提问于2015-07-05得票数 2
回答已采纳
4回答
我正在努力学习更多关于C++的知识，我在一个国际象棋程序中遇到了一些需要帮助理解的代码。我有一个像这样的联盟：
union b_union {
Bitboard b;
struct {
#if defined (BIGENDIAN)
uint32_t h;
uint32_t l;
#else
uint32_t l;
uint32_t h;
#endif
} dw;
};
上面的代码属于else条件。
Bitboard被定义为uint64_t。如果我有一个值，假设0x0025f780
浏览 2提问于2011-11-02得票数 1
回答已采纳
3回答
我在C++11中有一些与内存模型相关的问题。
29号在上。幻灯片是写的
C++内存模型保证了顺序一致性
但是，在我之前的文章中，我了解到C++内存有弱内存模型--编译器可以根据自己的意愿重新排序--他必须满足得就像规则一样。
浏览 9提问于2016-07-17得票数 9
回答已采纳
我目前正在学习有关web程序集，使用C++和emscripten工具链。我理解内存是如何与C++中的堆栈和堆一起工作的，而且web程序集使用的是最大大小为4GB (或浏览器允许的任何东西)的连续内存缓冲区。web程序集中的C++中是否有用于在堆栈上分配数据的最大大小，它是否与最大内存大小不同。例如，我是否可以在堆栈上分配C++中的所有数据，并能够使用最大内存，或者是否应该在堆上分配数据，并自己管理(使用智能指针)？
浏览 0提问于2019-02-06得票数 1
回答已采纳
在我的理解中，在Rcpp和C++之间转换向量会创建新的向量，如下所示。我的理解正确吗？
在将Rcpp向量转换为C++向量时，我们使用Rcpp::as<T>() (例如，Rcpp::as<std::string>表示Rcpp::CharacterVector)。将创建std::vector<std::string>，并将原始Rcpp元素作为std::string复制到C++矢量中。这意味着修改新创建的C++向量元素不会影响原始的Rcpp向量元素。
在将C++向量转换为Rcpp向量时，我们使用Rcpp::wrap()。创建具有相应类型的Rcpp向量，并将C++元
浏览 20提问于2019-10-27得票数 3
回答已采纳
3回答
在研究C++项目时，我遇到了C++的new操作符的一种奇怪用法：
int arr[5];
ClassA* a = new(arr) ClassA();
你能帮我理解一下这个语法吗？
浏览 2提问于2013-11-04得票数 6
into_inner()是否返回此示例程序中所有轻松的写操作？如果是的话，是哪个概念保证了这一点？
extern crate crossbeam;
use std::sync::atomic::{AtomicUsize, Ordering};
fn main() {
let thread_count = 10;
let increments_per_thread = 100000;
let i = AtomicUsize::new(0);
crossbeam::scope(|scope| {
for _ in 0..thread_count
浏览 8提问于2017-10-16得票数 4
回答已采纳
3回答
我在许多文献中都提到C/C++中的volatile很弱，在多处理器的并发环境中可能会出现问题，但它(volatile)可以作为C#/Java中不同CPU之间的通信机制。这个关键字似乎在C#/Java中比在C/C++中更严格，但它们之间的区别/影响是什么？
下面是C/C++中volatile的一个引用。
浏览 6提问于2013-11-12得票数 15
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
