blocks|key|179253|text|您的函数返回类型是单个字符(char)。您应该返回一个指向字符数组第一个元素的指针。如果你不能使用指针，那么你就完蛋了。:(|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|179254|entityMap^0|E|4|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Your function return type is a single character (<code>char</code>). You should return a pointer to the first element of the character array. If you can't use pointers, then you are screwed. :(

blocks|key|355632|text|您的问题出在函数的返回类型上--一定是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|355633|char+*myFunction()|code-block|syntax|javascript|355634|...and，那么你的原始配方就会起作用。|355635|请注意，您不能在没有指针的情况下使用C字符串。|355636|另外:打开你的编译器警告。它应该警告您在没有显式转换的情况下将char+*转换为char的返回行。|offset|length|style|CODE|355637|entityMap^0|0|0|0|0|V|6|14|4|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]|$M|Z|N|10|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

Your problem is with the return type of the function - it must be:

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

...and then your original formulation will work.

Note that you cannot have C strings without pointers being involved, somewhere along the line.

Also: Turn up your compiler warnings. It should have warned you about that return line converting a <code>char *</code> to <code>char</code> without an explicit cast.

blocks|key|1657102|text|char只是一个单字节字符。它不能存储字符串，也不是一个指针(显然你不能拥有它)。因此，如果不使用指针(+char[]是它的语法糖)，就不能解决问题。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1657103|entityMap^0|0|4|1H|6|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

A <code>char</code> is only a single one-byte character. It can't store the string of characters, nor is it a pointer (which you apparently cannot have). Therefore you cannot solve your problem without using pointers (which <code>char[]</code> is syntactic sugar for).

blocks|key|355686|text|您的函数签名需要是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|355687|const+char+*+myFunction()
{
++++return+"my+String";
}|code-block|syntax|javascript|355688|背景：|355689|它是C&+C%2B%2B的基础，但应该少做一些讨论。|355690|在C中(&+C%2B%2B+)，字符串只是一个以零字节结尾的字节数组-因此术语“字符串-零”用来表示这种特殊风格的字符串。还有其他类型的字符串，但在C+(&+C%2B%2B)中，这种风格是语言本身固有的。其他语言(Java、Pascal等)使用不同的方法来理解"my+string"。|offset|length|style|CODE|355691|如果你曾经使用过Windows+API+(在C%2B%2B中)，你会经常看到像这样的函数参数："LPCSTR+lpszName“。“sz”部分表示“string-zero”的概念:带有null+(/zero)终止符的字节数组。|355692|澄清：|355693|出于这个“介绍”的目的，我将“字节”和“字符”这两个词互换使用，因为这样更容易学习。请注意，还有其他方法(宽字符和多字节字符系统(mbcs))可用于处理国际字符。UTF-8就是mbcs的一个例子。为了便于介绍，我悄悄地“跳过”了所有这些。|355694|内存：|355695|这意味着像"my+string"这样的字符串实际上使用了9%2B1+(=10!)字节。当你最终开始动态分配字符串时，知道这一点很重要。|355696|所以，没有这个‘终止零’，你就没有一个字符串。您在内存中挂起了一个字符数组(也称为缓冲区)。|355697|数据的持久性：|355698|以这种方式使用该函数：|355699|const+char+*+myFunction()
{
++++return+"my+String";
}

int+main()
{
++++const+char*+szSomeString+=+myFunction();+//+Fraught+with+problems
++++printf("%25s",+szSomeString);
}|355700|..。通常会给你带来随机的未处理的异常/段错误等，特别是“在路上”。|355701|简而言之，尽管我的答案是正确的--如果你以这种方式使用程序，那么10次中有9次会导致程序崩溃，特别是如果你认为这样做是“好的做法”。简而言之:通常不是这样的。|355702|例如，想象一下在未来的某个时间，字符串现在需要以某种方式进行操作。通常，程序员会“选择最简单的方法”，并(尝试)编写如下代码：|355703|const+char+*+myFunction(const+char*+name)
{
++++char+szBuffer[255];
++++snprintf(szBuffer,+sizeof(szBuffer),+"Hi+%25s",+name);
++++return+szBuffer;
}|355704|也就是说，您的程序将崩溃，因为在调用szBuffer中的printf()时，编译器(可能会也可能没有)已经释放了main()使用的内存。(您的编译器也应该事先就此类问题发出警告。)|355705|有两种方法可以返回不那么容易呕吐的字符串。|355706|355707|返回存活一段时间的缓冲区(静态或动态分配)。在C%2B%2B中，使用'helper+classes‘(例如，std::string)来处理数据的持久性(这需要更改函数的返回值)，或者|ordered-list-item|355708|将缓冲区传递给使用helper填充的函数|355709|355710|请注意，在C中不使用指针是不可能使用字符串的，正如我已经说明的那样，它们是同义词。即使在带有模板类的C%2B%2B中，也总会有缓冲区(即指针)在后台使用。|355711|因此，为了更好地回答(现在修改后的问题)。(肯定会有各种各样的“其他答案”可以提供。)|355712|更安全的答案：|355713|示例1，使用静态分配的字符串：|BOLD|355714|const+char*+calculateMonth(int+month)
{
++++static+char*+months[]+=+{"Jan",+"Feb",+"Mar"+....+};
++++static+char+badFood[]+=+"Unknown";
++++if+(month+<+1+%7C%7C+month+>+12)
++++++++return+badFood;+//+Choose+whatever+is+appropriate+for+bad+input.+Crashing+is+never+appropriate+however.
++++else
++++++++return+months[month-1];
}

int+main()
{
++++printf("%25s",+calculateMonth(2));+//+Prints+"Feb"
}|355715|static在这里所做的(许多程序员不喜欢这种类型的“分配”)是将字符串放入程序的数据段中。也就是说，它是永久分配的。|355716|如果您迁移到C%2B%2B，您将使用类似的策略：|355717|class+Foo
{
++++char+_someData[12];
public:
++++const+char*+someFunction()+const
++++{+//+The+final+'const'+is+to+let+the+compiler+know+that+nothing+is+changed+in+the+class+when+this+function+is+called.
++++++++return+_someData;
++++}
}|355718|..。但是，如果您编写的是自己使用的代码(而不是与他人共享的库的一部分)，那么使用帮助器类可能会更容易一些，比如std::string。|355719|示例2，使用调用者定义的缓冲区：|355720|这是更“安全”的传递字符串的方式。返回的数据不受主叫方的操纵。也就是说，示例1很容易被主叫方滥用，并使您暴露于应用程序错误。这样，它更安全(尽管使用了更多的代码行)：|355721|void+calculateMonth(int+month,+char*+pszMonth,+int+buffersize)
{
++++const+char*+months[]+=+{"Jan",+"Feb",+"Mar"+....+};+//+Allocated+dynamically+during+the+function+call.+(Can+be+inefficient+with+a+bad+compiler)
++++if+(!pszMonth+%7C%7C+buffersize<1)
++++++++return;+//+Bad+input.+Let+junk+deal+with+junk+data.
++++if+(month<1+%7C%7C+month>12)
++++{
++++++++*pszMonth+=+'\0';+//+Return+an+'empty'+string
++++++++//+OR:+strncpy(pszMonth,+"Bad+Month",+buffersize-1);
++++}
++++else
++++{
++++++++strncpy(pszMonth,+months[month-1],+buffersize-1);
++++}
++++pszMonth[buffersize-1]+=+'\0';+//+Ensure+a+valid+terminating+zero!+Many+people+forget+this!
}

int+main()
{
++++char+month[16];+//+16+bytes+allocated+here+on+the+stack.
++++calculateMonth(3,+month,+sizeof(month));
++++printf("%25s",+month);+//+Prints+"Mar"
}|355722|第二种方法更好的原因有很多，特别是如果您正在编写供其他人使用的库(您不需要锁定到特定的分配/释放方案，第三方不能破坏您的代码，您也不需要链接到特定的内存管理库)，但像所有代码一样，它取决于您最喜欢什么。出于这个原因，大多数人选择例如1，直到他们被烧了很多次，以至于他们拒绝再这样写了;)|355723|免责声明：|355724|我几年前退休了，我的C现在有点生疏了。这段演示代码应该都可以用C正确编译(但对于任何C%2B%2B编译器都可以)。|355725|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/UTF-8^0|0|0|0|0|3E|B|0|0|0|29|5|0|0|0|5|B|0|0|0|0|0|0|0|0|0|I|8|S|8|1K|6|0|0|0|1E|B|0|0|0|0|0|0|0|F|0|0|0|6|0|0|0|1K|B|0|0|G|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|2U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|2V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|2W|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|2X|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|2Y|8|@$M|2Z|N|30|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|31|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|32|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|33|8|@]|9|@$M|34|N|35|1|36]]|A|$]]|$1|W|3|X|5|6|7|37|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|38|8|@$M|39|N|3A|O|P]]|9|@]|A|$]]|$1|10|3|11|5|6|7|3B|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|3C|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|3D|8|@]|9|@]|A|$]]|$1|16|3|17|5|D|7|3E|8|@]|9|@]|A|$E|F]]|$1|18|3|19|5|6|7|3F|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|6|7|3G|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|6|7|3H|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|D|7|3I|8|@]|9|@]|A|$E|F]]|$1|1G|3|1H|5|6|7|3J|8|@$M|3K|N|3L|O|P]|$M|3M|N|3N|O|P]|$M|3O|N|3P|O|P]]|9|@]|A|$]]|$1|1I|3|1J|5|6|7|3Q|8|@]|9|@]|A|$]]|$1|1K|3|-4|5|6|7|3R|8|@]|9|@]|A|$]]|$1|1L|3|1M|5|1N|7|3S|8|@$M|3T|N|3U|O|P]]|9|@]|A|$]]|$1|1O|3|1P|5|1N|7|3V|8|@]|9|@]|A|$]]|$1|1Q|3|-4|5|6|7|3W|8|@]|9|@]|A|$]]|$1|1R|3|1S|5|6|7|3X|8|@]|9|@]|A|$]]|$1|1T|3|1U|5|6|7|3Y|8|@]|9|@]|A|$]]|$1|1V|3|1W|5|6|7|3Z|8|@]|9|@]|A|$]]|$1|1X|3|1Y|5|6|7|40|8|@$M|41|N|42|O|1Z]]|9|@]|A|$]]|$1|20|3|21|5|D|7|43|8|@]|9|@]|A|$E|F]]|$1|22|3|23|5|6|7|44|8|@$M|45|N|46|O|P]]|9|@]|A|$]]|$1|24|3|25|5|6|7|47|8|@]|9|@]|A|$]]|$1|26|3|27|5|D|7|48|8|@]|9|@]|A|$E|F]]|$1|28|3|29|5|6|7|49|8|@$M|4A|N|4B|O|P]]|9|@]|A|$]]|$1|2A|3|2B|5|6|7|4C|8|@$M|4D|N|4E|O|1Z]]|9|@]|A|$]]|$1|2C|3|2D|5|6|7|4F|8|@]|9|@]|A|$]]|$1|2E|3|2F|5|D|7|4G|8|@]|9|@]|A|$E|F]]|$1|2G|3|2H|5|6|7|4H|8|@]|9|@]|A|$]]|$1|2I|3|2J|5|6|7|4I|8|@]|9|@]|A|$]]|$1|2K|3|2L|5|6|7|4J|8|@]|9|@]|A|$]]|$1|2M|3|-4|5|6|7|4K|8|@]|9|@]|A|$]]]|2N|$2O|$5|2P|2Q|2R|A|$2S|2T]]]]

Your function signature needs to be:
<pre><code>const char * myFunction()
{
 return &quot;my String&quot;;
}
</code></pre>
<h2>Background:</h2>
It's so fundamental to C &amp; C++, but little more discussion should be in order.
In C (&amp; C++ for that matter), a string is just an array of bytes terminated with a zero byte - hence the term &quot;string-zero&quot; is used to represent this particular flavour of string. There are other kinds of strings, but in C (&amp; C++), this flavour is inherently understood by the language itself. Other languages (Java, Pascal, etc.) use different methodologies to understand <code>&quot;my string&quot;</code>.
If you ever use the Windows API (which is in C++), you'll see quite regularly function parameters like: &quot;LPCSTR lpszName&quot;. The 'sz' part represents this notion of 'string-zero': an array of bytes with a null (/zero) terminator.
<h2>Clarification:</h2>
For the sake of this 'intro', I use the word 'bytes' and 'characters' interchangeably, because it's easier to learn this way. Be aware that there are other methods (wide-characters, and multi-byte character systems (mbcs)) that are used to cope with international characters. <a href="https://en.wikipedia.org/wiki/UTF-8" rel="noreferrer">UTF-8</a> is an example of an mbcs. For the sake of intro, I quietly 'skip over' all of this.
<h2>Memory:</h2>
This means that a string like <code>&quot;my string&quot;</code> actually uses 9+1 (=10!) bytes. This is important to know when you finally get around to allocating strings dynamically.
So, without this 'terminating zero', you don't have a string. You have an array of characters (also called a buffer) hanging around in memory.
<h2>Longevity of data:</h2>
The use of the function this way:
<pre><code>const char * myFunction()
{
 return &quot;my String&quot;;
}

int main()
{
 const char* szSomeString = myFunction(); // Fraught with problems
 printf(&quot;%s&quot;, szSomeString);
}
</code></pre>
... will generally land you with random unhandled-exceptions/segment faults and the like, especially 'down the road'.
In short, although my answer is correct - 9 times out of 10 you'll end up with a program that crashes if you use it that way, especially if you think it's 'good practice' to do it that way. In short: It's generally not.
For example, imagine some time in the future, the string now needs to be manipulated in some way. Generally, a coder will 'take the easy path' and (try to) write code like this:
<pre><code>const char * myFunction(const char* name)
{
 char szBuffer[255];
 snprintf(szBuffer, sizeof(szBuffer), &quot;Hi %s&quot;, name);
 return szBuffer;
}
</code></pre>
That is, your program will crash because the compiler (may/may not) have released the memory used by <code>szBuffer</code> by the time the <code>printf()</code> in <code>main()</code> is called. (Your compiler should also warn you of such problems beforehand.)
There are two ways to return strings that won't barf so readily.
<ol>
<li>returning buffers (static or dynamically allocated) that live for a while. In C++ use 'helper classes' (for example, <code>std::string</code>) to handle the longevity of data (which requires changing the function's return value), or</li>
<li>pass a buffer to the function that gets filled in with information.</li>
</ol>
Note that it is impossible to use strings without using pointers in C. As I have shown, they are synonymous. Even in C++ with template classes, there are always buffers (that is, pointers) being used in the background.
So, to better answer the (now modified question). (There are sure to be a variety of 'other answers' that can be provided.)
<h2>Safer Answers:</h2>
Example 1, using statically allocated strings:
<pre><code>const char* calculateMonth(int month)
{
 static char* months[] = {&quot;Jan&quot;, &quot;Feb&quot;, &quot;Mar&quot; .... };
 static char badFood[] = &quot;Unknown&quot;;
 if (month &lt; 1 || month &gt; 12)
 return badFood; // Choose whatever is appropriate for bad input. Crashing is never appropriate however.
 else
 return months[month-1];
}

int main()
{
 printf(&quot;%s&quot;, calculateMonth(2)); // Prints &quot;Feb&quot;
}
</code></pre>
What the <code>static</code> does here (many programmers do not like this type of 'allocation') is that the strings get put into the data segment of the program. That is, it's permanently allocated.
If you move over to C++ you'll use similar strategies:
<pre><code>class Foo
{
 char _someData[12];
public:
 const char* someFunction() const
 { // The final 'const' is to let the compiler know that nothing is changed in the class when this function is called.
 return _someData;
 }
}
</code></pre>
... but it's probably easier to use helper classes, such as <code>std::string</code>, if you're writing the code for your own use (and not part of a library to be shared with others).
Example 2, using caller-defined buffers:
This is the more 'foolproof' way of passing strings around. The data returned isn't subject to manipulation by the calling party. That is, example 1 can easily be abused by a calling party and expose you to application faults. This way, it's much safer (albeit uses more lines of code):
<pre><code>void calculateMonth(int month, char* pszMonth, int buffersize)
{
 const char* months[] = {&quot;Jan&quot;, &quot;Feb&quot;, &quot;Mar&quot; .... }; // Allocated dynamically during the function call. (Can be inefficient with a bad compiler)
 if (!pszMonth || buffersize&lt;1)
 return; // Bad input. Let junk deal with junk data.
 if (month&lt;1 || month&gt;12)
 {
 *pszMonth = '\0'; // Return an 'empty' string
 // OR: strncpy(pszMonth, &quot;Bad Month&quot;, buffersize-1);
 }
 else
 {
 strncpy(pszMonth, months[month-1], buffersize-1);
 }
 pszMonth[buffersize-1] = '\0'; // Ensure a valid terminating zero! Many people forget this!
}

int main()
{
 char month[16]; // 16 bytes allocated here on the stack.
 calculateMonth(3, month, sizeof(month));
 printf(&quot;%s&quot;, month); // Prints &quot;Mar&quot;
}
</code></pre>
There are lots of reasons why the second method is better, particularly if you're writing a library to be used by others (you don't need to lock into a particular allocation/deallocation scheme, third parties can't break your code, and you don't need to link to a specific memory management library), but like all code, it's up to you on what you like best. For that reason, most people opt for example 1 until they've been burnt so many times that they refuse to write it that way anymore ;)
<h2>Disclaimer:</h2>
I retired several years back and my C is a bit rusty now. This demo code should all compile properly with C (it is OK for any C++ compiler though).

blocks|key|179474|text|你的函数原型声明你的函数将返回一个char。因此，您不能在函数中返回字符串。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|179475|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|$]]

Your function prototype states your function will return a char. Thus, you can't return a string in your function.

blocks|key|355780|text|C字符串被定义为指向字符数组的指针。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|355781|如果你不能有指针，根据定义，你也不能有字符串。|355782|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

A C string is defined as a pointer to an array of characters.

If you cannot have pointers, by definition you cannot have strings.

blocks|key|1657234|text|请注意这个新函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1657235|const+char*+myFunction()
{
++++static+char+array[]+=+"my+string";
++++return+array;
}|code-block|syntax|javascript|1657236|我将"array“定义为静态的。否则，当函数结束时，变量(以及返回的指针)会超出作用域。因为内存是在堆栈上分配的，所以它的将被破坏。这种实现的缺点是代码不是可重入的，也不是threadsafe。|offset|length|style|BOLD|1657237|另一种选择是使用malloc在堆中分配字符串，然后释放代码的正确位置。这段代码将是可重入的和线程安全的。|1657238|正如评论中指出的，这是一个非常糟糕的做法，因为攻击者可以将代码注入到您的应用程序中(他/她需要使用GDB打开代码，然后创建断点并修改返回变量的值以使溢出和乐趣刚刚开始)。|1657239|更推荐让调用者处理内存分配。请看这个新示例：|1657240|char*+myFunction(char*+output_str,+size_t+max_len)
{
+++const+char+*str+=+"my+string";
+++size_t+l+=+strlen(str);
+++if+(l%2B1+>+max_len)+{
++++++return+NULL;
+++}
+++strcpy(str,+str,+l);
+++return+input;
}|1657241|请注意，唯一可以修改的内容是用户可以修改的内容。另一个副作用--这段代码现在是threadsafe了，至少从库的角度来看是这样。调用此方法的程序员应验证所使用的内存节是否为threadsafe。|1657242|entityMap^0|0|0|1P|10|0|0|1G|0|0|2D|0|0|M|0|0|0|2P|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@$I|11|J|12|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|13|8|@$I|14|J|15|K|L]]|9|@]|A|$]]|$1|O|3|P|5|6|7|16|8|@$I|17|J|18|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|19|8|@$I|1A|J|1B|K|L]]|9|@]|A|$]]|$1|S|3|T|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1D|8|@$I|1E|J|1F|K|L]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|X|$]]

Note this new function:

<pre><code>const char* myFunction()
{
 static char array[] = "my string";
 return array;
}
</code></pre>

I defined "array" as static. Otherwise when the function ends, the variable (and the pointer you are returning) gets out of scope. Since that memory is allocated on the stack, and it will get corrupted. The downside of this implementation is that the code is not reentrant and not threadsafe.

Another alternative would be to use malloc to allocate the string in the heap, and then free on the correct locations of your code. This code will be reentrant and threadsafe.

As noted in the comment, this is a very bad practice, since an attacker can then inject code to your application (he/she needs to open the code using GDB, then make a breakpoint and modify the value of a returned variable to overflow and fun just gets started).

It is much more recommended to let the caller handle about memory allocations. See this new example:

<pre><code>char* myFunction(char* output_str, size_t max_len)
{
 const char *str = "my string";
 size_t l = strlen(str);
 if (l+1 &gt; max_len) {
 return NULL;
 }
 strcpy(str, str, l);
 return input;
}
</code></pre>

Note that the only content which can be modified is the one that the user. Another side effect - this code is now threadsafe, at least from the library point of view. The programmer calling this method should verify that the memory section used is threadsafe.

blocks|key|179633|text|如果你真的不能使用指针，可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|179634|char+get_string_char(int+index)
{
++++static+char+array[]+=+"my+string";
++++return+array[index];
}

int+main()
{
++++for+(int+i+=+0;+i+<+9;+%2B%2Bi)
++++++++printf("%25c",+get_string_char(i));
++++printf("\n");
++++return+0;
}|code-block|syntax|javascript|179635|魔术数字9是可怕的，这不是一个好的编程例子。但你明白我的意思了。请注意，指针和数组是一回事(某种意义上)，所以这有点作弊。|179636|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|$]]

If you really can't use pointers, do something like this:

<pre><code>char get_string_char(int index)
{
 static char array[] = "my string";
 return array[index];
}

int main()
{
 for (int i = 0; i &lt; 9; ++i)
 printf("%c", get_string_char(i));
 printf("\n");
 return 0;
}
</code></pre>

The magic number 9 is awful, and this is not an example of good programming. But you get the point. Note that pointers and arrays are the same thing (kind of), so this is a bit cheating.

blocks|key|179683|text|根据您新添加的问题背景，为什么不返回一个从1到12的月份整数，并让main()函数使用switch语句或if-else梯形图来决定打印什么内容？这当然不是最好的go+-+char*方法--但是在这样一个类的上下文中，我想它可能是最优雅的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|179684|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|$]]

Based on your newly-added backstory with the question, why not just return an integer from 1 to 12 for the month, and let the main() function use a switch statement or if-else ladder to decide what to print? It's certainly not the best way to go - char* would be - but in the context of a class like this I imagine it's probably the most elegant.

blocks|key|179720|text|或者这个怎么样：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|179721|void+print_month(int+month)
{
++++switch+(month)
++++{
++++++++case+0:
++++++++++++printf("January");
++++++++++++break;
++++++++case+1:
++++++++++++printf("february");
++++++++++++break;
++++++++...etc...
++++}
}|code-block|syntax|javascript|179722|然后把它和你在其他地方计算的月份一起称为。|179723|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|$]]

Or how about this one:

<pre><code>void print_month(int month)
{
 switch (month)
 {
 case 0:
 printf("January");
 break;
 case 1:
 printf("february");
 break;
 ...etc...
 }
}
</code></pre>

And call that with the month you compute somewhere else.

blocks|key|179804|text|在您的代码中，您试图返回一个String+(在C中，它只是一个以空结尾的字符数组)，但是您的函数的返回类型是char，这给您带来了所有的麻烦。相反，你应该这样写它：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|179805|const+char*+myFunction()
{

++++return+"My+String";

}|code-block|syntax|javascript|179806|用const限定你的类型总是很好的，同时把C中的文字赋值给指针，因为C中的文字是不可修改的。|179807|entityMap^0|E|6|1I|4|0|0|1|5|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|N|$]]

Well, in your code you are trying to return a <code>String</code> (in C which is nothing but a null-terminated array of characters), but the return type of your function is <code>char</code> which is causing all the trouble for you. Instead you should write it this way:

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

 return "My String";

}
</code></pre>

And it's always good to qualify your type with <code>const</code> while assigning literals in C to pointers as literals in C aren't modifiable.

blocks|key|355932|text|您可以在调用者中创建数组，这是主函数，并将该数组传递给被调用者，即您的myFunction()。因此，myFunction可以将字符串填充到数组中。但是，您需要将myFunction()声明为|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|355933|char*+myFunction(char+*+buf,+int+buf_len){
++strncpy(buf,+"my+string",+buf_len);
++return+buf;
}|code-block|syntax|javascript|355934|在main中，应该这样调用myFunction：|355935|char+array[51];
memset(array,+0,+51);+/*+All+bytes+are+set+to+'\0'+*/
printf("%25s",+myFunction(array,+50));+/*+The+buf_len+argument++is+50,+not+51.+This+is+to+make+sure+the+string+in+buf+is+always+null-terminated+(array[50]+is+always+'\0')+*/|355936|但是，仍然使用指针。|355937|entityMap^0|Z|C|1F|A|29|C|0|0|1|4|D|A|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|16|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|R|$]]

You can create the array in the caller, which is the main function, and pass the array to the callee which is your <code>myFunction()</code>. Thus <code>myFunction</code> can fill the string into the array. However, you need to declare <code>myFunction()</code> as
<pre><code>char* myFunction(char * buf, int buf_len){
 strncpy(buf, &quot;my string&quot;, buf_len);
 return buf;
}
</code></pre>
And in <code>main</code>, <code>myFunction</code> should be called in this way:
<pre><code>char array[51];
memset(array, 0, 51); /* All bytes are set to '\0' */
printf(&quot;%s&quot;, myFunction(array, 50)); /* The buf_len argument is 50, not 51. This is to make sure the string in buf is always null-terminated (array[50] is always '\0') */
</code></pre>
However, a pointer is still used.

blocks|key|1585905|text|char*+myFunction()
{
++++return+"My+String";
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1585906|在C中，字符串文字是具有静态常量内存类的数组，因此返回指向此数组的指针是安全的。更多详细信息请参阅堆栈溢出问题|unstyled|1585907|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* myFunction()
{
 return "My String";
}
</code></pre>

In C, string literals are arrays with the static constant memory class, so returning a pointer to this array is safe. More details are in Stack Overflow question <a href="https://stackoverflow.com/questions/9970295/life-time-of-a-string-literal-in-c">&quot;Life-time&quot; of a string literal in C</a>

blocks|key|1657388|text|从函数返回字符串|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1657389|#include+<stdio.h>

const+char*+greet()+{
++return+"Hello";
}

int+main(void)+{
++printf("%25s",+greet());
}|code-block|syntax|javascript|1657390|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|$]]

Return string from function
<pre><code>#include &lt;stdio.h&gt;

const char* greet() {
 return &quot;Hello&quot;;
}

int main(void) {
 printf(&quot;%s&quot;, greet());
}
</code></pre>

blocks|key|355970|text|另一件要记住的事情是，您不能从C函数返回定义为局部变量的字符串，因为当函数执行完毕时，该变量将自动销毁(释放)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|355971|#include+<stdio.h>
#include+<stdlib.h>

char+*myfunc(){
++++char+*myvar+=+(char+*)malloc(20);
++++printf("Plese+enter+some+text+\n");
++++fgets(myvar,+20,+stdin);
++++return+myvar;
}
int+main(){
++++printf("You+entered:+%25s",+myfunc());
}|code-block|syntax|javascript|355972|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|$]]

Another thing to keep in mind is that you can’t return a string defined as a local variable from a C function, because the variable will be automatically destroyed (released) when the function finished execution.
<pre><code>#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

char *myfunc(){
 char *myvar = (char *)malloc(20);
 printf(&quot;Plese enter some text \n&quot;);
 fgets(myvar, 20, stdin);
 return myvar;
}
int main(){
 printf(&quot;You entered: %s&quot;, myfunc());
}
</code></pre>

I am trying to return a C string from a function, but it's not working. Here is my code.

<pre><code>char myFunction()
{
 return "My String";
}
</code></pre>

In <code>main</code> I am calling it like this:

<pre><code>int main()
{
 printf("%s", myFunction());
}
</code></pre>

I have also tried some other ways for <code>myFunction</code>, but they are not working. For example:

<pre><code>char myFunction()
{
 char array[] = "my string";
 return array;
}
</code></pre>

Note: I am not allowed to use pointers!

Little background on this problem:

There is function which is finding out which month it is. For example, if it's 1 then it returns January, etc.

So when it's going to print, it's doing it like this: <code>printf("Month: %s",calculateMonth(month));</code>. Now the problem is how to return that string from the <code>calculateMonth</code> function.

Returning a C string from a function

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我试图从一个函数返回一个C字符串，但它不起作用。这是我的代码。char myFunction(){    return "My String";}在main中，我是这样命名的：int main(){  printf("%s", myFunction());}我还尝试了myFunction的一些其他方法，但它们都不起作用...

问从函数返回C字符串
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从函数返回C字符串EN