These are mostly compiler design questions. When your compiler compiles this, for example: int * pData = new int[256]; How is the memory allocated on-the-fly? Does the compiler make a call to an OS routine that allocates memory for you or is a function compiled that allocates the memory for you? Also, when you write something like this: if (x == 5) int y; Since the memory is not all
这些主要是编译器设计问题。 当你的编译器编译这个时，例如： int * pData = new int[256]; 内存如何分配？ 编译器是否调用了为您分配内存的OS例程，或者是编译过的为您分配内存的函数？ 另外，当你写这样的东西： if (x == 5) int y; 由于内存不是在运行时分配的，我假设数据占用了程序数据段的一些空间。 由于编译器无法确定int y; 分支将在运行时执行，是为变量保留的内存，无论是否为int y; 执行？ 如果不
I'm reviewing someone else's C++ code for our project that uses MPI for high-performance computing (10^5 - 10^6 cores). The code is intended to allow for communications between (potentially) different machines on different architectures. He's written a comment that says something along the lines of: We'd normally use new and delete , but here I'm using malloc and free . T
我正在为使用MPI进行高性能计算（10 ^ 5 - 10 ^ 6内核）的项目审查其他人的C ++代码。 该代码旨在允许不同体系结构中（可能）不同机器之间的通信。 他写了一篇评论，内容如下： 我们通常会使用new和delete ，但在这里我使用malloc和free 。 这是必要的，因为有些编译器会在使用new数据时填充不同的数据，导致在不同平台之间传输数据时出错。 malloc不会发生这种情况。 这不符合我从标准new vs malloc问题中所知道的任
Does std::make_unique have any efficiency benefits like std::makes_shared ? Compared to manually constructing std::unique_ptr : std::make_unique<int>(1); // vs std::unique_ptr<int>(new int(1)); The motivation behind make_unique is primarily two-fold: make_unique is safe for creating temporaries, whereas with explicit use of new you have to remember the rule about not usi
std::make_unique是否有像std::makes_shared一样的效率优势？ 与手动构建std::unique_ptr相比： std::make_unique<int>(1); // vs std::unique_ptr<int>(new int(1)); make_unique的动机主要有两方面： make_unique对于创建临时make_unique是安全的，而对于明确使用new您必须记住关于不使用未命名临时对象的规则。 foo(make_unique<T>(), make_unique<U>()); // exception safe foo(uniq
int *p=(int * )malloc(sizeof(int)); delete p; When we allocate memory using malloc then we should release it using free and when we allocate using new in C++ then we should release it using delete. But if we allocate memory using malloc and then use delete, then there should be some error. But in the above code there's no error or warning coming in C++. Also if we reverse and allocate u
int *p=(int * )malloc(sizeof(int)); delete p; 当我们使用malloc分配内存时，我们应该释放它，当我们在C ++中使用新分配时，我们应该使用delete来释放它。 但是如果我们使用malloc分配内存然后使用delete，那么应该会出现一些错误。 但是在上面的代码中，C ++没有错误或警告。 此外，如果我们使用免费的新版本和版本进行反向和分配，那么也没有错误或警告。 为什么这样？ 这是未定义的行为，因为没有办法可靠地证明
I have an application which allocates lots of memory and I am considering using a better memory allocation mechanism than malloc. My main options are: jemalloc and tcmalloc. Is there any benefits in using any of them over the other? There is a good comparison between some mechanisms (including the author's proprietary mechanism -- lockless) in http://locklessinc.com/benchmarks.shtml and
我有一个分配大量内存的应用程序，我正在考虑使用比malloc更好的内存分配机制。 我的主要选项是：jemalloc和tcmalloc。 使用其中的任何一个有什么好处？ 在http://locklessinc.com/benchmarks.shtml中有一些机制（包括作者的专有机制 - 无锁）之间有很好的比较，它提到了它们每个的一些优缺点。 鉴于这两种机制都很活跃并不断改进。 有没有人对这两者的相对表现有任何洞察或经验？ 如果我没有记错，主要区别在于多线程
This question already has an answer here: In what cases do I use malloc vs new? 18 answers Dynamically allocated C array of strings 6 answers 这是因为new使用给定类的构造函数（在你的情况下： std::string ）和malloc()不会这样做。
这个问题在这里已经有了答案： 我在哪些情况下使用malloc vs new？ 18个答案 动态分配C数组字符串6个答案 这是因为new使用给定类的构造函数（在你的情况下： std::string ）和malloc()不会这样做。
This question already has an answer here: In what cases do I use malloc vs new? 18 answers malloc allocates memory only, it doesn't invoke constructors which can leave objects in an indeterminate state. In C++ you should almost never use malloc , calloc or free . And if possible avoid new and new[] as well, use object instances or vectors of instances instead. As for your second que
这个问题在这里已经有了答案： 我在哪些情况下使用malloc vs new？ 18个答案 malloc只分配内存，它不调用可以使对象处于不确定状态的构造函数。 在C ++中，你几乎不应该使用malloc ， calloc或free 。 如果可能，避免使用new和new[] ，而是使用对象实例或实例向量。 至于你的第二个问题（这与第一个问题非常相关）， *(myBoxArray2).printer(23)是错误的. 选择运算符优先于解引用运算符* 。 这意味着首先你使用. 成
This question already has an answer here: In what cases do I use malloc vs new? 18 answers Well, everyone's told you about new not initialising memory etc, but they forgot about value-initialization syntax: char *buffer = new char[size](); So I would argue that you always use new . If you want to initialise the memory, use the above syntax. Otherwise, drop the parentheses. The ques
这个问题在这里已经有了答案： 我在哪些情况下使用malloc vs new？ 18个答案 好吧，每个人都告诉过你关于new不初始化内存等，但他们忘记了值初始化语法： char *buffer = new char[size](); 所以我会争辩说你总是使用new 。 如果你想初始化内存，使用上面的语法。 否则，请删除括号。 这个问题不能真正回答，因为它基于不正确的假设，即new分配内存但不初始化它。 事实恰恰相反： new不仅分配内存（除非你使用“pla
This question already has an answer here: How to initialize all members of an array to the same value? 19 answers Using the syntax that you used, int array[100] = {-1}; says "set the first element to -1 and the rest to 0 " since all omitted elements are set to 0 . In C++, to set them all to -1 , you can use something like std::fill_n (from <algorithm> ): std::fill_n(arra
这个问题在这里已经有了答案： 如何初始化一个数组的所有成员为相同的值？ 19个答案 使用您使用的语法， int array[100] = {-1}; 说的“第一元件设置-1 ，其余的0 ”，因为所有的元件省略都设置为0 。 在C ++中，为了将它们全部设置为-1 ，你可以使用类似std::fill_n （来自<algorithm> ）： std::fill_n(array, 100, -1); 在便携式C中，你必须推出你自己的循环。 有编译器扩展，或者如果可接受的话，您可以依赖
Insertion on std::list is claimed to be constant time, regardless whether it is made in the front, middle or back of the container. On the other hand, acquisition of memory for the new inserted item is handled by the standard allocator, which uses operator new. AFAIK operator new is not guaranteed to have constant time. When operator new looks for available space in the heap, it must be sure
无论是在容器的前部，中部还是后部制作，std :: list上的插入声称是恒定时间。 另一方面，为新插入的项目获取内存由标准分配器处理，该分配器使用operator new。 AFAIK运营商新不保证有恒定的时间。 当operator new在堆中查找可用空间时，必须确保它不会覆盖以前分配的内存，因此它必须跟踪已经在堆上分配的内容。 我得出结论，插入必须至少与已经在列表中的元素的数量成线性关系。 这个推理有什么问题？ 我的问题是：