标签: dynamic-memory-allocation

有什么方法可以释放您使用 malloc() 创建的部分内存吗？

认为：-

int *temp;

temp = ( int *) malloc ( 10 * sizeof(int));
free(temp);

free() 将释放所有 20 字节的内存，但假设我只需要 10 字节。我可以释放最后 10 个字节吗？

该网站上的许多答案都提到delete()调用析构函数。但下面的示例代码似乎delete()在析构函数内部调用。当对象在堆栈和堆中初始化时，delete() 的正确用法是什么？

点击查看来源。

#include <iostream>
using namespace std;
 
class SmartPtr {
    int* ptr; // Actual pointer
public:
    // Constructor: Refer https:// www.geeksforgeeks.org/g-fact-93/
    // for use of explicit keyword
    explicit SmartPtr(int* p = NULL) { ptr = p; }
 
    // Destructor
    ~SmartPtr() { delete (ptr); }
 
    // Overloading dereferencing operator
    int& operator*() { return *ptr; }
};
 
int main()
{
    SmartPtr ptr(new int());
    *ptr = 20;
    cout << *ptr;
 
    // We don't need to call delete ptr: …

下面的代码允许您查看被删除的变量的大小：

#include <iostream>
#include <stdlib.h>
using namespace std;

struct P {
    static void operator delete(void* ptr, std::size_t sz)
    {
        cout << "custom delete for size " << sz <<endl;
        delete (ptr); // ::operator delete(ptr) can also be used
    }
    static void operator delete[](void* ptr, std::size_t sz)
    {
        cout << "custom delete for size " << sz <<endl;
        delete (ptr); // ::operator delete(ptr) can also be used
    }
};

int main()
{
    P* var1 = new P;
    delete var1;

    P* var2 …

我正在学习C++中的动态内存.作为为任何数据类型动态分配和解除分配的标准方法,我学到的是,例如,

//For double,
double* pvalue1 = nullptr;
pvalue1 = new double;
*pvalue1 = 17.3;
delete pvalue1; //free up when I'm done

但是,对于一个char数组,我了解到它的处理方式不同:

char* pvalue2 = nullptr;
pvalue2 = new char[6];
strncpy(pvalue2,"Hello",sizeof("Hello"));

std::cout << "Pointed-to value of pvalue2 is " << *pvalue2 << std::endl;
std::cout << "Value of pvalue2 is " << pvalue2 << std::endl;

delete [] pvalue2; //free up when I'm done

然后,在命令提示符下:

Pointed-to value of pvalue2 is H
Value of pvalue2 is Hello

1. 为什么指针pvalue2给出"指向"字符串文字而不是内存地址？不是"指针值"总是它指向的内存地址吗？
2. 为什么解除引用只给出数组中的第一个字符？ …

我试图理解双指针(这是指针持有另一个指针)的内部形成一个指针数组.所以,我试图运行以下代码,通过试验malloc进行调试,看看它是如何工作的.我无法理解malloc(0)我的情况,但我的代码通过输出"Hello World"来工作.

什么是差异

pToCharsPointers = (char**) malloc(0);

和

pToCharsPointers = (char**) malloc(2 * sizeof(char*));

请有人澄清一下我的情况.

#include <stdio.h>

char **pToCharsPointers;

int main(void)
{
    pToCharsPointers = (char**) malloc(0);

    char* pToChars = "Hello";
    *pToCharsPointers = pToChars;

    *(pToCharsPointers + 1)= "World";

    printf("%s %s\n", *(pToCharsPointers + 0), *(pToCharsPointers + 1));

    return 0;
}

另外,如果有人能解释双指针如何与内存中的示例一起工作以进行可视化,我会非常感激,因为即使我试图在很多地方阅读此内容,我仍未能看到自己.

编辑:感谢大家分享您的答案,这真的有助于理解.当我打印它时,我得到了一个带有malloc(0)的有效指针,并且在多次尝试期间也可以解除引用它而没有问题.想了解它的工作原理.在我的情况下似乎未定义的行为实际上是预期的行为.

我被教官说叫p = (int*)malloc(5 * sizeof(int))是不是动态内存分配，并且p=(int*)malloc(n * sizeof(int))是动态内存分配。

讲师正在谈论基本数据结构并教授数组。他曾告诉我们使用int arr[100]语法创建数组的传统方法，但随后他向我们介绍了 malloc。

据他说，由于内存大小不会改变，我猜它不是动态的。

从我可以从互联网上收集的信息来看，malloc在运行时分配内存，以及在运行时分配内存时的动态内存分配。所以我认为这两个malloc语句都是动态内存分配。我的推理有问题吗？

我注意到 C++ 中的字符串容量遵循以下模式：

• 初始字符串大小为 15
• 对于大于特定大小“块”的任何字符串，容量将增加一倍。

以下是长度不超过 500 的字符串的字符串容量：

15
30
60
120
240
480
960

使用以下 C++ 程序找到了容量：

#include <iostream>
#include <vector>

using namespace std;

string getstr(int len) { 
    string s = "";
    for (int i=0; i<len; i++) {
        s.append("1");
    }
    return s;
}

int main() {
    vector<int> capacities;
    int prevcap;
    for (int i=0; i<500; i++) {
        int cap = getstr(i).capacity();
        if (cap > prevcap) {
            capacities.push_back(cap);
            prevcap = cap;
        }
    }
    for (int i : capacities) {
        cout …

该标准规定，在移动和重新绑定方面，分配器必须与其副本相同。但是，在调用其成员函数之后（例如分配值之后），它是否会变得与之前的状态不相等？也就是说，这可能是一个合规的分配器吗？

auto allocator_copy = allocator;
std::cout << (allocator == allocator_copy) << std::endl;  // Outputs "1", as prescribed by the standard.
allocator.allocate(1);
std::cout << (allocator == allocator_copy) << std::endl;  // Outputs "0";

我有一个非常复杂的数学算法，它已经在我的代码中存在多年了。今天，我做了一些高级性能测试，发现该算法占用了大量 CPU 时间。然后我看到（由于其年龄）该算法使用了double[] array = new double[6]几次，然后将数组传递给子函数。我认为使用Span<double>和stackalloc double应该会稍微提高性能，因为它减少了 GC 负载并可能减少了一些范围检查。

令我非常惊讶的是，事实恰恰相反，这一变化导致整体测试时间从 23 秒提高到 28 秒。我编写了以下测试用例来展示该行为（实际代码要复杂得多）：

        // This one must be quite big to see the timing difference for these simple test cases
        private const int MeasuremenLoopCount = 1000000;
        private const int ArraySize = 10;

        [Fact]
        public void UseArray()
        {
            for (int i = 0; i < MeasuremenLoopCount; i++)
            {
                double[] array = new double[ArraySize];
                array[0] = 2;

                CalcOnArray(array);
            }
        }

        private void CalcOnArray(double[] …

为什么numpy.zeros()比重新初始化现有数组更快？

我从事计算机建模工作，并在工作中使用 numba。有时需要有一个归零数组来累积某些操作的结果。一般来说，我认为对已分配的数组进行清零不会比创建一个充满零的新数组慢，但事实并非如此。我知道延迟选择（例如为什么Python的Numpy零和空函数之间的速度差异会随着较大的数组大小而消失？https: //vorpus.org/blog/why-does-calloc-exist/），但它必须采取是时候将其归零了。

据我所知，np.zeros使用calloc和所有加速都来自此调用，并且应该可以为其他语言重现。有什么保证吗，总是这样吗？这是好的做法还是不好的做法？

import numpy as np
import numba as nb
import benchit
nb.set_num_threads(1)

@nb.njit
def numba_operation(in_arr, out):
    for i in range(out.shape[0]):
        for j in range(out.shape[1]):
            out[i,j] += in_arr[i,j] * 2 + 4
            
@nb.njit
def numba_operation_with_zeros(in_arr, out):
    for i in range(out.shape[0]):
        for j in range(out.shape[1]):
            out[i,j] = 0
    for i in range(out.shape[0]):
        for j in range(out.shape[1]):
            out[i,j] += in_arr[i,j] * 2 + 4

    
def every_time_generate_zeros(data):
    in_arr, out = data
    out …