标签: dynamic-allocation

我在我的嵌入式系统中使用了C++基类和子类(为了清楚起见,我们称之为A和B).

这对时间和空间至关重要,所以我真的需要它是最小的.

编译器抱怨缺少虚拟析构函数,我理解这一点,因为如果你分配一个B* 以后删除指针作为实例,那会导致你遇到麻烦A*.

但是我永远不会分配这个类的任何实例.有没有一种方法,我可以重载operator new(),使得它编译,如果有要么类没有动态分配,但是如果最终用户尝试分配A或B的新实例会导致编译器错误？

我正在寻找一种类似于通过私有构造函数"中毒"自动编译器复制构造函数的常用技术的方法.(例如http://channel9.msdn.com/Forums/TechOff/252214-Private-copy-constructor-and-private-operator-C)

我读过,delete[]可以释放一个对象数组.然而,在我读过的任何来源中都没有提到它是否是一个错误或未定义提供类似的参数delete[3].

我有以下疑问.

1. 难道是C++标准规定是否我可以/不可以suplly一个参数delete[]为delete[3]？
2. 如果是,效果如何？
3. 它是否在C++中指定是否可以/不能delete用于从中分配的数组new[]？

我无法理解这段代码的结尾(array = 0;):

#include <iostream>

int main()
{
    std::cout << "Enter a positive integer: ";
    int length;
    std::cin >> length;

    int *array = new int[length];

    std::cout << "I just allocated an array of integers of length " << length << '\n';

    array[0] = 5; // set element 0 to value 5

    delete[] array; // use array delete to deallocate array
    array = 0; // use nullptr instead of 0 in C++11

    return 0;
}

最后,删除动态分配的数组(返回到OS),然后分配值0.

为什么这样做？数组返回操作系统后,无需为其赋值0,对吗？

代码来自:http …

new和之间有什么区别new[1]？我可以delete用new[1]吗？

编辑

好吧,我应该提供背景,对不起.我正在使用VS 2010评估BoundsChecker,当我在new [1]上使用delete []时,它抱怨内存泄漏.所以理论上我知道应该如何使用新的和删除对,但这种特殊的情况使我对引擎盖下的事情感到困惑.有什么想法吗？

我在 pyspark 中运行 python 脚本并收到以下错误：NameError: name 'spark' is not defined

我查了一下，发现原因是spark.dynamicAllocation.enabled目前还不允许。

根据 Spark 的文档（https://jaceklaskowski.gitbooks.io/mastering-apache-spark/content/spark-dynamic-allocation.html#spark_dynamicAllocation_enabled）：（spark.dynamicAllocation.enabled默认false：）控制是否启用动态分配。假定spark.executor.instances未设置或为 0（这是默认值）。

由于默认设置是false，我需要更改 Spark 设置以启用spark.dynamicAllocation.enabled.

我用 brew 安装了 Spark，并没有改变它的配置/设置。

如何更改设置并启用spark.dynamicAllocation.enabled？

非常感谢。

我有一个Spark Streaming作业与其他作业（Spark核心作业）一起在我们的集群上运行。我想对包括Spark Streaming在内的这些作业使用动态资源分配。根据下面的JIRA问题，不支持动态分配Spark Streaming（在1.6.1版本中）。但已在2.0.0中修复

JIRA链接

根据本期的PDF，它说应该有一个名为“ spark.streaming.dynamicAllocation.enabled=true 但是我在文档中没有看到此配置” 的配置字段 。

任何人都可以确认，

1. 我无法在1.6.1版本中为Spark Streaming启用动态资源分配。
2. 它在Spark 2.0.0中可用吗？如果是，应设置什么配置（spark.streaming.dynamicAllocation.enabled=true或spark.dynamicAllocation.enabled=true）

我必须实现一个看起来像这样的函数:

MyList * sum (MyList * l1, MyList * l2) {
    MyList * newlist = new MyList();
    //Adds two objects and place the result in a third new list
    return newlist;
}

该函数采用了两个列表,并将每个对象的总和放入一个新列表中.所述MyList类曾与指针指向节点next可变的,并且该列表内的对象的用户定义被.

这让我思考 - 我该如何处理来自对象和列表本身的动态内存分配？因为我必须为新列表的每个对象创建内存.

有没有办法将对象总和的值放在新列表中而不必依赖动态分配？也许做这样的事情:

Object result(node1->content + node2->content);
Node->content = &result; // will this object be erased when the function ends?

而不是这个:

Node->content = new Object(node1->content + node2->content);

我应该如何处理函数内部创建的新列表的生命周期,该函数将在函数结束后保存内存的变量？返回新列表时,我可以这样做吗？

MyList & sum (MyList * l1, MyList * l2) {
    //Create variable without allocating …

我的代码中有这样的东西

typedef struct ts_fem_mesh
{   
    double          **vertices;
    unsigned int    **triangles;
    unsigned int    n_ver;
    unsigned int    n_tri;
} fem_mesh;

fem_mesh *fem_mesh_new(unsigned int n_ver, unsigned int n_tri)
{
    fem_mesh *mesh;
    mesh = (fem_mesh *)malloc(sizeof(fem_mesh));

    mesh->n_ver = n_ver;
    mesh->n_tri = n_tri;

    mesh->vertices = (double **)calloc(n_ver, sizeof(double *));
    mesh->triangles = (unsigned int **)calloc(n_tri, sizeof(unsigned int *));

    int i;
    for(i=0;i<n_ver;i++)
        mesh->vertices[i] = (double *)calloc(2, sizeof(double));
    for(i=0;i<n_tri;i++)
        mesh->triangles[i] = (unsigned int *)calloc(3, sizeof(unsigned int));
    return mesh;

}

通常情况下,当我打电话fem_mesh_new,我使用了非常大的数字n_ver和n_tri,这有时会导致分配错误(没有足够的空间).

即使我遇到这种错误,我的程序也应该建议用户并执行.在这种情况下,我想释放自错误点以来我分配的所有东西(即我在尝试分配时遇到错误mesh->triangles …

我是C++的新手,想问下面的代码是否是悬空指针或内存泄漏的一个例子,因为它指向动态分配的数组:

int * n = new int[10];
for (int prev = 0; prev < 10; prev++) {
    *n = *(n + prev + 1);
}
delete[] n;
n = nullptr;

安全关键项目不建议任何动态分配或释放分配的内存.仅在程序执行的精化/初始化阶段,才允许.

我知道你们中的大多数人都会争论实施SW,它应该只进行所有静态分配,或者在代码中做一些理由,动态分配不会损害整个程序等等,但是,这个问题还有其他选择吗？有什么方法或任何例子可以在程序初始化/详细说明期间分配一些(堆)内存并从那里分配/释放内存？如果我们真的想在(安全关键)项目中进行动态分配,还是解决这个问题的任何解决方案/替代方案？