读取文件时,将为放置文件内容的字符串动态分配内存.这是在函数内部完成的,字符串作为传递char **str.
使用gdb我发现在线路上产生了一个seg故障 **(str+i) = fgetc(aFile);
以下是$ gdb a.out core一些变量值的输出:
Program terminated with signal SIGSEGV, Segmentation fault.
#0 0x0000000000400bd3 in readFile (aFile=0x994010, str=0x7ffd8b1a9338) at src/morse.c:59
59 **(str + i) = fgetc(aFile);
(gdb) print i
$1 = 1
(gdb) print **(str + 0)
$2 = 65 'A'
(gdb) print *(str + 0)
$3 = 0x994250 "A"
(gdb) print (str + 0)
$4 = (char **) 0x7ffd8b1a9338
(gdb) print **(str + 1)
Cannot access memory at address 0x0 …这真的很奇怪.如果我将它的值增加asize一个crashSystem(),那就是它的名字所说的.返回int指针的第二个函数可以使用更大的值.这两个函数只是删除并分配相同大小的相同动态数组(我创建它只是为了测试目的).
注意:我认为它可能与最大堆栈容量1MB(130037*8字节接近1MB)有关,但它真的很奇怪'因为使用new内部函数分配应该与其他任何工作相同new.
使用Visual Studio 2015
#include <iostream>
void crashSystem(int * dynamicArray, int asize) {
delete[] dynamicArray;
//dynamicArray = nullptr; does not matter at all
dynamicArray = new int[asize];
std::cout << "mem allocated\n";
}
int * worksOk(int * dynamicArray, int asize) {
int * newDynamicArray = new int[asize];
delete[] dynamicArray;
std::cout << "mem allocated\n";
return newDynamicArray;
}
int main()
{
int asize = 130037; // dynamic array size
//asize = 12330037; // for …所以,我给出了一些如何使用动态分配的2d数组的示例,并且即将发送基本上如下的代码:
int size = 5;
int* arr = new int[ size ];
for( int i = 0; i < size; i++ )
arr[ i ] = i;
delete[] arr;
size = 10;
int* arr = new int[ size ];
for( int i = size; i > 0; i-- )
arr[ i ] = i;
delete[] arr;
这给了我一个重定义错误,但我认为delete []释放了内存中的空间(因此'arr').我知道如何解决这个问题(新的数组名称,不要删除[] /重新定义),但我想知道实际发生了什么导致错误？
我想了解为什么动态分配多次调用的数据使用的内存比在代码上直接指定的内存或通过单次调用分配的那样多malloc.
例如,我在C中制作了以下两个代码:
test1.c:int x分配有malloc
int main (void)
{
int *x;
int i, n=1048576; //n=1024*1024;
printf("size = %lu\n", n* sizeof(int));
for(i=0; i<n; i++)
{
x = malloc(sizeof(int));
*x=i;
}
printf("Look at top and then press something to finish.");fflush(stdout);
getc(stdin);
return 0;
}
我没有在这里免费使用它来保持简单.当程序等待交互时,我查看另一个终端中的top函数,它显示了这个:
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
1384 root 20 0 41300 34076 1300 S 0.0 3.3 0:00.47 test1
test2.c:int x未动态分配
int main (void)
{ …c malloc memory-management dynamic-memory-allocation static-memory-allocation
我需要一些帮助来为结构释放内存.
我正在存储一个指向变量中的内存位置的指针,但我想在使用后释放内存.但是,当我尝试释放内存时,它只释放第一个结构项(name)并age保留在内存中.我的代码可以在下面看到.
int main(int argc, char **argv)
{
struct employee {
char *name;
int age;
};
// Make pointer, employee struct and put struct in memory at pointer location
struct employee *employee_1;
struct employee new_employee;
new_employee.name = "Sue";
new_employee.age = 26;
employee_1 = (struct employee *) malloc(sizeof(new_employee));
(*employee_1).name = new_employee.name;
(*employee_1).age = new_employee.age;
// ... Some operations done
// Deallocate memory location
free(employee_1);
return 0;
}
员工的姓名和年龄肯定都存储在内存位置,但我无法将其解除分配.我测试过这个在结构中有两个以上的项目,每次它只是第一个被解除分配的项目.
我已经尝试了一些不同的方法,例如在每个单独解除分配的情况下,如果它可以工作,free((*employee_1).name)但这会引发错误.任何帮助,将不胜感激.
我的问题主要是理论上的。假设我们有一堂课
class A{
private:
int * a;
int b;
private:
A(){
a = new int[100];
b = 100;
}
~A(){
delete [] a;
}
}
据我所知，如果我们动态创建类型A的对象（A * a = new A()），该对象的内存将在堆中分配，如果我使用（A a），它将在堆栈中创建(A a)。如果在堆栈上为变量创建对象，则在堆上a分配变量；如果在堆栈上为对象分配对象，则在堆栈上分配对象b。我要确定的第一个问题是：我正确吗？
第二个问题是，将类的所有成员存储在堆内存或堆栈内存中会更有效吗？
class A{
private:
int * a;
int * b;
private:
A(){
a = new int[100];
b = new int(100);
}
~A(){
delete [] a;
delete b;
}
}
当我说有效时，我的意思是所有关于类成员的数据都将彼此靠近地存储在堆或堆栈的内存中（实际上，我不确定它们将彼此靠近存储是正确的）。
我有以下代码:
src/main.cpp:
#include <include/array.hpp>
int main() {
int temp[] = {1, 2, 3, 4, 5};
sdizo::array<int> a(temp, 5);
print_array(a);
return 0;
}
include/array.hpp
#pragma once
#include <string.h>
#include <iostream>
namespace sdizo {
template <class T>
class array {
private:
T* data;
int length;
public:
array();
array(T* d, int len);
~array();
T* begin();
T* end();
};
template <typename T>
array<T>::array() {
data = nullptr;
length = 0;
}
template <typename T>
array<T>::array(T* d, int len) {
length = len;
this->data …阅读COM以获取一些遗留项目.到目前为止,我的理解是COM只是一个二进制规范,并且所有实现组件(客户端和服务器)必须遵守此规范.只要我们使用接收和返回简单值类型的方法处理COM接口,一切对我来说都是完美的.
但是,也有可能从COM对象发送指向整个对象/变体(包含例如a SAFEARRAY)的指针,我想知道这些param对象的内存在哪里被分配.我读到它是由windows拥有的内存,我们不应该通过COM方法篡改它.然后我偶然发现了IMallocCOM接口及其Alloc方法,它似乎以COM感知的方式分配了一大堆内存,完美地完成了混乱.
为了不干扰由C++维护的堆结构(假设我们用C++编写COM服务器),究竟在哪里IMalloc分配内存？
我正在阅读我正在阅读的C++书籍中的以下代码片段.
int* operator=(const int& rhs, int *x)
{
int *tmpx=x //line 1
x = new int(2) //line 2
delete tmpx; //line 3
return x; //line 4
}
我怀疑的是,如果我在第3行删除tmpx,它将地址保存到x指向的内存位置,并且删除将使内存地址无效,那么返回指向内存地址的x不是错误的在第3行获释？
I'm using posix_memalign (had trouble with align_alloc) to allocate (inside my own new) so I have a void*. I need it as int for instance to compute alignment:
#include <iostream>
using std::cout;
using std::cin;
using std::endl;
int main() {
void *ptr;
auto align{4096}, size{10000};
posix_memalign( &ptr,align,size );
cout << ptr << endl; // works
cout << ptr % align << endl; // not
return 0;
}
我认为在现代C ++ static_cast<long>中将是正确的方法，但这会导致错误，这是不允许的void*。那么正确的方法是什么？我当然可以使用旧式的C强制类型转换，但我正在尝试避免使用这些类型。