blocks|key|886681|text|原因：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|886682|您需要返回类型为char(*)[20]。但即使在这种情况下，您也不希望从函数返回指向本地对象的指针。|offset|length|style|CODE|886683|执行以下操作：|886684|使用malloc分配sub_str，并返回char**。|886685|entityMap^0|0|8|B|0|0|L|6|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@$D|T|E|U|F|G]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|M|$]]

Reason: 
you need the return type to be <code>char(*)[20]</code>. But even in this case you don't want to return a pointer to a local object from the function. 
Do: 
Use malloc to allocate sub_str, and return <code>char**</code>.

blocks|key|886727|text|char+*f()
{+++
++++static+char+str[10][20];

++++//+......

++++return+(char+*)str;
}

int+main()
{

++++char+*str;
++++str+=+f();

++++printf(+"%25s\n",+str+);

++++return+0;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|886728|您可以使用static代替malloc。这是你的选择。|unstyled|886729|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>char *f()
{ 
 static char str[10][20];

 // ......

 return (char *)str;
}

int main()
{

 char *str;
 str = f();

 printf( "%s\n", str );

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

You can use static instead of malloc. It's your choice.

blocks|key|886794|text|对于刚开始编程的程序员来说，“栈”或“堆”的概念可能有点混乱，特别是如果您已经开始使用Ruby、Java、Python等高级语言进行编程。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|886795|考虑一下：|886796|char+**get_me_some_strings()+{
++char+*ary[]+=+{"ABC",+"BCD",+NULL};
++return+ary;
}|code-block|syntax|javascript|886797|编译器将正确地发出关于试图返回局部变量的地址的投诉，而您在尝试使用返回的指针时肯定会得到一个分段错误。|886798|和：|886799|char+**get_me_some_strings()+{
++char+*ary[]+=+{"ABC",+"BCD",+NULL};
++char+**strings+=+ary;
++return+strings;
}|886800|将关闭编译器，同时仍然得到相同的讨厌的分段错误。|886801|为了让除了狂热者之外的每个人都高兴，你应该做一些更复杂的事情：|886802|#include+<stdio.h>
#include+<stdlib.h>
#include+<string.h>

char+**get_me_some_strings()+{
++char+*ary[]+=+{+"ABC",+"BCD",+NULL+};
++char+**strings+=+ary;+//+a+pointer+to+a+pointer,+for+easy+iteration
++char+**to_be_returned+=+malloc(sizeof(char*)+*+3);
++int+i+=+0;
++while(*strings)+{
++++to_be_returned[i]+=+malloc(+sizeof(char)+*+strlen(+*strings+)+);
++++strcpy(+to_be_returned[i%2B%2B],+*strings);
++++strings%2B%2B;
++}
++return+to_be_returned;
}|886803|现在使用它：|886804|void+i_need_me_some_strings()+{
++char+**strings+=+get_me_some_strings();
++while(*strings)+{
++++printf("a+fine+string+that+says:+%25s",+*strings);
++++strings%2B%2B;
++}
}|886805|只要记住，当你完成后释放分配的内存，因为没有人会为你做这件事。这适用于所有指针，而不仅仅是指向指针的指针！(我想)。|886806|要更好地理解这一切，您可能还需要阅读以下内容：What+and+where+are+the+stack+and+heap?|offset|length|886807|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/79923/what-and-where-are-the-stack-and-heap^0|0|0|0|0|0|0|0|0|0|0|0|0|N|12|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1D|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1E|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1F|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1G|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|1H|8|@]|9|@]|A|$G|H]]|$1|O|3|P|5|6|7|1I|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1J|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|1K|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|1L|8|@]|9|@]|A|$]]|$1|W|3|X|5|F|7|1M|8|@]|9|@]|A|$G|H]]|$1|Y|3|Z|5|6|7|1N|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|1O|8|@]|9|@$12|1P|13|1Q|1|1R]]|A|$]]|$1|14|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]]|15|$16|$5|17|18|19|A|$1A|1B]]]]

To programmers just starting out, the concept of a "stack" or the "heap" might be a little confusing, especially if you have started programming in a higher level language like Ruby, Java, Python, etc.

Consider:

<pre><code>char **get_me_some_strings() {
 char *ary[] = {"ABC", "BCD", NULL};
 return ary;
}
</code></pre>

The compiler will rightfully issue a complaint about trying to return address of a local variable, and you will most certainly get a segmentation fault trying to use the returned pointer. 

and:

<pre><code>char **get_me_some_strings() {
 char *ary[] = {"ABC", "BCD", NULL};
 char **strings = ary;
 return strings;
}
</code></pre>

will shut the compiler up, while still getting the same nasty segmentation fault.

To keep everyone but the zealots happy, you would do something a little more elaborate:

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

char **get_me_some_strings() {
 char *ary[] = { "ABC", "BCD", NULL };
 char **strings = ary; // a pointer to a pointer, for easy iteration
 char **to_be_returned = malloc(sizeof(char*) * 3);
 int i = 0;
 while(*strings) {
 to_be_returned[i] = malloc( sizeof(char) * strlen( *strings ) );
 strcpy( to_be_returned[i++], *strings);
 strings++;
 }
 return to_be_returned;
}
</code></pre>

now use it:

<pre><code>void i_need_me_some_strings() {
 char **strings = get_me_some_strings();
 while(*strings) {
 printf("a fine string that says: %s", *strings);
 strings++;
 }
}
</code></pre>

Just remember to free the allocated memory when you are done, cuz nobody will do it for you. That goes for all the pointers, not just the pointer to the pointers! (i think).

To make more sense of it all, you might also want to read this: <a href="https://stackoverflow.com/questions/79923/what-and-where-are-the-stack-and-heap">What and where are the stack and heap?</a>

blocks|key|1101720|text|编译器错误的原因很简单，但不是您真正想要做的事情的答案。您声明函数返回char+*，而返回char+**。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1101721|在不知道你正在做什么的细节的情况下，我将假设以下两件事中的一件是真的：|1101722|1)该函数的作用是创建和返回字符串数组。2)该函数对字符串数组执行一些操作。|1101723|如果#1为真，则需要几个malloc调用才能完成此工作(实际上只需两个调用即可完成，但为了简单起见，我将使用几个)。|1101724|如果你不知道数组应该有多大，你的函数声明应该是这样的：|1101725|char+**+allocateStrings+(+int+numberOfStrings,+int+strLength+);|code-block|syntax|javascript|1101726|这样做的原因是因为您实际上返回了一个指向指针数组的指针，并且您需要知道有多少个字符串以及每个字符串有多长。|1101727|char+**+allocateStrings+(+int+numberOfStrings,+int+strLength+)
{
++++int+i;

++++//The+first+line+is+allocating+an+array+of+pointers+to+chars,+not+actually+allocating+any+strings+itself
++++char+**+retVal+=+(+char+**+)+malloc+(+sizeof+(+char+*+)+*+numberOfStrings+);

++++//For+each+string,+we+need+to+malloc+strLength+chars
++++for+(+i+=+0;+i+<+numberOfStrings;+i+%2B%2B+)
++++{
++++++++//Allocate+one+extra+char+for+the+null+pointer+at+the+end
++++++++retVal+[+i+]+=+(+char+*+)+malloc+(+sizeof+(+char+)+*+(+strLength+%2B+1+)+);
++++}

++++return+retVal;
}|1101728|正如其他人指出的那样，最好的做法是让分配的东西也做释放分配。因此需要一个清理函数。|1101729|void+cleanupStrings+(+char+**+strArray,+int+numberOfStrings+)
{
++++int+i;

++++for+(+i+=+0;+i+<+numberOfStrings;+i+%2B%2B+)
++++{
++++++++//Should+be+checking+to+see+if+this+is+a+null+pointer.
++++++++free+(+strArray+[+i+]+);
++++}

++++//Once+the+strings+themselves+are+freed,+free+the+actual+array+itself.
++++free+(+strArray+);
}|1101730|现在，请记住，一旦调用了cleanup函数，您就不再有权访问数组。尝试仍然使用它很可能会导致您的应用程序崩溃。|1101731|如果#2为true，则需要分配字符串、处理字符串并清除它们。你应该使用上面的两个函数来分配/释放你的字符串，然后使用第三个函数来处理它们。|1101732|void+processStrings+(+char+**+strArray,+int+numberOfStrings,+int+strLength+);|1101733|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|16|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|17|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|18|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|19|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1B|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|1C|8|@]|9|@]|A|$]]|$1|U|3|V|5|L|7|1D|8|@]|9|@]|A|$M|N]]|$1|W|3|X|5|6|7|1E|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1F|8|@]|9|@]|A|$]]|$1|10|3|11|5|L|7|1G|8|@]|9|@]|A|$M|N]]|$1|12|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|13|$]]

The cause of your compiler error is simple, but not the answer to what you really want to do. You are declaring that the function returns a char *, while returning a char **.

Without knowing the details of what you're doing, I'm going to assume one of two things are true:

1) The purpose of the function is to create and return an array of strings.
2) The function performs some operation(s) on an array of strings.

If #1 is true, you need several malloc calls to make this work (It can really be done with only two, but for purposes of simplicity, I'll use several).

If you don't know how large the array is supposed to be, your function declaration should look like this:

<pre><code>char ** allocateStrings ( int numberOfStrings, int strLength );
</code></pre>

The reason for this is because you're essentially returning a pointer to an array of pointers and you need to know how many strings and how long each string is.

<pre><code>char ** allocateStrings ( int numberOfStrings, int strLength )
{
 int i;

 //The first line is allocating an array of pointers to chars, not actually allocating any strings itself
 char ** retVal = ( char ** ) malloc ( sizeof ( char * ) * numberOfStrings );

 //For each string, we need to malloc strLength chars
 for ( i = 0; i &lt; numberOfStrings; i ++ )
 {
 //Allocate one extra char for the null pointer at the end
 retVal [ i ] = ( char * ) malloc ( sizeof ( char ) * ( strLength + 1 ) );
 }

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

As somebody else pointed out, it's best practice to have whatever does the allocating also do the deallocating. So a cleanup function is needed.

<pre><code>void cleanupStrings ( char ** strArray, int numberOfStrings )
{
 int i;

 for ( i = 0; i &lt; numberOfStrings; i ++ )
 {
 //Should be checking to see if this is a null pointer.
 free ( strArray [ i ] );
 }

 //Once the strings themselves are freed, free the actual array itself.
 free ( strArray );
}
</code></pre>

Now, keep in mind that once the cleanup function is called, you no longer have access to the array. Trying to still use it will most likely cause your application to crash.

If #2 is true, then you want to allocate the strings, process the strings, and clean them up. You should use the two functions above to allocate/deallocate your strings, then a third function to do whatever with them.

<pre><code>void processStrings ( char ** strArray, int numberOfStrings, int strLength );
</code></pre>

blocks|key|886926|text|我使用该函数将字符串拆分为字符串数组|type|unstyled|depth|inlineStyleRanges|entityRanges|data|886927|char++**+split(char+*str,+char+*delimiter)
{
++++char+*temp=strtok(str,delimiter);
++++char+*arr[]={temp};
++++int+i=0;

++++while(true)
++++{
+++++++elm=strtok+(NULL,+delimiter);

+++++++if(!temp)+break;

+++++++arr[%2B%2Bi]=temp;
++++}

++++return+arr;
}|code-block|syntax|javascript|886928|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|$]]

i use that function to split a string to string array

<pre><code>char ** split(char *str, char *delimiter)
{
 char *temp=strtok(str,delimiter);
 char *arr[]={temp};
 int i=0;

 while(true)
 {
 elm=strtok (NULL, delimiter);

 if(!temp) break;

 arr[++i]=temp;
 }

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

blocks|key|886970|text|首先，你不能返回存储在堆栈中的字符串变量，你需要使用malloc来动态分配内存，这里给出了数据，示例Go+https://nxtspace.blogspot.com/2018/09/return-array-of-string-and-taking-in-c.html得到一个正确的答案|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|886971|entityMap|0|LINK|mutability|MUTABLE|url|https://nxtspace.blogspot.com/2018/09/return-array-of-string-and-taking-in-c.html^0|1H|29|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

first of all You can not return a string variable which is stored in stack you need use malloc to allocate memory dynamicaly here is given datails with the example
Go <a href="https://nxtspace.blogspot.com/2018/09/return-array-of-string-and-taking-in-c.html" rel="nofollow noreferrer">https://nxtspace.blogspot.com/2018/09/return-array-of-string-and-taking-in-c.html</a>
get a proper answer

<pre><code>char * myFunction () {

 char sub_str[10][20]; 
 return sub_str;

} 

void main () {

 char *str;
 str = myFunction();

}
</code></pre>

error:return from incompatible pointer type

thanks

how to return a string array from a function

编译器

Python

Java

char * myFunction () {    char sub_str[10][20];     return sub_str;} void main () {    char *str;    str = myFunction();}错误:从不兼容的指针类型返回谢谢

问如何从函数返回字符串数组
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何从函数返回字符串数组EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何从函数返回字符串数组
EN