标签: malloc

更新

这行代码是否有效:

boost::shared_array<struct sockaddr> addr(
    reinterpret_cast<struct sockaddr *>(
        (ipv6 ? new unsigned char [sizeof(struct sockaddr_in6)]
              : new unsigned char [sizeof(struct sockaddr_in)])
    )
);

请注意分配和类型中给出的类型之间的两种不同数据类型<template>.

最初的问题是使用boost :: shared_ptr

这行代码是否有效:

boost::shared_ptr<struct sockaddr> addr(
    reinterpret_cast<struct sockaddr *>(
        (ipv6 ? new unsigned char [sizeof(struct sockaddr_in6)]
              : new unsigned char [sizeof(struct sockaddr_in)])
    )
);

请注意分配和类型中给出的类型之间的两种不同数据类型<template>.

解

boost::shared_array<unsigned char> address(new unsigned char [sizeof(sockaddr_in)]);

注意:使用相同类型的unsigned char,其大小恰好是所需的大小.

然后当我打算使用它时:

bind(, (sockaddr*)address.get(), );

[编者注:我已经编辑了标题,试图在将来对其他人有用.为了给回答者一个信誉,这只是"为什么这不起作用？" 他们回答的问题!]

top -> ...无论Node*尝试将哪些代码推送到矢量子代,以下代码都会在具有分段错误的行中崩溃.有谁知道这可能导致什么？

struct Node
{
    string data;
    struct Node* parent;
    vector<struct Node*> children;
};

struct Node* push(string word, struct Node* top)
{
    Node* temp = (struct Node*) malloc(sizeof(struct Node));
    temp -> data = word;
    temp -> parent = top;
    return temp;
}

int main()
{
    Node* top = push("blah", NULL);
    Node* temp = NULL;
    top -> children.push_back(temp);
}

gcc(GCC)4.7.0 c89

我使用以下内容分配内存:

db_data_size = 32;
db->db_data[i]->name = malloc(db_data_size);

(gdb) p db_data_size
$24 = 32
(gdb) p sizeof(db->db_data[i]->name)
$25 = 8
(gdb) n
205   db->db_data[i]->email = malloc(db_data_size);
(gdb) p sizeof(db->db_data[i]->name)
$26 = 8

在调试器中,我得到8个字节而不是我认为应该分配的32个字节.

我的结构是:

struct data {
    int id;
    int set;
    char *name;
    char *email;
};

struct database {
    struct data **db_data;
    size_t database_rows;
    size_t database_data_size;
};

我能想到的唯一想法是char*是8个字节,这就是我得到的.但是,在malloc中我明确要求32个字节.

我不明白为什么必须在这里取消引用指针.char *toParseStr = (char*)malloc(10);有人有主意吗？

我有这个问题C.

我有以下声明.

int *a;
a=malloc(100);

我收到以下错误:

错误:从'void*'到'int*'的无效转换[-fpermissive]

有什么暗示吗？

使用此函数分配二维数组后:

char** make_matrix(int M, int N)
{
    char** MAT = (char**)malloc(M * sizeof(char));
    for (int i = 0; i < M; i++)
    {
        MAT[i] = (char*)malloc(N * sizeof(char));
    }
    return MAT;
}

我发现试图free(M[0])导致断言失败.我能找到的关于释放2-d数组的所有内容都使用int而不是char.然而,char用int以上代替每一个,断言失败消失.为什么这样,我怎么能释放整个二维阵列？

我有一个功能

int*AllocatedMemory(int n){
    int*p=malloc(n*sizeof(int));
    return p;
}

离开函数后分配的内存是否会丢失范围,从而被释放？

我已经经历了几个有关相同错误代码的类似问题,最关心的是传递无效指针地址.但是,这看起来并非如此,因为我的程序正确地处理了传递的任何地址.

FORMAT_STRING:

static char *format_string(char *string)
{
    int i;

    if (string == NULL) {
        return string;
    }
    string[0] = (char)toupper((int)string[0]);

    111->for (i = 1; string[i] != '\0'; i++) {
        if (!isalpha(string[i-1])) {
            string[i] = (char)toupper((int)string[i]);
        } else {
            string[i] = (char)tolower((int)string[i]);
        }
        if (string[i] == '/' || string[i] == '\\') {
        string[i] = ' ';
        }
    }
    /* Remove End of string White Spaces */
    while (string[--i]==' '); string[++i]='\0';

    return string;
}

metadata_extract:

static int metadata_extract(const char *filename, struct kw_metadata …

我是编程的新手,我正在努力理解它们之间的区别

A = (char * ) malloc(sizeof(char)*n);

和

A = (char * ) malloc(sizeof(char)); 

要么

A = new char [n];

和

A = new char;

当我没有指定特定数据类型的对象数时,编译器分配给此指针的默认内存是多少.

当我宣布时

A = new char [n];
cout << A[n+1];

它没有给我一个分段错误.

它应该不会给出分段错误,因为我试图访问超出为阵列分配的内存.

我明白如果我有以下内容:

char* c1 = "apple";
char* c2 = "apple";

然后这两个char*可以具有完全相同的内存地址.但如果我有以下内容怎么办:

char* c1 = (char*)malloc(sizeof(char)*10);
memset(c1, 0, 10);
c1[0]='a';c1[0]='p';c1[0]='p';c1[0]='l';c1[0]='e';
char* c2 = (char*)malloc(sizeof(char)*10);
memset(c1, 0, 10);
c2[0]='a';c2[0]='p';c2[0]='p';c2[0]='l';c2[0]='e';

即使在这种情况下,c1和c2是否可能具有相同的地址？