下面是一个直接变量声明的例子。
double multiplyByTwo (double input) {
double twice = input * 2.0;
return twice;
}
下面是一个动态内存分配的例子。
double *multiplyByTwo (double *input) {
double *twice = malloc(sizeof(double));
*twice = *input * 2.0;
return twice;
}
如果我有选择，我会一直使用直接变量声明，因为代码看起来更易读。什么时候动态内存分配更合适？
考虑以下代码段：
#include <iostream>
using namespace std;
class p
{
public:
int* q;
p()
{
q = new int(100);
}
~p(){
delete q;
}
};
static p* p1 = new p();
static p p2;
int main() {
// your code goes here
std::cout << *(p1->q);
std::cout << *(p2.q);
delete p1;
}
p1 和 p2 是静态变量，它们必须存储在静态段中。
由于 p1 是一个指针，那么是否只是存储在静态段中的指针地址，甚至是它指向的对象？
p2 是一个普通的静态对象，但是它包含一个动态分配的成员变量 q，那么 q 是否也存储在静态段中？
我有以下功能的问题.
当我尝试realloc()记忆时,我得到的比实际要求的要多!
在这种情况下我会再做连接两个字符串,一个谁是14个字符长,一个谁是长11个字符,但最终的结果是,memTemp长38个字符,即使memNewSize表明,它实际上是在25,没有人知道该怎么办？
int dstring_concatenate(DString* destination, DString source)
{
assert(destination != NULL); // Precondition: destination ar ej NULL
assert(*destination != NULL); // Precondition: *destination ar ej NULL
assert(source != NULL); // Precondition: source ar ej NULL
//Dstring looks like this = "typedef char* Dstring;"
int memNewSize = strlen(*destination) + strlen(source);
char *memTemp;
memTemp = (char*)realloc(memTemp, sizeof(char) * memNewSize);
printf("%d\n", memNewSize);
printf("%d\n", strlen(memTemp));
if(memTemp == NULL)
{
printf("Could not allocate new memory.\n");
return 0;
} …我正在尝试在C中构建一个名为PROCESS的结构,这个结构应该包含进程的ID(id)和等待时间(wt).
typedef struct PROC{
int id;
int wt;
}PROCESS;
PROCESS *pt = NULL;
现在我想像数组一样创建这个结构的一个实例.我想做的是这样的':
PROCESS pt[10];
pt[0].id = 5;
pt[1].id = 7;
但我想用动态内存分配来做到这一点:
pt = calloc(2,sizeof(PROCESS));
pt[0]->id = 5;
我的错是什么？
我想为数组数组动态分配内存，知道行数将为 n，但我不想为每行分配比需要更多的内存，这将是 i = 1:n ，每行的元素数 = i，我事先知道这一点。
int [] a = new int[n];
for (int i=0; i<n; i++)
我刚刚开始学习 Java，我是新手。据我所知，第一行将为 n 个元素（行数）分配内存，我想要做的是在每次迭代时创建一个新的 i 个元素数组。
我对这三个概念有些困惑：堆栈、堆和动态内存分配。我将提供 C++ 中的示例。
我说给定一个程序，对于它的所有变量、数组，也许还有堆栈上的对象，当程序刚刚启动时，所有需要的内存空间都已经存在，所以一切都是预先确定的吗？但是当程序运行时，对我来说它仍然听起来像“动态”，因为堆栈仍在变化，在运行时值仍在推入，从堆栈中弹出。
关于堆，对于“动态”的意义，我从这个站点上的一些答案中提出了这个想法，它是针对运行时确定的：
cin >> box_size;
int *box = new int[box_size];
但是，那么这个†怎么样：
Box surprise_box = new Box();
我已经知道编译时需要多少空间，对吗？但它仍然在堆上。所以看起来“动态”内存分配只是关于内存分配/释放的负担成为程序员的负担之一。
†：应该是Box *ptr_surprise_box = new Box();。（感谢评论）
我明白为什么我的问题被认为太宽泛了，但我不知道如何将它们分成几部分。更糟糕的是，现在我正在考虑这是否与地址空间和编译时确定的那些内存地址有关。
我只是很想知道,如果在释放新运算符分配的内存之前会发生什么,会发生异常？是否发生了内存泄漏问题？
#include <iostream>
#include<new>
using namespace std;
void func()
{
try
{
int *p = new int[10];
/*
Number of lines code here
.
.
.
.
.
Suppose here I got exception then What heppens????
.
.
.
.
*/
delete []p;
}
catch(const std::exception& e)
{
cout<<"Exception occured"<<endl;
}
}
int main() {
func();
return 0;
}
我创建如下数组（行= 2649429，col = 17770，数组的大小为47,080,353,330〜470亿）
double* a= new double [row*col];
错误如下
terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
火车数据约为3GB。
请告诉我如何处理数组？解决方案。谢谢。
我正在学习有关 C 编程语言中动态内存分配的知识。当我试图编写一个描述如下的程序时：
编写一个名为duplicate 的函数，它使用动态存储分配来创建一个字符串的副本。例如，调用
p = 重复（str）；
将为与 str 相同长度的字符串分配空间，将 str 的内容复制到新字符串中，并返回指向它的指针。如果内存分配失败，让重复返回空指针。
这是《C程序设计语言，一种现代方法（第二版）》一书中第17章的练习2。
在我的第一次尝试中，我编写代码如下：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
char *duplicate(char* str){
char* news=(char*)malloc((strlen(str)+1)*sizeof(char));
if(news==NULL){
printf("Error: malloc failed\n");
return NULL;
}
strcpy(news,str);
return news;
}
int main(){
char *str,*p;
str="Hello world";
p=duplicate(str);
puts(p);
return 0;
}
运行成功。但是当我修改我的代码以调用free(str) 时，如下所示：
int main(){
char *str,*p;
str="Hello world";
p=duplicate(str);
free(str);
puts(p);
return 0;
}
它在没有任何输出的情况下失败并返回一个异常值。在我的书中，它没有提到关于这个问题的任何内容，而只给出了一些关于在没有分配任何值的指针上使用的 free() 函数的示例。我很好奇我的代码有什么问题？如果我想使用 free 函数，使用它的正确方法是什么，如何释放指向已分配值的内存的指针？
当我创建一个动态数组时：
int *arr = (int *) malloc( 4 * sizeof(int) );
所以它应该包含 4 个整数（对于空间问题可能还有 2 或 3 个），但为什么这样做：
for ( int x = 0; x < 30000; x++) {
arr[x] = x;
}
我的意思是不应该有 30.000 个变量的空间，而且它工作得很好，可能是什么原因？它是否像 c++ std::vector 一样自动重新分配，或者我如何理解它？
如果我将循环范围设置为 50.000，它会崩溃，但它甚至应该像索引 a[100] 或之前那样崩溃，因为数组有 4 个元素。
如果这很重要，我正在使用 gnu/linux。
我非常努力地理解它。
请帮忙