在这个问题,有人建议意见,我应该不会投的结果malloc,即

int *sieve = malloc(sizeof(int) * length);

而不是:

int *sieve = (int *) malloc(sizeof(int) * length);

为什么会这样呢？

我遇到了以下C拼图:

问:为什么以下程序会在IA-64上发生段错误,但在IA-32上运行良好？

  int main()
  {
      int* p;
      p = (int*)malloc(sizeof(int));
      *p = 10;
      return 0;
  }

我知道int64位机器的大小int可能与指针的大小不同(可能是32位,指针可能是64位).但我不确定这与上述计划有什么关系.有任何想法吗？

我想询问以下案例:

char *temp;
temp = malloc(10);

由于返回类型malloc是void*,在被分配给temp之前,是否会malloc被隐式转换为char*类型返回的指针？标准在这方面说了什么？

如果我们的指针变量是某种结构类型,例如:

struct node *temp;
temp = (struct node *)malloc(sizeof(struct node));

如果我们将内存分配给temp而不struct node*将其强制转换为类型,是否会将其隐式转换为struct node*类型,还是必须将其显式转换为struct node*类型？

答案之一,以你为什么不使用C为您的Web应用程序？包含以下内容:

对于下面的C crap示例:

const char* foo = "foo";
const char* bar = "bar";
char* foobar = (char*)malloc(strlen(foo)+strlen(bar)+1);
strcpy(foobar, foo);
strcat(foobar, foo);

Run Code Online (Sandbox Code Playgroud)

实际上,常量CAN和应该在C中自然连接:

const char foo[] = "foo";
const char bar[] = "bar";
char foobar[] = foo bar; // look Ma, I did it without any operator!

Run Code Online (Sandbox Code Playgroud)

使用[]代替*甚至可以让你修改字符串,或者找到它们的长度:

int foo_str_len = sizeof(foobar)-1;

Run Code Online (Sandbox Code Playgroud)

所以,请你,在你(错误地)声称C很难用字符串之前,学习如何使用C.

我自己尝试过,但得到一个错误:

预期','或';' 字符串常量之前

所以我的问题是:我是否需要告诉编译器一些东西才能使这项工作或上面的帖子完全错误？请注意,我知道在C中连接字符数组的其他方法.

我在这个帖子上对我的回答发表了评论:

函数调用中的malloc似乎在返回时被释放？

总之,我有这样的代码:

int * somefunc (void)
{
  int * temp = (int*) malloc (sizeof (int));
  temp[0] = 0;
  return temp;
}

我有这个评论:

我可以说,请不要转换malloc的返回值？它不是必需的,可以隐藏错误.

我同意在C中不需要强制转换.它在C++中是强制性的,所以我通常添加它们以防万一我必须在C++中移植代码.

但是,我想知道这样的演员是如何隐藏错误的.有任何想法吗？

编辑:

似乎双方都有非常好的和有效的论据.感谢发帖,伙计们.

我知道我们应该释放任何用malloc分配的变量,但如果我在函数中返回它会怎么样？像这样的东西:

char *somefunction(int somearg){
    char *str;

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

    //some code

    return str;
}

我应该免费吗？我怎么能这样做？

有人可以向我解释为什么一些程序员在malloc前使用(char*)？我知道它返回void但为什么我要它只返回char内存？对不起,我只是编程的新手.谢谢

这已经有很多东西了.他们似乎都暗示你每次调用malloc时都需要做的就是免费调用,并且可能最后释放"指针指针" - 所以你不会在它被释放后最终引用它

例如,如果我有

int** myPtr

然后我只需要

free(myPtr[j])

对于每个j,在最终释放指针之前

free(myPtr)

凉.我在我的程序中已经完成了几次,它似乎工作得很好 - 除了一个案例.我试图弄清楚这种情况有什么不同,我能够在最小的程序中复制症状.

#include "stdafx.h"
#include <stdlib.h>

signed char** getPtr()
{
    unsigned char n = 10;
    unsigned char k = 2;

    signed char** myPtr = (signed char**)malloc(n*sizeof(signed char));
    if (myPtr == NULL) {return NULL;}

    for (unsigned char i = 0; i < n; i++)
    {
        myPtr[i] = (signed char*)malloc(k*sizeof(signed char)); 
        if (myPtr[i] == NULL) {return NULL;}
    }

    for (unsigned char j = 0; j < n; j++)
    {
        for (unsigned …

int (*p)[2];
p=(int(*))malloc(sizeof(int[2])*100);

malloc指向数组的指针的正确方法是什么？我无法找出(int(*))的部分

农产品协议

我一直试图在我的循环链表中调试一个问题12小时.该函数接收一个具有开始和光标字段的ADT.最初的虚拟单元指向自身.插入元素.不允许重复元素.

    int setInsertElementSorted(setADT buffer, setElementT E)
    {
        bool isUnique = true;
        cellT *previous;

        previous = buffer->start;
        buffer->cursor = buffer->start->next;

        while(buffer->cursor != buffer->start){
            if(buffer->cursor->value == E){
                isUnique = false;
            } else if(E < buffer->cursor->value)
                break;
              else {   
                previous = buffer->cursor;
                buffer->cursor = buffer->cursor->next;
            }
        }

        if(isUnique != false){
            cellT *newNode = malloc(sizeof(cellT));
            newNode->value = E;
            previous->next = newNode;
            newNode->next = buffer->cursor;

            buffer->count++;
            return (buffer->count);   
            }
    }

代码接受一系列整数,然后将它们排序到LL参数中.假设用于一组(因此没有重复输入).

输出为:9,8,7,6,5,4,3,2,1

是.. 3,4,5,6,7,8,9(前两个值发生了什么？)

输入类似的东西时:7,3,5,1,9,2

out只有7,9(所以它不能处理超过一个的值... oO)

附加信息:

typedef struct cellT {
    int value; …