相关疑难解决方法(0)

为什么C++没有虚拟构造函数？

有没有办法在堆栈而不是堆上分配内存？我找不到一本好书,这里有人有个主意吗？

我总是用Java编程,这可能就是为什么我对此很困惑:

在Java中我声明了一个指针:

int[] array

并初始化它或为其分配一些内存:

int[] array = {0,1,0}
int[] array = new int[3]

现在,在C中,这一切都让人感到困惑.起初我以为它就像宣布它一样容易:

int array[]

并初始化它或为其分配一些内存:

int array[] = {0,1,0}
int array[] = malloc(3*sizeof(int))
int array[] = calloc(3,sizeof(int))

除非我错了,以上所有内容都等同于Java-C,对吗？

然后,今天我遇到了一个代码,其中我发现了以下内容:

pthread_t tid[MAX_OPS];

以及下面的一些行,没有任何初始化......

pthread_create(&tid[0],NULL,mou_usuari,(void *) 0);

令人惊讶的是(至少对我而言)代码有效!至少在Java中,会返回一个很好的"NullPointerException"!

所以,按顺序:

1. 我是否正确使用所有Java-C"翻译"？

2. 为什么该代码有效？

3. 使用malloc(n*sizeof(int))和之间有什么区别calloc(n,sizeof(int))吗？

提前致谢

我正在调试一个相当奇怪的堆栈溢出,据说是在堆栈上分配太大的变量引起的,我想澄清以下内容.

假设我有以下功能:

void function()
{
    char buffer[1 * 1024];
    if( condition ) {
       char buffer[1 * 1024];
       doSomething( buffer, sizeof( buffer ) );
    } else {
       char buffer[512 * 1024];
       doSomething( buffer, sizeof( buffer ) );
    }
 }

我理解,它依赖于编译器,也取决于优化器决定什么,但为这些局部变量分配内存的典型策略是什么？

输入功能后是否会立即分配最坏情况(1 + 512千字节)或首先分配1千字节,然后根据条件另外分配1或512千字节？

我正在研究一个软实时事件处理系统.我希望尽可能减少代码中具有非确定性时序的调用次数.我需要构造一个由字符串,数字,时间戳和GUID组成的消息.大概std::vector的boost::variant的.

我一直想用alloca在过去类似性质的代码中.然而,当人们研究系统编程文献时,总是会对这个函数调用提出大量警告.就个人而言,我不能想到过去15年中没有虚拟内存的服务器类机器,而且我知道Windows堆栈一次增长一个虚拟内存页面,所以我假设Unices也是如此.这里没有砖墙(再也没有),堆栈就像堆一样可能耗尽空间,那么是什么给出了？为什么人们没有超过阿洛卡？我可以想到许多负责任地使用alloca的用例(字符串处理任何人？).

无论如何,我决定测试性能差异(见下文),并且alloca和malloc之间存在5倍的速度差异(测试捕获了我将如何使用alloca).那么,有变化吗？我们是否应该谨慎对待风并使用alloca(包裹在a中std::allocator)每当我们完全可以确定物体的使用寿命时？

我厌倦了生活在恐惧中!

编辑:

好吧有限制,对于Windows来说这是一个链接时间限制.对于Unix来说,它似乎是可调的.似乎页面对齐的内存分配器是有序的:D任何人都知道通用的便携式实现:D？

码:

#include <stdlib.h>
#include <time.h>

#include <boost/date_time/posix_time/posix_time.hpp>
#include <iostream>

using namespace boost::posix_time;

int random_string_size()
{
    return ( (rand() % 1023) +1 );
}

int random_vector_size()
{
    return ( (rand() % 31) +1);
}

void alloca_test()
{
    int vec_sz = random_vector_size();

    void ** vec = (void **) alloca(vec_sz * sizeof(void *));    

    for(int i = 0 ; i < vec_sz ; i++)
    {
        vec[i] = alloca(random_string_size()); …

我一直想知道如何逃脱这个:

int main(int argc, char **argv) {
    printf("%p %s %d\n", &argv[1], argv[1], strlen(argv[1]));
    char copy[strlen(argv[1]) + 1];
    strcpy(copy, argv[1]);
    printf("%p %s %d\n", &copy, copy, strlen(copy));
    return 0;
}

copy无论如何,char数组都被分配,程序运行正常,打印出原始数据和副本.而Valgrind并没有抱怨什么.

我认为没有malloc的C语言中不可能使用动态数组.我错了吗？

我有一个简单的函数,其中一个数组声明大小取决于参数int.

    void f(int n){
        char a[n];
    };

    int main() {
        return 0;
    }

这段代码在GNU C++上编译得很好,但在MSVC 2005上却没有.

我收到以下编译错误:

    .\main.cpp(4) : error C2057: expected constant expression
    .\main.cpp(4) : error C2466: cannot allocate an array of constant size 0
    .\main.cpp(4) : error C2133: 'a' : unknown size

我该怎么做才能纠正这个问题？

(我有兴趣使用MSVC,而不使用new/delete)

当进程请求内存并且操作系统向进程提供一些新页面时,内核应该初始化页面(例如,使用零),以避免显示另一个进程使用的可靠数据.当进程启动并接收一些内存时也是如此,例如堆栈段.

当我在Linux中执行以下代码时,结果是大部分已分配的内存确实为0,但堆栈底部大约3-4 kB(数组的最后一个元素,最高地址)包含随机数.

#include <cstdlib>
#include <iostream>
using namespace std;

int main()
{
    int * a = (int*)alloca(sizeof(int)*2000000);
    for(int i = 0; i< 2000000; ++i)
        cout << a[i] << endl;
    return 0;
}

1. 为什么它也没有设置为零？
2. 可能是因为它被这个过程重用了吗？
3. 如果是,那么早期使用那些3-4 kB内存的初始化代码是不是？

我对可变长度数组感到担忧.当我想动态分配一个数组时,如果无法分配足够的内存,我将得到null,我可以在程序中正确响应.对于可变长度数组,我没有得到这些信息.我该怎么办？

int A[10000000]; //This gives a segmentation fault
int *A = (int*)malloc(10000000*sizeof(int));//goes without any set fault.

现在我的问题是,出于好奇,如果最终我们能够为我们的数据结构分配更高的空间,例如,在C中使用指针方法创建的BST和链接列表没有这样的内存限制(除非总数大小超过我们机器的RAM大小),例如,在声明指针类型的上面的第二个语句中,为什么我们不能声明一个更大的数组(直到达到内存限制!!). ..这是因为分配的空间在静态大小的数组中是连续的吗？但是从那里我们得到保证,在RAM的下一个1000000字中没有其他代码将运行...？

PS:我在一些陈述中可能错了.在这种情况下请正确.