blocks|key|4474690|text|因为常量文字在程序的生命周期中以某种方式存储在大多数平台的只读内存区域中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4474691|当您使用free时，您正在尝试释放分配的内存，而不是指针本身，这就是为什么如果您试图在内存的只读区域中执行此操作，它将无法工作|4474692|当您重新分配指针时，您将失去对已分配内存的跟踪，因此会造成内存泄漏。内存泄漏是因为你首先分配了内存并将其分配给你的指针，当你有一个指针指向它时，你可以很容易地释放该内存，但当你没有更多对该内存的引用时，就无法释放。这就是发生的情况，当将文字分配给指针时，该地址没有更多的引用，它被分配了，但它再也无法访问了，这样你就不能释放内存。|4474693|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|$]]

Because constant literals are stored in a way for the lifetime of the program, in a read-only region of memory in most of the platforms.

When you use free you are trying to free the memory allocated, not the pointer itself, that's why it's not gonna work if you try to do that in a read-only region of memory

When you reassign your pointer you're losing track of the allocated memory and therefore creating a memory leak.
The memory leak is created because you first allocated the memory and assign it to your pointer, when you've a pointer pointing to it you can easily free that memory, but when you don't have any more reference to that memory you can't.
That's what's happening, when assign the literal to the pointer there's no more reference to that address, it was allocated but it's not reachable anymore, in this way you can't free the memory.

blocks|key|4474137|text|问题是，在为指针赋另一个值的那一秒，它就丢失了：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4474138|ptr+=+malloc(256);

if+(ptr+==+NULL)++++{
++++printf("Out+of+memory\n");
++++return+1;
}

//+here+you+should+free+your+memory
ptr+=+"michi";
printf("%25s",ptr);

//+this+fails,+because+ptr+now+points+to+the+const+static+string+"michi"+you+have+coded+yourself.+The+assignment+didn't+copy+it,+just+changed+what+ptr+points+to.
free(ptr);|code-block|syntax|javascript|4474139|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The problem is that you have lost the pointer the second you assigned another value to it:

<pre><code>ptr = malloc(256);

if (ptr == NULL) {
 printf("Out of memory\n");
 return 1;
}

// here you should free your memory
ptr = "michi";
printf("%s",ptr);

// this fails, because ptr now points to the const static string "michi" you have coded yourself. The assignment didn't copy it, just changed what ptr points to.
free(ptr);
</code></pre>

blocks|key|4474805|text|+ptr+=+malloc(256);
+...
+ptr+=+"michi";
+printf("%25s",ptr);
+free(ptr);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|4474806|当您将内存分配给ptr，然后将其指向string+literal。因此，指针ptr不再指向由malloc分配的内存。|unstyled|offset|length|style|CODE|4474807|以及未由malloc或类似函数分配的free内存会导致程序出错。|4474808|改为这样做-|4474809|+strcpy(ptr,"michi");|4474810|entityMap^0|0|8|3|I|E|12|3|1A|6|0|4|6|I|4|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|T|8|@$G|U|H|V|I|J]|$G|W|H|X|I|J]|$G|Y|H|Z|I|J]|$G|10|H|11|I|J]]|9|@]|A|$]]|$1|K|3|L|5|F|7|12|8|@$G|13|H|14|I|J]|$G|15|H|16|I|J]]|9|@]|A|$]]|$1|M|3|N|5|F|7|17|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|A|$B|C]]|$1|Q|3|-4|5|F|7|19|8|@]|9|@]|A|$]]]|R|$]]

<pre><code> ptr = malloc(256);
 ...
 ptr = "michi";
 printf("%s",ptr);
 free(ptr);
</code></pre>

As you allocate memory to <code>ptr</code> and then you make it point to <code>string literal</code>. Thus pointer <code>ptr</code> no longer points to memory allocated by <code>malloc</code>.

And to <code>free</code> memory not allocated by <code>malloc</code> or similar functions cause error in program.

Do this instead-

<pre><code> strcpy(ptr,"michi");
</code></pre>

blocks|key|4474893|text|在第一个程序中，您分配了内存|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4474894|ptr+=+malloc(256);|code-block|syntax|javascript|4474895|并用整数值10初始化其第一个sizeof(+int+)字节。|offset|length|style|CODE|4474896|*ptr+=+10;|4474897|指针本身没有改变。所以在这条语句中|4474898|free(ptr);|4474899|指针ptr指向使用malloc分配的内存。|4474900|在第二个程序中，您以与第一个程序相同的方式分配内存|4474901|ptr+=+malloc(256);|4474902|但是随后您使用字符串文字"michi“的第一个字符的地址重新分配了指针本身。|4474903|ptr+=+"michi";|4474904|比较此作业的左侧|4474905|*ptr+=+10;|4474906|和这项任务的|4474907|ptr+=+"michi";|4474908|如你所见，它们是不同的。在第一种情况下，您正在更改分配的内存，而在第二种情况下，您正在更改指针本身。|4474909|因此，在下面的语句中|4474910|4474911|指针ptr未指向先前分配的内存。它指向未使用malloc分配的字符串文本所占用的内存。|4474912|因此，该语句是错误的，并且程序具有内存泄漏，因为使用malloc分配的先前内存未被释放，|4474913|entityMap^0|0|0|E|D|0|0|0|0|2|3|0|0|0|0|0|0|0|0|0|0|0|0|2|3|0|0^^$0|@$1|2|3|4|5|6|7|1L|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1M|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1N|8|@$I|1O|J|1P|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|1Q|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1R|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1S|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1T|8|@$I|1U|J|1V|K|L]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1W|8|@]|9|@]|A|$]]|$1|W|3|X|5|D|7|1X|8|@]|9|@]|A|$E|F]]|$1|Y|3|Z|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|10|3|11|5|D|7|1Z|8|@]|9|@]|A|$E|F]]|$1|12|3|13|5|6|7|20|8|@]|9|@]|A|$]]|$1|14|3|15|5|D|7|21|8|@]|9|@]|A|$E|F]]|$1|16|3|17|5|6|7|22|8|@]|9|@]|A|$]]|$1|18|3|19|5|D|7|23|8|@]|9|@]|A|$E|F]]|$1|1A|3|1B|5|6|7|24|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|6|7|25|8|@]|9|@]|A|$]]|$1|1E|3|R|5|D|7|26|8|@]|9|@]|A|$E|F]]|$1|1F|3|1G|5|6|7|27|8|@$I|28|J|29|K|L]]|9|@]|A|$]]|$1|1H|3|1I|5|6|7|2A|8|@]|9|@]|A|$]]|$1|1J|3|-4|5|6|7|2B|8|@]|9|@]|A|$]]]|1K|$]]

In the first program you allocated memory

<pre><code>ptr = malloc(256);
</code></pre>

and initialized its first <code>sizeof( int )</code> bytes with integer value 10.

<pre><code>*ptr = 10;
</code></pre>

The pointer itself was not changed. So in this statement

<pre><code>free(ptr);
</code></pre>

pointer <code>ptr</code> points to the memory that was allocated using malloc.

In the second program you allocated memory the same way as in the first program

<pre><code>ptr = malloc(256);
</code></pre>

But then you reassigned the pointer itself with the address of the first character of string literal "michi"

<pre><code>ptr = "michi";
</code></pre>

Compare the left sides of this assignment

<pre><code>*ptr = 10;
</code></pre>

and of this assignment

<pre><code>ptr = "michi";
</code></pre>

As you see they are different. In the first case you are changing the allocated memory while in the second case you are changing the pointer itself.

Thus in this statement

<pre><code>free(ptr);
</code></pre>

pointer <code>ptr</code> does not point to the memory that was previously allocated. It points to the memory occupied by the string literal that was not allocated using malloc.

Thus this statement is wrong and the program has a memory leak because the previous memory that was allocated using malloc was not freed,

blocks|key|4474996|text|尝尝这个。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4474997|#include+<stdio.h>

int+main(void)
{
+++++char+++*str:

+++++str+=+(char*)malloc(sizeof(str)+*+4);
+++++printf("Addr+of+str+before:+%25p\n",+str);
+++++str+=+"Joe";
+++++printf("Addr+of+str+after:+%25p\n",str);
+++++return(0);
}+|code-block|syntax|javascript|4474998|/*您将获得以下地址：|4474999|之前的字符串地址:+0x51fc040之后的字符串地址:+0x4006f0|4475000|这是因为您更改了str指向的位置。0x51fc040是使用malloc分配的内存，0x4006f0是字符串文字"Joe“的内存地址。|4475001|我有以下几点建议：*/|4475002|#include+<stdio.h>

int+main(void)
{
+++++char++++*str;

+++++str+=+(char*)malloc(sizeof(str)+*+4);
+++++printf("Addr+of+str+before:+%25p\n",+str);+
+++++str+=strncpy(str,+"Joe",+4);
+++++printf("Addr+of+str+after:+%25p\n",str);
+++++free(str);
+++++return+(0);
}|4475003|4475004|之前的字符串地址:+0x51fc040之后的字符串地址:+0x51fc040|4475005|这是因为strncpy将字符串文字复制到动态分配的内存中。而且它比stcpy更安全，因为它可以防止缓冲区溢出。|4475006|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Z|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|10|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|11|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|12|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|Q|3|H|5|6|7|14|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|15|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|16|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|W|$]]

Try this.

<pre><code>#include &lt;stdio.h&gt;

int main(void)
{
 char *str:

 str = (char*)malloc(sizeof(str) * 4);
 printf("Addr of str before: %p\n", str);
 str = "Joe";
 printf("Addr of str after: %p\n",str);
 return(0);
} 
</code></pre>

/* you will get the following addresses:

Addr of str before: 0x51fc040
Addr of str after: 0x4006f0

this is becuase you changed where str points to. 0x51fc040 is memory allocated using malloc and 0x4006f0 is the memory Adress of the string literal "Joe".

I would advice the following...*/

<pre><code>#include &lt;stdio.h&gt;

int main(void)
{
 char *str;

 str = (char*)malloc(sizeof(str) * 4);
 printf("Addr of str before: %p\n", str); 
 str =strncpy(str, "Joe", 4);
 printf("Addr of str after: %p\n",str);
 free(str);
 return (0);
}
</code></pre>

/* you will get the following addresses:

Addr of str before: 0x51fc040
Addr of str after: 0x51fc040

This is because strncpy copies the string literal to the memory dynamically allocated. and it is safer than stcpy, since it prevents buffer overflow

There are some related discussions about my problem but there are no clearly explanations about my problem.

I thought that I must <code>free()</code> whatever I <code>malloc()</code>, no matter when or where but I have to do it, to prevent a memory leak.
So i have the following program:

<pre><code>#include&lt;stdio.h&gt;
#include&lt;stdlib.h&gt;

int main(void)
{
 int *ptr;

 ptr = malloc(256);

 if (ptr == NULL) {
 printf("Out of memory\n");
 return 1;
 }

 *ptr = 10;

 printf("The value of PTR is:\t%d\n",*ptr);
 free(ptr);

 return 0;
}
</code></pre>

I have a pointer and I dynamically allocated some memory (256), then I checked for <code>NULL</code> letter I <code>free()</code> it.

Until here everything is OK: to the pointer was dynamically allocated some memory and then I <code>free()</code> it.

Now i will use a char pointer this time and after i will dynamically allocated some memory (256), i will point that pointer to a string literal, lets say MICHI:

<pre><code>#include&lt;stdio.h&gt;
#include&lt;stdlib.h&gt;

int main(void)
{
 char *ptr;

 ptr = malloc(256);

 if (ptr == NULL) {
 printf("Out of memory\n");
 return 1;
 }

 ptr = "michi";
 printf("%s",ptr);

 free(ptr);

 return 0;
}
</code></pre>

Here I am doing something wrong because if i try to <code>free()</code> it, well it will not work because it happens that i'm going to free a non-heap object.

So i'm lost in here, because i thought that everything you <code>malloc()</code> you have to <code>free()</code> it.
What exactly make that pointer, after points to a string literal, to not need to be <code>free()</code>ed

Why cannot be pointer free() after pointing to string literal

有一些关于我的问题的相关讨论，但没有关于我的问题的明确解释。我认为我必须free()我malloc()的任何东西，无论何时何地，但我必须这样做，以防止内存泄漏。因此，我有以下程序：#include<stdio.h>#include<stdlib.h>int main(void){ int *ptr; ptr...

问为什么指向字符串文字后不能无指针()
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么指向字符串文字后不能无指针()EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么指向字符串文字后不能无指针()
EN