字符串放在堆內(nèi)存中，會(huì)不會(huì)有啥比較壞的影響？

craaazy123

rt，先貼一下代碼，以下是to_lower_case1函數(shù)，主要是將字符串轉(zhuǎn)換為小寫：

char *to_lower_case1(const char *src) {
        if(is_empty(src)) return "";
         
        // 申請(qǐng)堆內(nèi)存
        char *dst = (char *)calloc(strlen(src), sizeof(char *));
        
        // 將原來的拷貝一份
        strcpy(dst, src);
        char *p = dst;
        
       // 遍歷轉(zhuǎn)小寫
        for(; *p != '\0'; p++) {
                if(*p >= 'A' && *p <= 'Z') {
                        *p += 32;
                }
        }
      
        return dst;
}

這樣調(diào)用是比較方便的了，（方式一）：
printf("%s\n", to_lower_case1("This is a String."));

較之前的（方式二）：
char *src = "This Is A String.";
int len = strlen(src);
char dst[len];
printf("%s\n", to_upper_case(dst, src));

注意to_upper_case函數(shù)未貼出，其實(shí)和to_lower_case1差不多是一樣的。


我比較疑惑的是to_lower_case1返回的指針是需要自己手動(dòng)釋放的，但是如果按照方式一調(diào)用，內(nèi)存會(huì)不會(huì)釋放掉？

貼兩個(gè)文件，有問題的話，麻煩大家提出來，我是來學(xué)習(xí)的，謝謝:
string_util.h

1. #ifndef __STRING_UTIL__
   
2. #define __STRING_UTIL__
   
3. 
   
4. typedef int bool;
   
5. 
   
6. //char **split(const char* src, const char *delim);
   
7. 
   
8. int first_index_of(const char *src, const char *chs);
   
9. int last_index_of(const char *src, const char *chs);
   
10. bool is_empty(const char *s);
    
11. 
    
12. //char *to_lower_case(char *dst, const char *src);
    
13. char *to_lower_case(const char *src);
    
14. char *to_upper_case(const char *src);
    
15. //char *to_upper_case(char *dst, const char *src);
    
16. char *trim(const char *src);
    
17. char *ltrim(const char *src);
    
18. char *rtrim(const char *src);
    
19. 
    
20. char *substr(const char *src, int start, int len);
    
21. void destroy(char *s);
    
22. 
    
23. #define char_at(str, i) (strlen(str) > i) ? *(str + i) : -1
    
24. 
    
25. 
    
26. #endif

復(fù)制代碼

string_util.c

1. 
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <string.h>
   
5. 
   
6. #define TRUE 1
   
7. #define FALSE 0
   
8. 
   
9. #include "string_util.h"
   
10. 
    
11. int main(int argc, char** argv) {
    
12.            //split("This is a string", " ");
    
13. 
    
14.     //printf("%d\n", first_index_of("This is a string.", ""));
    
15.         //printf("%d\n", is_empty(""));
    
16.         /*char *src = "This Is A String.";
    
17.         int len = strlen(src);
    
18.         char dst[len];
    
19.         printf("%s\n", to_upper_case(dst, src));*/
    
20. 
    
21.         char *s = to_lower_case("This is a String.");
    
22.         printf("%s\n", s);
    
23.         destroy(s);
    
24. 
    
25. /*        char *s = substr("This is a string.", 5, -1);
    
26.         int l = strlen(s);
    
27.         printf("s = %s, len = %d\n", s, l);
    
28.         destroy(s);*/
    
29. 
    
30. /*        char *s = ltrim("  \t \r \n");
    
31.         int l = strlen(s);
    
32.         printf("s=%s, len=%d\n", s, l);
    
33.         destroy(s);*/
    
34. 
    
35. /*
    
36.         char *s = trim(" \t \r \n This is a String.  \t \r \n");
    
37.         int l = strlen(s);
    
38.         printf("s=%s, len=%d\n", s, l);
    
39.         destroy(s);*/
    
40. 
    
41.         //printf("%c\n", char_at("This is a string.", 1));
    
42. 
    
43.         return 0;
    
44. }
    
45. 
    
46. /*char **split(const char* src, const char *delim) {
    
47.         if(src == NULL || delim == NULL) return NULL;
    
48. 
    
49.         const char *p = src;
    
50.         const char **t = NULL;
    
51.         for(; *p != '\0'; p++) {
    
52.                
    
53.         }
    
54. 
    
55.        
    
56. 
    
57.         return NULL;
    
58. }*/
    
59. 
    
60. 
    
61. int first_index_of(const char *src, const char *chs) {
    
62.         if(is_empty(src) || is_empty(chs))
    
63.                 return -1;
    
64. 
    
65.         const char *p = src;
    
66.         const char *q = chs;
    
67. 
    
68.         int len = strlen(chs);
    
69.         int i;
    
70. 
    
71.         for(i = 0; *p != '\0' || *q != '\0'; p++, i++) {
    
72.                 if(*p == *q++) {
    
73.                         if(*q == '\0') break;
    
74.                 } else {
    
75.                         q = chs;
    
76.                 }
    
77.         }
    
78.         return (*q == '\0') ? (i - len + 1) : -1;
    
79. }
    
80. 
    
81. int last_index_of(const char *src, const char *chs) {
    
82.         if(is_empty(src) || is_empty(chs))
    
83.                 return -1;
    
84. 
    
85.        
    
86. }
    
87. 
    
88. bool is_empty(const char *s) {
    
89.         return (s == NULL || s == "");
    
90. }
    
91. 
    
92. 
    
93. 
    
94. /*char *to_lower_case(char *dst, const char *src) {
    
95.         if(is_empty(src)) {
    
96.                 strcpy(dst, "");
    
97.                 return dst;
    
98.         }
    
99.                
    
100.         strcpy(dst, src);
     
101.         char *p = dst;
     
102. 
     
103.         for(; *p != '\0'; p++) {
     
104.                 if(*p >= 'A' && *p <= 'Z') {
     
105.                         *p += 32;
     
106.                 }
     
107.         }
     
108. 
     
109.         return dst;
     
110. }        */
     
111. 
     
112. /*char *to_upper_case(char *dst, const char *src) {
     
113.         if(is_empty(src)) {
     
114.                 strcpy(dst, "");
     
115.                 return dst;
     
116.         }
     
117. 
     
118.         strcpy(dst, src);
     
119.         char *p = dst;
     
120. 
     
121.         for(; *p != '\0'; p++) {
     
122.                 if(*p >= 'a' && *p <= 'z') {
     
123.                         *p -= 32;
     
124.                 }
     
125.         }
     
126.         return dst;
     
127. }
     
128. */
     
129. char *to_lower_case(const char *src) {
     
130.         if(is_empty(src)) return "";
     
131. 
     
132.         char *dst = (char *)calloc(strlen(src), sizeof(char));
     
133. 
     
134.         strcpy(dst, src);
     
135.         char *p = dst;
     
136. 
     
137.         for(; *p != '\0'; p++) {
     
138.                 if(*p >= 'A' && *p <= 'Z') {
     
139.                         *p += 32;
     
140.                 }
     
141.         }
     
142. 
     
143.         return dst;
     
144. }
     
145. 
     
146. char *to_upper_case(const char *src) {
     
147.         if(is_empty(src)) return "";
     
148. 
     
149.         char *dst = (char *)calloc(strlen(src), sizeof(char));
     
150. 
     
151.         strcpy(dst, src);
     
152.         char *p = dst;
     
153. 
     
154.         for(; *p != '\0'; p++) {
     
155.                 if(*p >= 'a' && *p <= 'z') {
     
156.                         *p -= 32;
     
157.                 }
     
158.         }
     
159. 
     
160.         return dst;
     
161. }
     
162. 
     
163. char *ltrim(const char* src) {
     
164.         if(is_empty(src))
     
165.                 return "";
     
166. 
     
167.         const char *p = src;
     
168.         while(*p++ != '\0' && isspace(*p))
     
169.                 ;
     
170. 
     
171.         int len = strlen(p);
     
172.         if(len > 0) {
     
173.                 char *dst = (char *)calloc(len, sizeof(char *));
     
174.                 strcpy(dst, p);
     
175.                 return dst;
     
176.         }
     
177.         return "";
     
178. }       
     
179. 
     
180. char *rtrim(const char* src) {
     
181.         if(is_empty(src))
     
182.                 return "";
     
183.         int len = strlen(src);
     
184.         const char *p = src + len;
     
185. 
     
186.         int i;
     
187.         for(i = len - 1; i >= 0 && isspace(*(src + i)); i--)
     
188.                 ;
     
189. 
     
190.         if(i > 0) {
     
191.                 char *dst = (char *)calloc(i + 1, sizeof(char *));
     
192.                 strncpy(dst, src, i + 1);
     
193.                 return dst;
     
194.         }
     
195.         return "";
     
196. 
     
197. }
     
198. 
     
199. char *trim(const char* src) {
     
200.         return rtrim(ltrim(src));
     
201. }
     
202. 
     
203. char *substr(const char *src, int start, int len) {
     
204. 
     
205.         if(is_empty(src))
     
206.                 return "";
     
207. 
     
208.         int n = strlen(src);
     
209.         if(n < start)
     
210.                 return "";
     
211. 
     
212.         const char *p = src;
     
213.         int i;
     
214.         for(i = 0; i < start; i++, p++)
     
215.                 ;
     
216. 
     
217.         char *dst = (char *)calloc((n - start + 1), sizeof(char));
     
218.        
     
219.         if(len > 0){
     
220.                 strncpy(dst, p, len);
     
221.         } else {
     
222.                 strcpy(dst, p);
     
223.         }
     
224.         return dst;
     
225. }
     
226. 
     
227. void destroy(char * s) {
     
228.         if(s == NULL) return;
     
229.         if(strlen(s) > 0) free(s);
     
230.         s = NULL;
     
231. }

復(fù)制代碼

hellioncu

返回的指針未保存，當(dāng)然無法釋放了

craaazy123

回復(fù) 2# hellioncu


非得這樣嗎？

char *s = to_lower_case1("This is a String.");
printf("%s\n", s);
free(s);

   

hellioncu

craaazy123 發(fā)表于 2014-10-26 10:17
回復(fù) 2# hellioncu

對(duì)于你的to_lower_case1，只能這樣

bruceteen

建議用 方式二

另外，對(duì)于 char *dst = (char *)calloc(strlen(src), sizeof(char *));
首先，根本沒必要用calloc，而應(yīng)該用malloc；其次，不應(yīng)該是sizeof(char *)，而應(yīng)該是sizeof(char)，同時(shí)strlen(src)應(yīng)該是strlen(src)+1

zhaohongjian000

返回空的時(shí)候這么寫的：

1.          if(is_empty(src)) return "";

復(fù)制代碼

其他情況內(nèi)存又是這么申請(qǐng)的：

1. char *dst = (char *)calloc(strlen(src), sizeof(char *));

復(fù)制代碼

這實(shí)現(xiàn)有問題�？盏那闆r下調(diào)用free釋放返回的指針必然是錯(cuò)的。

craaazy123

回復(fù) 5# bruceteen

之前看了個(gè)帖子是這么寫的，當(dāng)時(shí)想都沒想就copy過來了，發(fā)現(xiàn)輸出與預(yù)期一致就沒管了。


   

craaazy123

回復(fù) 6# zhaohongjian000

以前用面向?qū)ο蟮恼Z言用習(xí)慣了，用gcc編譯后也沒告警，不知道這樣返回的問題在哪？能不能解釋一下？ 好久沒寫c代碼了

zhaohongjian000

回復(fù) 8# craaazy123


    C和C++中，字符串字面量（諸如 ""  "string"  "hello"）不需要也不能用free釋放。