blocks|key|1751911|text|您已经在foo中分配了arr，但该指针值存储在调用堆栈中。如果你想这样做，可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1751912|void+foo(+int+**+arr)+{
++++*arr+=+(int+*)malloc(+sizeof(int)+*+25+);
++++(*arr)[3]+=+69;
}|code-block|syntax|javascript|1751913|在main中，只需传递一个指向foo的指针(如foo(&arr))|1751914|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You've allocated arr in foo, but that pointers value is stored in the call stack. If you want to do this, do it like this:

<pre><code>void foo( int ** arr) {
 *arr = (int *)malloc( sizeof(int) * 25 );
 (*arr)[3] = 69;
}
</code></pre>

And in main, simply pass a pointer to foo (like foo(&amp;arr))

blocks|key|1751955|text|您通过值传递指针，而不是通过引用，因此无论您在foo中对arr做什么，都不会在foo-function之外产生任何影响。正如m_pGladiator所写的，一种方法是像这样声明一个对指针的引用(只有在C%2B%2B+btw中才有可能。C不知道引用)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1751956|int+main(int+argc,+char+**+argv)+{
++int+*+arr;

++foo(arr);
++printf("car[3]=%25d\n",arr[3]);
++free+(arr);
++return+1;
}

void+foo(int+*+&arr+)+{
++arr+=+(int*)+malloc(+sizeof(int)*25+);
++arr[3]+=+69;
}|code-block|syntax|javascript|1751957|另一种(更好的imho)方法是不将指针作为参数传递，而是返回一个指针：|1751958|int+main(int+argc,+char+**+argv)+{
++int+*+arr;

++arr+=+foo();
++printf("car[3]=%25d\n",arr[3]);
++free+(arr);
++return+1;
}

int+*+foo(void+)+{
++int+*+arr;
++arr+=+(int*)+malloc(+sizeof(int)*25+);
++arr[3]+=+69;
++return+arr;
}|1751959|您可以将指针传递给指针。这是通过引用传递的C方法。语法有点复杂，但很好--这就是C语言...|1751960|int+main(int+argc,+char+**+argv)+{
++int+*+arr;

++foo(&arr);
++printf("car[3]=%25d\n",arr[3]);
++free+(arr);
++return+1;
}

void+foo(int+**+arr+)+{
++(*arr)+=+(int*)+malloc(+sizeof(int)*25+);
++(*arr)[3]+=+69;
}|1751961|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

You pass the pointer by value, not by reference, so whatever you do with arr inside foo will not make a difference outside the foo-function. 
As m_pGladiator wrote one way is to declare a reference to pointer like this (only possible in C++ btw. C does not know about references):

<pre><code>int main(int argc, char ** argv) {
 int * arr;

 foo(arr);
 printf("car[3]=%d\n",arr[3]);
 free (arr);
 return 1;
}

void foo(int * &amp;arr ) {
 arr = (int*) malloc( sizeof(int)*25 );
 arr[3] = 69;
}
</code></pre>

Another (better imho) way is to not pass the pointer as an argument but to return a pointer:

<pre><code>int main(int argc, char ** argv) {
 int * arr;

 arr = foo();
 printf("car[3]=%d\n",arr[3]);
 free (arr);
 return 1;
}

int * foo(void ) {
 int * arr;
 arr = (int*) malloc( sizeof(int)*25 );
 arr[3] = 69;
 return arr;
}
</code></pre>

And you can pass a pointer to a pointer. That's the C way to pass by reference. Complicates the syntax a bit but well - that's how C is...

<pre><code>int main(int argc, char ** argv) {
 int * arr;

 foo(&amp;arr);
 printf("car[3]=%d\n",arr[3]);
 free (arr);
 return 1;
}

void foo(int ** arr ) {
 (*arr) = (int*) malloc( sizeof(int)*25 );
 (*arr)[3] = 69;
}
</code></pre>

blocks|key|1752017|text|如果参数(arr)不是通过引用(&)传入的，则不能更改该参数的值。通常，您希望返回指针，因此您的方法应该是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1752018|arr=foo()；|1752019|尝试重新分配参数是很糟糕的；我不推荐(&)解决方案。|1752020|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

You cannot change the value of your argument (arr) if it's not passed in by reference (&amp;). In general, you would want to return the pointer, so your method should be:

arr=foo();

It's bad juju to try to reassign arguments; I don't recommend the (&amp;) solution.

blocks|key|1537126|text|foo接收int指针的本地副本，为其分配内存，并在超出作用域时泄漏内存。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1537127|解决这个问题的一种方法是让foo返回指针：|1537128|int+*+foo()+{
++return+(int*)+malloc(+sizeof(int)*25+);
}

int+main()+{
++++int*+arr+=+foo();
}|code-block|syntax|javascript|1537129|另一种方法是向foo传递一个指向指针的指针|1537130|void+foo(int+**+arr)+{
+++*arr+=+malloc(...);
}

int+main()+{
++++foo(&arr);
}|1537131|在C%2B%2B中，修改foo以接受对指针的引用会更简单。在C%2B%2B中需要做的唯一更改是将foo更改为|1537132|void+foo(int+*+&+arr)|1537133|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

foo receives a local copy of the int pointer, alloactes memory to it and leaks that memory when it goes out of scope.

One way to fix this to get foo to return the pointer:

<pre><code>int * foo() {
 return (int*) malloc( sizeof(int)*25 );
}

int main() {
 int* arr = foo();
}
</code></pre>

Another is to pass foo a pointer to a pointer

<pre><code>void foo(int ** arr) {
 *arr = malloc(...);
}

int main() {
 foo(&amp;arr);
}
</code></pre>

In C++ it is simpler to modify foo to accept a reference to a pointer. The only change you need in C++ is to change foo to

<pre><code>void foo(int * &amp; arr)
</code></pre>

blocks|key|1752173|text|因为你是通过值来传递指针的，所以main中的arr指针并没有指向分配的内存。这意味着两件事:你得到了一个内存泄漏(不，在函数foo完成后内存没有被释放)，当你访问main中的arr指针时，你正在访问某个任意范围的内存，因此你没有打印出3，因此free()拒绝工作。您很幸运，在访问main中的arr3时没有遇到分段错误。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1752174|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Since your are passing the pointer by value, the arr pointer inside main isn't pointing to the allocated memory. This means two thing: you've got yourself a memory leak (NO, the memory isn't freed after the function foo completes), and when you access the arr pointer inside main you are accessing some arbitrary range of memory, hence you don't get 3 printed out and hence free() refuses to work. You're lucky you didn't get a segmentation fault when accessing arr[3] inside main.

I think I've got it down to the most basic case:

<pre><code>int main(int argc, char ** argv) {
 int * arr;

 foo(arr);
 printf("car[3]=%d\n",arr[3]);
 free (arr);
 return 1;
}

void foo(int * arr) {
 arr = (int*) malloc( sizeof(int)*25 );
 arr[3] = 69;
}
</code></pre>

The output is this:

<pre class="lang-none prettyprint-override"><code>&gt; ./a.out 
 car[3]=-1869558540
 a.out(4100) malloc: *** error for object 0x8fe01037: Non-aligned pointer
 being freed
 *** set a breakpoint in malloc_error_break to debug
&gt;
</code></pre>

If anyone can shed light on where my understanding is failing, it'd be greatly appreciated.

Malloc inside a function call appears to be getting freed on return?

我想我已经把它归结为最基本的情况：int main(int argc, char ** argv) {  int * arr;  foo(arr);  printf("car[3]=%d\n",arr[3]);  free (arr);  return 1;}void foo(int * arr) {  arr = (...

问函数调用中的Malloc似乎在返回时被释放了？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问函数调用中的Malloc似乎在返回时被释放了？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问函数调用中的Malloc似乎在返回时被释放了？
EN