blocks|key|5411465|text|看到一些其他的答案，似乎许多C%2B%2B程序员甚至不知道您所问的“内存模型”是什么意思。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5411466|从某种意义上讲，问题是关于内存模型:关于写/读重新排序(可能发生在编译器端或运行时端)有什么保证(如果有)？这个问题对于多线程编程非常重要，因为如果没有这样的规则，编写正确的多线程程序是不可能的，有些令人惊讶的事实是，由于目前缺乏显式的内存模型，许多多线程程序或多或少都是“靠运气”--最常见的是由于编译器假设了函数调用中的指针别名。-请参阅|5411467|在当前的C%2B%2B中，没有标准的内存模型。一些编译器定义了易失性变量的内存模型，但这是非标准的。C%2B%2B0x为此定义了新的“原子”原语。有关检查最新状态的详尽起点，请访问Threads+and+memory+model+for+C%2B%2B|offset|length|5411468|重要的链接还包括Concurrency+memory+model、Atomic+Types和C%2B%2B+Data-Dependency+Ordering:+Atomics+and+Memory+Model标准提案。|5411469|entityMap|0|LINK|mutability|MUTABLE|url|http://www.hpl.hp.com/personal/Hans_Boehm/c%2B%2Bmm/|1|http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2429.htm|2|http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html|3^0|0|0|2A|W|0|0|8|O|1|X|C|2|1A|1I|3|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@$F|Z|G|10|1|11]]|A|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@$F|13|G|14|1|15]|$F|16|G|17|1|18]|$F|19|G|1A|1|1B]]|A|$]]|$1|J|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]|R|$5|M|N|O|A|$P|S]]|T|$5|M|N|O|A|$P|U]]|V|$5|M|N|O|A|$P|U]]]]

Seeing some other answers, it seems many C++ programmers are not even aware what the "memory model" you are asking about means.

The questions is about memory model in the sense: what guarantees (if any) are there about write / read reordering (which may happen on the compiler side or on the runtime side)? This question is very important for multithreaded programming, as without such rules writing correct multithread programs is not possible, and somewhat surprising truth is with current lack of explicit memory model many multithreaded programs work more or less "by sheer luck" - most often thanks to compilers assuming pointer aliasing across function calls. - see <a href="http://www.hpl.hp.com/techreports/2004/HPL-2004-209.html" rel="noreferrer">Threads Cannot be Implemented as a Library</a>

In current C++ there is no standard memory model. Some compilers define memory model for volatile variables, but this is nonstandard. C++0x defines new "atomic" primitives for this purpose. Exhaustive starting point to check what recent status is can be found at <a href="http://www.hpl.hp.com/personal/Hans_Boehm/c++mm/" rel="noreferrer">Threads and memory model for C++</a>

Important links are also <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2429.htm" rel="noreferrer">Concurrency memory model</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html" rel="noreferrer">Atomic Types</a> and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html" rel="noreferrer">C++ Data-Dependency Ordering: Atomics and Memory Model</a> standard proposals.

blocks|key|4000207|text|不幸的是，在C%2B%2B中没有像Java语言那样的“标准内存模型”。实际的实现留给了编译器、运行时库和处理器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4000208|因此，C%2B%2B内存模型==混杂的模型，这意味着您总是必须尝试编写不依赖于特定内存模型的安全代码，这也适用于线程编程，因为编译器可以在临界区之外执行任何它想要的优化，甚至是无序处理！|4000209|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Unfortunately in C++ there is no "Standard Memory Model" like that of Java. The actual implementation is left up to the compiler, runtime libraries and processors. 

Thus the C++ memory model == chaotic mix-mash of models, which means you always have to try to write safe code that doesn't depend on a specific memory model, and that goes for threaded programming as well, because the compiler can do any optimization it wants to outside of a critical section, even out of order processing!

blocks|key|3154840|text|如何查看C%2B%2B标准委员会网站上的论文：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3154841|3154842|C%2B%2B+Data-Dependency+Ordering:+Atomics+and+Memory+Model|unordered-list-item|offset|length|3154843|etc|3154844|3154845|3154846|entityMap|0|LINK|mutability|MUTABLE|url|http://open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2492.html|1|http://open-std.org/jtc1/sc22/wg21/docs/papers/2008/#mailing2008-10^0|0|0|0|1I|0|0|0|3|1|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|W|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|X|8|@]|9|@$F|Y|G|Z|1|10]]|A|$]]|$1|H|3|I|5|E|7|11|8|@]|9|@$F|12|G|13|1|14]]|A|$]]|$1|J|3|-4|5|6|7|15|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|16|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|S]]|T|$5|O|P|Q|A|$R|U]]]]

What about checking the papers on the C++ standard committee website:

<ul>
<li><a href="http://open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2492.html" rel="nofollow noreferrer">C++ Data-Dependency Ordering: Atomics and Memory Model</a></li>
<li><a href="http://open-std.org/jtc1/sc22/wg21/docs/papers/2008/#mailing2008-10" rel="nofollow noreferrer">etc</a></li>
</ul>

?

blocks|key|834783|text|如果您想更深入地理解共享内存一致性模型，我建议您参考以下教程。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|834784|http://rsim.cs.uiuc.edu/~sadve/Publications/computer96.pdf|offset|length|834785|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1M|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@$D|O|E|P|1|Q]]|A|$]]|$1|F|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|C]]]]

If you'd like to get a deeper understanding of shared memory consistency models, I'd refer you to the following tutorial.

<a href="http://rsim.cs.uiuc.edu/~sadve/Publications/computer96.pdf" rel="nofollow noreferrer">http://rsim.cs.uiuc.edu/~sadve/Publications/computer96.pdf</a>

blocks|key|3154742|text|简短的回答是:没有|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3154743|长答案:+C%2B%2B没有托管内存，你必须自己分配并释放它。智能指针类可以减轻这方面的负担。如果你忘记释放你分配的内存，那就是一个内存泄漏和错误。如果您试图在释放内存之后使用它，或者您尝试多次释放内存，这些也是令人讨厌的bug。|3154744|至于低层细节，C%2B%2B没有指定-这取决于硬件。内存是通过指针访问的，指针包含某种类型的内存地址。内存地址可以是物理地址，也可以是虚拟地址。如果你使用的是操作系统内核，或者你正在阅读在实模式下运行的旧的DOS代码，那么你只能看到物理地址。有关更多详细信息，请阅读virtual+memory，那里有很多很好的资源。|offset|length|3154745|x86架构还允许使用段描述符对内存进行寻址。这是一个完全不同的蠕虫罐头，自从Win16时代以来就没有真正使用过，如果你幸运的话，你永远不需要处理它。|3154746|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Virtual_memory^0|0|0|3L|E|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@$F|U|G|V|1|W]]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]]]

Short answer: there is none

Long answer: C++ does not have managed memory, you have to allocate it and free it yourself. Smart pointer classes can make this less burdensome. If you forget to free memory that you allocated, that's a memory leak and a bug. If you try to use memory after freeing it, or you try to free memory more than once, those are also nasty bugs.

As for the low-level details, C++ does not specify that - it's up to the hardware. Memory is accessed through pointers, which contain some sort of memory address. Memory addresses can either be physical addresses or virtual addresses. You'll only see physical addresses if you're working on an operating system kernel, or if you're reading old DOS code that ran in real mode. For more details, read up <a href="http://en.wikipedia.org/wiki/Virtual_memory" rel="nofollow noreferrer">virtual memory</a>, there's lots of good resources out there.

The x86 architecture also allows memory to be addressed using segment descriptors. This is a whole nother can of worms, which hasn't really been used since the days of Win16, and if you're lucky, you'll never have to deal with it.

blocks|key|4000355|text|简而言之，C%2B%2B内存模型由...|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4000356|4000357|向下增长的堆栈--也就是说，当您推入堆栈帧时，堆栈指针的值小于它的值|unordered-list-item|4000358|向上增长的堆，即新分配的内存的结束地址大于内存之前的地址。您可以使用malloc()或new在堆中分配内存。如果堆中没有足够的内存可用，那么malloc+(或new)调用系统函数brk()+sbrk()来增加堆的大小。如果对brk()或sbrk()的调用失败，则malloc或new会失败，并出现内存不足异常。|4000359|4000360|您永远不需要关心堆栈或堆是向下增长还是向上增长，在某些系统中，它们可能会以相反的方式运行。只需考虑堆栈和堆从地址空间的末端向内增长。|4000361|4000362|内存分配器，按8位字节分配内存。New也会分配内存，但它分配的内存量是基于New对象的大小。包含可执行代码的|4000363|文本空间。文本驻留在堆的下面。在执行|4000364|期间不能更改文本空间|4000365|一个程序可以在文本下面有其他特殊用途的部分。|4000366|您可以在linux系统上使用objdump查看程序是如何静态组织的(在加载之前)。|4000367|我注意到，尽管您在问题中没有提到这一点，但“并发性”是您分配给这个问题的关键字之一。线程系统在堆上为每个线程分配额外的线程空间，然后管理堆栈指针以在线程之间切换。|4000368|还有更多的细节，其中许多是特定于特定硬件、OSes或线程系统的，但这是最基本的想法。|4000369|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|12|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|13|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|14|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|15|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|16|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|17|8|@]|9|@]|A|$]]|$1|L|3|M|5|E|7|18|8|@]|9|@]|A|$]]|$1|N|3|O|5|E|7|19|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1A|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1B|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|1C|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|1D|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1E|8|@]|9|@]|A|$]]|$1|Z|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|10|$]]

In a nutshell, the C++ memory model consists of...

<ul>
<li>A stack that grows downward -- that is, when you push a stack frame the stack pointer has a value less that it was</li>
<li>A heap that grows upward, that is the end address of the newly allocated memory is greater it was before the memory. You allocate memory in the heap using malloc() or new. If there is not enough memory available in the heap then malloc (or new) calls the system function brk() sbrk() to increase the size of the heap. If the call to brk() or sbrk() fails then malloc or new fails with an out of memory exception.</li>
</ul>

You should never need to care whether the stack or heap grow down or up and in some systems these may operate the other way around. Just consider that the stack and heap grow inwards from the ends of the address space.

<ul>
<li>A memory allocator, malloc, which allocates memory in terms of 8-bit bytes. New also allocates memory, but the amount of memory that it allocates is based on the size of the object being newed.</li>
<li>Text space which contains the executable code. Text resides below the heap. You cannot alter the text space during execution</li>
</ul>

A program may have other special purpose sections below text.

You can see how a program is organized statically (before it's loaded) using objdump on linux systems.

I noticed that although you didn't mention it in your question, "concurrency" is one of the keywords you assigned to this question. Threading systems allcoate additional thread space on the heap for each thread and then manage the stack pointer to switch between threads.

There are a lot more details, many of which are specific to particluar hardware, OSes, or threading system, but that's the essential idea.

What is the memory model for concurrency in C++03?

(And, does C++11 change the memory model to support concurrency better?)

What is the C++03 memory model for concurrency?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

C++03中的并发内存模型是什么？(而且，C++11是否更改了内存模型以更好地支持并发性？)

问并发的C++03内存模型是什么？
EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问并发的C++03内存模型是什么？EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问并发的C++03内存模型是什么？
EN