在C中将长字符串分割为单词

huangapple
go评论95阅读模式
英文:

Separating a long string into individual words in C

问题

Sure, here's the translated code portion:

  1. 我尝试做的是，给定一个字符串（比如 "This is a string"），编写一个能够将其拆分成一个数组的代码，每个单词都放在数组的一个单独元素中（"This"，"is"，"a"，"string"）。我草拟了这样的代码：
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6. int main()
  7. {
  8.   char bigString[1000];
  9.   scanf("%s", bigString);
  10.   char wordCollection[10][100];
  11.   int bigIndex=0;
  12.   int smallIndex=0;
  13.   for (int i = 0; i<10; i++)
  14.   {
  15.       while (bigString[bigIndex]!=' ' && bigString[bigIndex]!='
    我尝试做的是，给定一个字符串（比如 "This is a string"），编写一个能够将其拆分成一个数组的代码，每个单词都放在数组的一个单独元素中（"This"，"is"，"a"，"string"）。我草拟了这样的代码：
  17. #include <stdio.h>
  18. #include <stdlib.h>
  19. #include <string.h>
  20. int main()
  21. {
  22.   char bigString[1000];
  23.   scanf("%s", bigString);
  24.   char wordCollection[10][100];
  25.   int bigIndex=0;
  26.   int smallIndex=0;
  27.   for (int i = 0; i<10; i++)
  28.   {
  29.       while (bigString[bigIndex]!=' ' && bigString[bigIndex]!='\0')
  30.       {
  31.           wordCollection[i][smallIndex] = bigString[bigIndex];
  32.           bigIndex++;
  33.           smallIndex++;
  34.       }
  35.       if (bigString[bigIndex]=='\0') i=10;
  36.       bigIndex++;
  37.       smallIndex=0;
  38.       printf("%s", wordCollection[i]);
  39.   }
  40. }
  41. ')
  42.       {
  43.           wordCollection[i][smallIndex] = bigString[bigIndex];
  44.           bigIndex++;
  45.           smallIndex++;
  46.       }
  47.       if (bigString[bigIndex]=='
    我尝试做的是，给定一个字符串（比如 "This is a string"），编写一个能够将其拆分成一个数组的代码，每个单词都放在数组的一个单独元素中（"This"，"is"，"a"，"string"）。我草拟了这样的代码：
  49. #include <stdio.h>
  50. #include <stdlib.h>
  51. #include <string.h>
  52. int main()
  53. {
  54.   char bigString[1000];
  55.   scanf("%s", bigString);
  56.   char wordCollection[10][100];
  57.   int bigIndex=0;
  58.   int smallIndex=0;
  59.   for (int i = 0; i<10; i++)
  60.   {
  61.       while (bigString[bigIndex]!=' ' && bigString[bigIndex]!='\0')
  62.       {
  63.           wordCollection[i][smallIndex] = bigString[bigIndex];
  64.           bigIndex++;
  65.           smallIndex++;
  66.       }
  67.       if (bigString[bigIndex]=='\0') i=10;
  68.       bigIndex++;
  69.       smallIndex=0;
  70.       printf("%s", wordCollection[i]);
  71.   }
  72. }
  73. ') i=10;
  74.       bigIndex++;
  75.       smallIndex=0;
  76.       printf("%s", wordCollection[i]);
  77.   }
  78. }

If you have any further questions or need assistance with the code, please feel free to ask.

英文:

What I'm trying to do is, given a string (say "This is a string") write a code that could take it and put each word in a separate element of an array ("This", "is", "a", "string"). I scribbled something like that:

  1. #include &lt;stdio.h&gt;
  2. #include &lt;stdlib.h&gt;
  3. #include &lt;string.h&gt;
  4. int main()
  5. {
  6.   char bigString[1000];
  7.   scanf(&quot;%s&quot;, bigString);
  8.   char wordCollection[10][100];
  9.   int bigIndex=0;
  10.   int smallIndex=0;
  11.   for (int i = 0; i&lt;10; i++)
  12.   {
  13.       while (bigString[bigIndex]!=&#39; &#39; &amp;&amp; bigString[bigIndex]!=&#39;
    #include &lt;stdio.h&gt;
  14. #include &lt;stdlib.h&gt;
  15. #include &lt;string.h&gt;
  16. int main()
  17. {
  18. char bigString[1000];
  19. scanf(&quot;%s&quot;, bigString);
  20. char wordCollection[10][100];
  21. int bigIndex=0;
  22. int smallIndex=0;
  23. for (int i = 0; i&lt;10; i++)
  24. {
  25. while (bigString[bigIndex]!=&#39; &#39; &amp;&amp; bigString[bigIndex]!=&#39;\0&#39;)
  26. {
  27. wordCollection[i][smallIndex] = bigString[bigIndex];
  28. bigIndex++;
  29. smallIndex++;
  30. }
  31. if (bigString[bigIndex]==&#39;\0&#39;) i=10;
  32. bigIndex++;
  33. smallIndex=0;
  34. printf(&quot;%s&quot;, wordCollection[i]);
  35. }
  36. }
  37. &#39;)
  38.       {
  39.           wordCollection[i][smallIndex] = bigString[bigIndex];
  40.           bigIndex++;
  41.           smallIndex++;
  42.       }
  43.       if (bigString[bigIndex]==&#39;
    #include &lt;stdio.h&gt;
  44. #include &lt;stdlib.h&gt;
  45. #include &lt;string.h&gt;
  46. int main()
  47. {
  48. char bigString[1000];
  49. scanf(&quot;%s&quot;, bigString);
  50. char wordCollection[10][100];
  51. int bigIndex=0;
  52. int smallIndex=0;
  53. for (int i = 0; i&lt;10; i++)
  54. {
  55. while (bigString[bigIndex]!=&#39; &#39; &amp;&amp; bigString[bigIndex]!=&#39;\0&#39;)
  56. {
  57. wordCollection[i][smallIndex] = bigString[bigIndex];
  58. bigIndex++;
  59. smallIndex++;
  60. }
  61. if (bigString[bigIndex]==&#39;\0&#39;) i=10;
  62. bigIndex++;
  63. smallIndex=0;
  64. printf(&quot;%s&quot;, wordCollection[i]);
  65. }
  66. }
  67. &#39;) i=10;
  68.       bigIndex++;
  69.       smallIndex=0;
  70.       printf(&quot;%s&quot;, wordCollection[i]);
  71.   }
  72. }

Unfortunately, it doesn't act as needed (printing out some gibberish). I tried debugging it but I still don't understand why it wouldn't function properly. Guidance would be very helpful 在C中将长字符串分割为单词
Also - if you have a more efficient idea, say one involving pointers, I would be more than thrilled to see it.

答案1

得分: 1

Here are the translated portions:

"你没有在 wordCollection 中对单词进行空字符终止。"

在 while 后面添加 wordCollection[i][smallIndex] = '\0';，例如：

  1. while (bigString[bigIndex] != ' ' && bigString[bigIndex] != '
    while (bigString[bigIndex] != ' ' && bigString[bigIndex] != '\0')
  2. {
  3.     wordCollection[i][smallIndex] = bigString[bigIndex];
  4.     bigIndex++;
  5.     smallIndex++;
  6. }
  7. wordCollection[i][smallIndex] = '\0';
  8. ')
  9. {
  10.     wordCollection[i][smallIndex] = bigString[bigIndex];
  11.     bigIndex++;
  12.     smallIndex++;
  13. }
  14. wordCollection[i][smallIndex] = '
    while (bigString[bigIndex] != ' ' && bigString[bigIndex] != '\0')
  15. {
  16.     wordCollection[i][smallIndex] = bigString[bigIndex];
  17.     bigIndex++;
  18.     smallIndex++;
  19. }
  20. wordCollection[i][smallIndex] = '\0';
  21. ';

"你还应该检查大小，记住，空字符终止的字符串占用的字符比字符串长度多一个。"

此外，在 printf 之前设置 i=10 会导致最后一个 printf 打印无意义的内容，因为如果少于 10 个单词，你没有放置任何内容。更糟糕的是，它可能会导致分段错误，因为 wordCollection 数组的最后一个索引是 9。

英文:

You are not null terminating the words in wordCollection

Add a wordCollection[i][smallIndex] = &#39;\0 after the while, e.g.:

  1.       while (bigString[bigIndex]!=&#39; &#39; &amp;&amp; bigString[bigIndex]!=&#39;\0&#39;)
  2.       {
  3.           wordCollection[i][smallIndex] = bigString[bigIndex];
  4.           bigIndex++;
  5.           smallIndex++;
  6.       }
  7.       wordCollection[i][smallIndex] = &#39;\0&#39;;

You should also check sizes, remember that a null terminated string occupies one more char than the string length.

Also, setting i=10 before the printf will make the last printf print gibberish, because you didn't put anything there if there were less than 10 words. Even worst, it could give a segmentation fault, because the last index of the wordCollection array is 9.

答案2

得分: 1

以下是您要翻译的内容：

对于这个scanf的调用

  1. scanf(&quot;%s&quot;, bigString);

是不安全的，只能读取一个单词。

相反，您可以使用标准函数fgets。

如果遇到空格字符，那么这个while循环

  1. while (bigString[bigIndex]!=&#39; &#39; &amp;&amp; bigString[bigIndex]!=&#39;
    while (bigString[bigIndex]!=&#39; &#39; &amp;&amp; bigString[bigIndex]!=&#39;
    while (bigString[bigIndex]!=&#39; &#39; &amp;&amp; bigString[bigIndex]!=&#39;\0&#39;)
  2. &#39;)
  3. &#39;)

会被跳过。在这种情况下，两维字符数组的索引i不会被字符串填充。因此，这个printf的调用

  1. printf(&quot;%s&quot;, wordCollection[i]);

会引发未定义行为。而且，如果记录中有多个相邻的空格，且字符串中的单词数少于10个，可能会出现这样的情况，即不会输出任何单词。

此外，您需要将用空字符&#39;\0&#39;填充的数组wordCollection的每个元素追加在一起以形成一个字符串。

而且这一对语句

  1.   if (bigString[bigIndex]==&#39;
      if (bigString[bigIndex]==&#39;
      if (bigString[bigIndex]==&#39;\0&#39;) i=10;
  2. //...
  3. printf(&quot;%s&quot;, wordCollection[i]);
  4. &#39;) i=10;
  5.   //...
  6.   printf(&quot;%s&quot;, wordCollection[i]);
  7. &#39;) i=10;
  8.   //...
  9.   printf(&quot;%s&quot;, wordCollection[i]);

再次引发未定义行为，因为10是一个无效的索引。

您可以使用标准的C字符串函数代替手动编写的while循环。

并且要注意，通常单词可以由多个相邻的空格或制表符分隔开。

以下是演示程序。

  1. #include &lt;stdio.h&gt;
  2. #include &lt;string.h&gt;
  4. int main( void )
  5. {
  6. 	enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  8. 	char bigString[MAX_STRING_LEN];
  9. 	char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  11. 	size_t count = 0;
  13. 	if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  14. 	{
  15. 		bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;
    #include &lt;stdio.h&gt;
  16. #include &lt;string.h&gt;
  18. int main( void )
  19. {
  20. 	enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  22. 	char bigString[MAX_STRING_LEN];
  23. 	char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  25. 	size_t count = 0;
  27. 	if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  28. 	{
  29. 		bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;
    #include &lt;stdio.h&gt;
  30. #include &lt;string.h&gt;
  31. int main( void )
  32. {
  33. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  34. char bigString[MAX_STRING_LEN];
  35. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  36. size_t count = 0;
  37. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  38. {
  39. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  40. const char *delim = &quot; \t&quot;;
  41. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  42. {
  43. p += strspn( p, delim );
  44. if (*p != &#39;\0&#39;)
  45. {
  46. size_t n = strcspn( p, delim );
  47. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  48. memcpy( wordCollection[count], p, len );
  49. wordCollection[count][len] = &#39;\0&#39;;
  50. ++count;
  51. p += n;
  52. }
  53. }
  54. for (size_t i = 0; i &lt; count; i++)
  55. {
  56. puts( wordCollection[i] );
  57. }
  58. }
  59. }
  60. &#39;;
  62. 		const char *delim = &quot; \t&quot;;
  64. 		for (const char *p = bigString; *p != &#39;
    #include &lt;stdio.h&gt;
  65. #include &lt;string.h&gt;
  66. int main( void )
  67. {
  68. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  69. char bigString[MAX_STRING_LEN];
  70. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  71. size_t count = 0;
  72. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  73. {
  74. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  75. const char *delim = &quot; \t&quot;;
  76. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  77. {
  78. p += strspn( p, delim );
  79. if (*p != &#39;\0&#39;)
  80. {
  81. size_t n = strcspn( p, delim );
  82. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  83. memcpy( wordCollection[count], p, len );
  84. wordCollection[count][len] = &#39;\0&#39;;
  85. ++count;
  86. p += n;
  87. }
  88. }
  89. for (size_t i = 0; i &lt; count; i++)
  90. {
  91. puts( wordCollection[i] );
  92. }
  93. }
  94. }
  95. &#39; &amp;&amp; count &lt; WORD_COUNT; )
  96. 		{
  97. 			p += strspn( p, delim );
  100. 			if (*p != &#39;
    #include &lt;stdio.h&gt;
  101. #include &lt;string.h&gt;
  102. int main( void )
  103. {
  104. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  105. char bigString[MAX_STRING_LEN];
  106. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  107. size_t count = 0;
  108. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  109. {
  110. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  111. const char *delim = &quot; \t&quot;;
  112. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  113. {
  114. p += strspn( p, delim );
  115. if (*p != &#39;\0&#39;)
  116. {
  117. size_t n = strcspn( p, delim );
  118. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  119. memcpy( wordCollection[count], p, len );
  120. wordCollection[count][len] = &#39;\0&#39;;
  121. ++count;
  122. p += n;
  123. }
  124. }
  125. for (size_t i = 0; i &lt; count; i++)
  126. {
  127. puts( wordCollection[i] );
  128. }
  129. }
  130. }
  131. &#39;)
  132. 			{
  133. 				size_t n = strcspn( p, delim );
  135. 				size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  137. 				memcpy( wordCollection[count], p, len );
  138. 				wordCollection[count][len] = &#39;
    #include &lt;stdio.h&gt;
  139. #include &lt;string.h&gt;
  140. int main( void )
  141. {
  142. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  143. char bigString[MAX_STRING_LEN];
  144. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  145. size_t count = 0;
  146. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  147. {
  148. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  149. const char *delim = &quot; \t&quot;;
  150. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  151. {
  152. p += strspn( p, delim );
  153. if (*p != &#39;\0&#39;)
  154. {
  155. size_t n = strcspn( p, delim );
  156. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  157. memcpy( wordCollection[count], p, len );
  158. wordCollection[count][len] = &#39;\0&#39;;
  159. ++count;
  160. p += n;
  161. }
  162. }
  163. for (size_t i = 0; i &lt; count; i++)
  164. {
  165. puts( wordCollection[i] );
  166. }
  167. }
  168. }
  169. &#39;;
  170. 				
  171. 				++count;
  173. 				p += n;
  174. 			}
  175. 		}
  177. 		for (size_t i = 0; i &lt; count; i++)
  178. 		{
  179. 			puts( wordCollection[i] );
  180. 		}
  181. 	}
  182. }
  183. &#39;;
  185. 		const char *delim = &quot; \t&quot;;
  187. 		for (const char *p = bigString; *p != &#39;
    #include &lt;stdio.h&gt;
  188. #include &lt;string.h&gt;
  190. int main( void )
  191. {
  192. 	enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  194. 	char bigString[MAX_STRING_LEN];
  195. 	char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  197. 	size_t count = 0;
  199. 	if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  200. 	{
  201. 		bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;
    #include &lt;stdio.h&gt;
  202. #include &lt;string.h&gt;
  203. int main( void )
  204. {
  205. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  206. char bigString[MAX_STRING_LEN];
  207. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  208. size_t count = 0;
  209. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  210. {
  211. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  212. const char *delim = &quot; \t&quot;;
  213. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  214. {
  215. p += strspn( p, delim );
  216. if (*p != &#39;\0&#39;)
  217. {
  218. size_t n = strcspn( p, delim );
  219. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  220. memcpy( wordCollection[count], p, len );
  221. wordCollection[count][len] = &#39;\0&#39;;
  222. ++count;
  223. p += n;
  224. }
  225. }
  226. for (size_t i = 0; i &lt; count; i++)
  227. {
  228. puts( wordCollection[i] );
  229. }
  230. }
  231. }
  232. &#39;;
  234. 		const char *delim = &quot; \t&quot;;
  236. 		for (const char *p = bigString; *p != &#39;
    #include &lt;stdio.h&gt;
  237. #include &lt;string.h&gt;
  238. int main( void )
  239. {
  240. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  241. char bigString[MAX_STRING_LEN];
  242. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  243. size_t count = 0;
  244. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  245. {
  246. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  247. const char *delim = &quot; \t&quot;;
  248. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  249. {
  250. p += strspn( p, delim );
  251. if (*p != &#39;\0&#39;)
  252. {
  253. size_t n = strcspn( p, delim );
  254. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  255. memcpy( wordCollection[count], p, len );
  256. wordCollection[count][len] = &#39;\0&#39;;
  257. ++count;
  258. p += n;
  259. }
  260. }
  261. for (size_t i = 0; i &lt; count; i++)
  262. {
  263. puts( wordCollection[i] );
  264. }
  265. }
  266. }
  267. &#39; &amp;&amp; count &lt; WORD_COUNT; )
  268. 		{
  269. 			p += strspn( p, delim );
  272. 			if (*p != &#39;
    #include &lt;stdio.h&gt;
  273. #include &lt;string.h&gt;
  274. int main( void )
  275. {
  276. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  277. char bigString[MAX_STRING_LEN];
  278. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  279. size_t count = 0;
  280. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  281. {
  282. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  283. const char *delim = &quot; \t&quot;;
  284. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  285. {
  286. p += strspn( p, delim );
  287. if (*p != &#39;\0&#39;)
  288. {
  289. size_t n = strcspn( p, delim );
  290. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  291. memcpy( wordCollection[count], p, len );
  292. wordCollection[count][len] = &#39;\0&#39;;
  293. ++count;
  294. p += n;
  295. }
  296. }
  297. for (size_t i = 0; i &lt; count; i++)
  298. {
  299. puts( wordCollection[i] );
  300. }
  301. }
  302. }
  303. &#39;)
  304. 			{
  305. 				size_t n = strcspn( p, delim );
  307. 				size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  309. 				memcpy( wordCollection[count], p, len );
  310. 				wordCollection[count][len] = &#39;
    #include &lt;stdio.h&gt;
  311. #include &lt;string.h&gt;
  312. int main( void )
  313. {
  314. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  315. char bigString[MAX_STRING_LEN];
  316. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  317. size_t count = 0;
  318. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  319. {
  320. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  321. const char *delim = &quot; \t&quot;;
  322. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  323. {
  324. p += strspn( p, delim );
  325. if (*p != &#39;\0&#39;)
  326. {
  327. size_t n = strcspn( p, delim );
  328. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  329. memcpy( wordCollection[count], p, len );
  330. wordCollection[count][len] = &#39;\0&#39;;
  331. ++count;
  332. p += n;
  333. }
  334. }
  335. for (size_t i = 0; i &lt; count; i++)
  336. {
  337. puts( wordCollection[i] );
  338. }
  339. }
  340. }
  341. &#39;;
  342. 				
  343. 				++count;
  345. 				p += n;
  346. 			}
  347. 		}
  349. 		for (size_t i = 0; i &lt; count; i++)
  350. 		{
  351. 			puts( wordCollection[i] );
  352. 		}
  353. 	}
  354. }
  355. &#39; &amp;&amp; count &lt; WORD_COUNT; )
  356. 		{
  357. 			p += strspn( p, delim );
  360. 			if (*p != &#39;
    #include &lt;stdio.h&gt;
  361. #include &lt;string.h&gt;
  363. int main( void )
  364. {
  365. 	enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  367. 	char bigString[MAX_STRING_LEN];
  368. 	char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  370. 	size_t count = 0;
  372. 	if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  373. 	{
  374. 		bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;
    #include &lt;stdio.h&gt;
  375. #include &lt;string.h&gt;
  376. int main( void )
  377. {
  378. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  379. char bigString[MAX_STRING_LEN];
  380. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  381. size_t count = 0;
  382. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  383. {
  384. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  385. const char *delim = &quot; \t&quot;;
  386. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  387. {
  388. p += strspn( p, delim );
  389. if (*p != &#39;\0&#39;)
  390. {
  391. size_t n = strcspn( p, delim );
  392. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  393. memcpy( wordCollection[count], p, len );
  394. wordCollection[count][len] = &#39;\0&#39;;
  395. ++count;
  396. p += n;
  397. }
  398. }
  399. for (size_t i = 0; i &lt; count; i++)
  400. {
  401. puts( wordCollection[i] );
  402. }
  403. }
  404. }
  405. &#39;;
  407. 		const char *delim = &quot; \t&quot;;
  409. 		for (const char *p = bigString; *p != &#39;
    #include &lt;stdio.h&gt;
  410. #include &lt;string.h&gt;
  411. int main( void )
  412. {
  413. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  414. char bigString[MAX_STRING_LEN];
  415. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  416. size_t count = 0;
  417. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  418. {
  419. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  420. const char *delim = &quot; \t&quot;;
  421. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  422. {
  423. p += strspn( p, delim );
  424. if (*p != &#39;\0&#39;)
  425. {
  426. size_t n = strcspn( p, delim );
  427. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  428. memcpy( wordCollection[count], p, len );
  429. wordCollection[count][len] = &#39;\0&#39;;
  430. ++count;
  431. p += n;
  432. }
  433. }
  434. for (size_t i = 0; i &lt; count; i++)
  435. {
  436. puts( wordCollection[i] );
  437. }
  438. }
  439. }
  440. &#39; &amp;&amp; count &lt; WORD_COUNT; )
  441. 		{
  442. 			p += strspn( p, delim );
  445. 			if (*p != &#39;
    #include &lt;stdio.h&gt;
  446. #include &lt;string.h&gt;
  447. int main( void )
  448. {
  449. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  450. char bigString[MAX_STRING_LEN];
  451. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  452. size_t count = 0;
  453. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  454. {
  455. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  456. const char *delim = &quot; \t&quot;;
  457. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  458. {
  459. p += strspn( p, delim );
  460. if (*p != &#39;\0&#39;)
  461. {
  462. size_t n = strcspn( p, delim );
  463. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  464. memcpy( wordCollection[count], p, len );
  465. wordCollection[count][len] = &#39;\0&#39;;
  466. ++count;
  467. p += n;
  468. }
  469. }
  470. for (size_t i = 0; i &lt; count; i++)
  471. {
  472. puts( wordCollection[i] );
  473. }
  474. }
  475. }
  476. &#39;)
  477. 			{
  478. 				size_t n = strcspn( p, delim );
  480. 				size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  482. 				memcpy( wordCollection[count], p, len );
  483. 				wordCollection[count][len] = &#39;
    #include &lt;stdio.h&gt;
  484. #include &lt;string.h&gt;
  485. int main( void )
  486. {
  487. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  488. char bigString[MAX_STRING_LEN];
  489. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  490. size_t count = 0;
  491. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  492. {
  493. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  494. const char *delim = &quot; \t&quot;;
  495. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  496. {
  497. p += strspn( p, delim );
  498. if (*p != &#39;\0&#39;)
  499. {
  500. size_t n = strcspn( p, delim );
  501. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  502. memcpy( wordCollection[count], p, len );
  503. wordCollection[count][len] = &#39;\0&#39;;
  504. ++count;
  505. p += n;
  506. }
  507. }
  508. for (size_t i = 0; i &lt; count; i++)
  509. {
  510. puts( wordCollection[i] );
  511. }
  512. }
  513. }
  514. &#39;;
  515. 				
  516. 				++count;
  518. 				p += n;
  519. 			}
  520. 		}
  522. 		for (size_t i = 0; i &lt; count; i++)
  523. 		{
  524. 			puts( wordCollection[i] );
  525. 		}
  526. 	}
  527. }
  528. &#39;)
  529. 			{
  530. 				size_t n = strcspn( p, delim );
  532. 				size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  534. 				memcpy( wordCollection[count], p, len );
  535. 				wordCollection[count][len] = &#39;
    #include &lt;stdio.h&gt;
  536. #include &lt;string.h&gt;
  538. int main( void )
  539. {
  540. 	enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  542. 	char bigString[MAX_STRING_LEN];
  543. 	char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  545. 	size_t count = 0;
  547. 	if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  548. 	{
  549. 		bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;
    #include &lt;stdio.h&gt;
  550. #include &lt;string.h&gt;
  551. int main( void )
  552. {
  553. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  554. char bigString[MAX_STRING_LEN];
  555. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  556. size_t count = 0;
  557. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  558. {
  559. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  560. const char *delim = &quot; \t&quot;;
  561. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  562. {
  563. p += strspn( p, delim );
  564. if (*p != &#39;\0&#39;)
  565. {
  566. size_t n = strcspn( p, delim );
  567. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  568. memcpy( wordCollection[count], p, len );
  569. wordCollection[count][len] = &#39;\0&#39;;
  570. ++count;
  571. p += n;
  572. }
  573. }
  574. for (size_t i = 0; i &lt; count; i++)
  575. {
  576. puts( wordCollection[i] );
  577. }
  578. }
  579. }
  580. &#39;;
  582. 		const char *delim = &quot; \t&quot;;
  584. 		for (const char *p = bigString; *p != &#39;
    #include &lt;stdio.h&gt;
  585. #include &lt;string.h&gt;
  586. int main( void )
  587. {
  588. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  589. char bigString[MAX_STRING_LEN];
  590. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  591. size_t count = 0;
  592. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  593. {
  594. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  595. const char *delim = &quot; \t&quot;;
  596. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  597. {
  598. p += strspn( p, delim );
  599. if (*p != &#39;\0&#39;)
  600. {
  601. size_t n = strcspn( p, delim );
  602. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  603. memcpy( wordCollection[count], p, len );
  604. wordCollection[count][len] = &#39;\0&#39;;
  605. ++count;
  606. p += n;
  607. }
  608. }
  609. for (size_t i = 0; i &lt; count; i++)
  610. {
  611. puts( wordCollection[i] );
  612. }
  613. }
  614. }
  615. &#39; &amp;&amp; count &lt; WORD_COUNT; )
  616. 		{
  617. 			p += strspn( p, delim );
  620. 			if (*p != &#39;
    #include &lt;stdio.h&gt;
  621. #include &lt;string.h&gt;
  622. int main( void )
  623. {
  624. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  625. char bigString[MAX_STRING_LEN];
  626. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  627. size_t count = 0;
  628. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  629. {
  630. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  631. const char *delim = &quot; \t&quot;;
  632. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  633. {
  634. p += strspn( p, delim );
  635. if (*p != &#39;\0&#39;)
  636. {
  637. size_t n = strcspn( p, delim );
  638. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  639. memcpy( wordCollection[count], p, len );
  640. wordCollection[count][len] = &#39;\0&#39;;
  641. ++count;
  642. p += n;
  643. }
  644. }
  645. for (size_t i = 0; i &lt; count; i++)
  646. {
  647. puts( wordCollection[i] );
  648. }
  649. }
  650. }
  651. &#39;)
  652. 			{
  653. 				size_t n = strcspn( p, delim );
  655. 				size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  657. 				memcpy( wordCollection[count], p, len );
  658. 				wordCollection[count][len] = &#39;
    #include &lt;stdio.h&gt;
  659. #include &lt;string.h&gt;
  660. int main( void )
  661. {
  662. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  663. char bigString[MAX_STRING_LEN];
  664. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  665. size_t count = 0;
  666. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  667. {
  668. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  669. const char *delim = &quot; \t&quot;;
  670. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  671. {
  672. p += strspn( p, delim );
  673. if (*p != &#39;\0&#39;)
  674. {
  675. size_t n = strcspn( p, delim );
  676. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  677. memcpy( wordCollection[count], p, len );
  678. wordCollection[count][len] = &#39;\0&#39;;
  679. ++count;
  680. p += n;
  681. }
  682. }
  683. for (size_t i = 0; i &lt; count; i++)
  684. {
  685. puts( wordCollection[i] );
  686. }
  687. }
  688. }
  689. &#39;;
  690. 				
  691. 				++count;
  693. 				p += n;
  694. 			}
  695. 		}
  697. 		for (size_t i = 0; i &lt; count; i++)
  698. 		{
  699. 			puts( wordCollection[i] );
  700. 		}
  701. 	}
  702. }
  703. &#39;;
  704. 				
  705. 				++count;
  707. 				p += n;
  708. 			}
  709. 		}
  711. 		for (size_t i = 0; i &lt; count; i++)
  712. 		{
  713. 			puts( wordCollection[i] );
  714. 		}
  715. 	}
  716. }

该程序的输出是

  1. This is a string
  2. This
  3. is
  4. a
  5. string
英文:

For starters this call of scanf

  1. scanf(&quot;%s&quot;, bigString);

is unsafe and can read only one word.

Instead you can use standard function fgets.

If a space character is encountered then this while loop

  1. while (bigString[bigIndex]!=&#39; &#39; &amp;&amp; bigString[bigIndex]!=&#39;
    while (bigString[bigIndex]!=&#39; &#39; &amp;&amp; bigString[bigIndex]!=&#39;
    while (bigString[bigIndex]!=&#39; &#39; &amp;&amp; bigString[bigIndex]!=&#39;\0&#39;)
  2. &#39;)
  3. &#39;)

is skipped. In this case an element with the index i of the two-dimensional character array will not be filled by a string. As a result this call of printf

  1. printf(&quot;%s&quot;, wordCollection[i]);

invokes undefined behavior. And moreover if there are several adjacent spaces in the record and the number of words in the string is even less than 10 it can occur such a way that neither word will be outputted.

Also you need to append each element of the array wordCollection that was filled with the terminating zero character &#39;\0&#39; to make a string.

And this pair of statements

  1.   if (bigString[bigIndex]==&#39;
      if (bigString[bigIndex]==&#39;
      if (bigString[bigIndex]==&#39;\0&#39;) i=10;
  2. //...
  3. printf(&quot;%s&quot;, wordCollection[i]);
  4. &#39;) i=10;
  5.   //...
  6.   printf(&quot;%s&quot;, wordCollection[i]);
  7. &#39;) i=10;
  8.   //...
  9.   printf(&quot;%s&quot;, wordCollection[i]);

again invokes undefined behavior because 10 is an invalid index.

Instead of the manually written while loop you could use standard C string functions.

And pay attention to that in general words can be separated by several adjacent spaces of tab characters.

Here is a demonstration program.

  1. #include &lt;stdio.h&gt;
  2. #include &lt;string.h&gt;
  4. int main( void )
  5. {
  6. 	enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  8. 	char bigString[MAX_STRING_LEN];
  9. 	char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  11. 	size_t count = 0;
  13. 	if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  14. 	{
  15. 		bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;
    #include &lt;stdio.h&gt;
  16. #include &lt;string.h&gt;
  18. int main( void )
  19. {
  20. 	enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  22. 	char bigString[MAX_STRING_LEN];
  23. 	char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  25. 	size_t count = 0;
  27. 	if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  28. 	{
  29. 		bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;
    #include &lt;stdio.h&gt;
  30. #include &lt;string.h&gt;
  31. int main( void )
  32. {
  33. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  34. char bigString[MAX_STRING_LEN];
  35. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  36. size_t count = 0;
  37. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  38. {
  39. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  40. const char *delim = &quot; \t&quot;;
  41. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  42. {
  43. p += strspn( p, delim );
  44. if (*p != &#39;\0&#39;)
  45. {
  46. size_t n = strcspn( p, delim );
  47. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  48. memcpy( wordCollection[count], p, len );
  49. wordCollection[count][len] = &#39;\0&#39;;
  50. ++count;
  51. p += n;
  52. }
  53. }
  54. for (size_t i = 0; i &lt; count; i++)
  55. {
  56. puts( wordCollection[i] );
  57. }
  58. }
  59. }
  60. &#39;;
  62. 		const char *delim = &quot; \t&quot;;
  64. 		for (const char *p = bigString; *p != &#39;
    #include &lt;stdio.h&gt;
  65. #include &lt;string.h&gt;
  66. int main( void )
  67. {
  68. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  69. char bigString[MAX_STRING_LEN];
  70. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  71. size_t count = 0;
  72. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  73. {
  74. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  75. const char *delim = &quot; \t&quot;;
  76. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  77. {
  78. p += strspn( p, delim );
  79. if (*p != &#39;\0&#39;)
  80. {
  81. size_t n = strcspn( p, delim );
  82. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  83. memcpy( wordCollection[count], p, len );
  84. wordCollection[count][len] = &#39;\0&#39;;
  85. ++count;
  86. p += n;
  87. }
  88. }
  89. for (size_t i = 0; i &lt; count; i++)
  90. {
  91. puts( wordCollection[i] );
  92. }
  93. }
  94. }
  95. &#39; &amp;&amp; count &lt; WORD_COUNT; )
  96. 		{
  97. 			p += strspn( p, delim );
  100. 			if (*p != &#39;
    #include &lt;stdio.h&gt;
  101. #include &lt;string.h&gt;
  102. int main( void )
  103. {
  104. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  105. char bigString[MAX_STRING_LEN];
  106. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  107. size_t count = 0;
  108. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  109. {
  110. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  111. const char *delim = &quot; \t&quot;;
  112. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  113. {
  114. p += strspn( p, delim );
  115. if (*p != &#39;\0&#39;)
  116. {
  117. size_t n = strcspn( p, delim );
  118. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  119. memcpy( wordCollection[count], p, len );
  120. wordCollection[count][len] = &#39;\0&#39;;
  121. ++count;
  122. p += n;
  123. }
  124. }
  125. for (size_t i = 0; i &lt; count; i++)
  126. {
  127. puts( wordCollection[i] );
  128. }
  129. }
  130. }
  131. &#39;)
  132. 			{
  133. 				size_t n = strcspn( p, delim );
  135. 				size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  137. 				memcpy( wordCollection[count], p, len );
  138. 				wordCollection[count][len] = &#39;
    #include &lt;stdio.h&gt;
  139. #include &lt;string.h&gt;
  140. int main( void )
  141. {
  142. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  143. char bigString[MAX_STRING_LEN];
  144. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  145. size_t count = 0;
  146. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  147. {
  148. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  149. const char *delim = &quot; \t&quot;;
  150. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  151. {
  152. p += strspn( p, delim );
  153. if (*p != &#39;\0&#39;)
  154. {
  155. size_t n = strcspn( p, delim );
  156. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  157. memcpy( wordCollection[count], p, len );
  158. wordCollection[count][len] = &#39;\0&#39;;
  159. ++count;
  160. p += n;
  161. }
  162. }
  163. for (size_t i = 0; i &lt; count; i++)
  164. {
  165. puts( wordCollection[i] );
  166. }
  167. }
  168. }
  169. &#39;;
  170. 				
  171. 				++count;
  173. 				p += n;
  174. 			}
  175. 		}
  177. 		for (size_t i = 0; i &lt; count; i++)
  178. 		{
  179. 			puts( wordCollection[i] );
  180. 		}
  181. 	}
  182. }
  183. &#39;;
  185. 		const char *delim = &quot; \t&quot;;
  187. 		for (const char *p = bigString; *p != &#39;
    #include &lt;stdio.h&gt;
  188. #include &lt;string.h&gt;
  190. int main( void )
  191. {
  192. 	enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  194. 	char bigString[MAX_STRING_LEN];
  195. 	char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  197. 	size_t count = 0;
  199. 	if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  200. 	{
  201. 		bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;
    #include &lt;stdio.h&gt;
  202. #include &lt;string.h&gt;
  203. int main( void )
  204. {
  205. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  206. char bigString[MAX_STRING_LEN];
  207. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  208. size_t count = 0;
  209. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  210. {
  211. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  212. const char *delim = &quot; \t&quot;;
  213. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  214. {
  215. p += strspn( p, delim );
  216. if (*p != &#39;\0&#39;)
  217. {
  218. size_t n = strcspn( p, delim );
  219. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  220. memcpy( wordCollection[count], p, len );
  221. wordCollection[count][len] = &#39;\0&#39;;
  222. ++count;
  223. p += n;
  224. }
  225. }
  226. for (size_t i = 0; i &lt; count; i++)
  227. {
  228. puts( wordCollection[i] );
  229. }
  230. }
  231. }
  232. &#39;;
  234. 		const char *delim = &quot; \t&quot;;
  236. 		for (const char *p = bigString; *p != &#39;
    #include &lt;stdio.h&gt;
  237. #include &lt;string.h&gt;
  238. int main( void )
  239. {
  240. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  241. char bigString[MAX_STRING_LEN];
  242. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  243. size_t count = 0;
  244. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  245. {
  246. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  247. const char *delim = &quot; \t&quot;;
  248. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  249. {
  250. p += strspn( p, delim );
  251. if (*p != &#39;\0&#39;)
  252. {
  253. size_t n = strcspn( p, delim );
  254. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  255. memcpy( wordCollection[count], p, len );
  256. wordCollection[count][len] = &#39;\0&#39;;
  257. ++count;
  258. p += n;
  259. }
  260. }
  261. for (size_t i = 0; i &lt; count; i++)
  262. {
  263. puts( wordCollection[i] );
  264. }
  265. }
  266. }
  267. &#39; &amp;&amp; count &lt; WORD_COUNT; )
  268. 		{
  269. 			p += strspn( p, delim );
  272. 			if (*p != &#39;
    #include &lt;stdio.h&gt;
  273. #include &lt;string.h&gt;
  274. int main( void )
  275. {
  276. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  277. char bigString[MAX_STRING_LEN];
  278. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  279. size_t count = 0;
  280. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  281. {
  282. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  283. const char *delim = &quot; \t&quot;;
  284. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  285. {
  286. p += strspn( p, delim );
  287. if (*p != &#39;\0&#39;)
  288. {
  289. size_t n = strcspn( p, delim );
  290. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  291. memcpy( wordCollection[count], p, len );
  292. wordCollection[count][len] = &#39;\0&#39;;
  293. ++count;
  294. p += n;
  295. }
  296. }
  297. for (size_t i = 0; i &lt; count; i++)
  298. {
  299. puts( wordCollection[i] );
  300. }
  301. }
  302. }
  303. &#39;)
  304. 			{
  305. 				size_t n = strcspn( p, delim );
  307. 				size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  309. 				memcpy( wordCollection[count], p, len );
  310. 				wordCollection[count][len] = &#39;
    #include &lt;stdio.h&gt;
  311. #include &lt;string.h&gt;
  312. int main( void )
  313. {
  314. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  315. char bigString[MAX_STRING_LEN];
  316. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  317. size_t count = 0;
  318. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  319. {
  320. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  321. const char *delim = &quot; \t&quot;;
  322. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  323. {
  324. p += strspn( p, delim );
  325. if (*p != &#39;\0&#39;)
  326. {
  327. size_t n = strcspn( p, delim );
  328. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  329. memcpy( wordCollection[count], p, len );
  330. wordCollection[count][len] = &#39;\0&#39;;
  331. ++count;
  332. p += n;
  333. }
  334. }
  335. for (size_t i = 0; i &lt; count; i++)
  336. {
  337. puts( wordCollection[i] );
  338. }
  339. }
  340. }
  341. &#39;;
  342. 				
  343. 				++count;
  345. 				p += n;
  346. 			}
  347. 		}
  349. 		for (size_t i = 0; i &lt; count; i++)
  350. 		{
  351. 			puts( wordCollection[i] );
  352. 		}
  353. 	}
  354. }
  355. &#39; &amp;&amp; count &lt; WORD_COUNT; )
  356. 		{
  357. 			p += strspn( p, delim );
  360. 			if (*p != &#39;
    #include &lt;stdio.h&gt;
  361. #include &lt;string.h&gt;
  363. int main( void )
  364. {
  365. 	enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  367. 	char bigString[MAX_STRING_LEN];
  368. 	char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  370. 	size_t count = 0;
  372. 	if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  373. 	{
  374. 		bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;
    #include &lt;stdio.h&gt;
  375. #include &lt;string.h&gt;
  376. int main( void )
  377. {
  378. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  379. char bigString[MAX_STRING_LEN];
  380. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  381. size_t count = 0;
  382. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  383. {
  384. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  385. const char *delim = &quot; \t&quot;;
  386. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  387. {
  388. p += strspn( p, delim );
  389. if (*p != &#39;\0&#39;)
  390. {
  391. size_t n = strcspn( p, delim );
  392. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  393. memcpy( wordCollection[count], p, len );
  394. wordCollection[count][len] = &#39;\0&#39;;
  395. ++count;
  396. p += n;
  397. }
  398. }
  399. for (size_t i = 0; i &lt; count; i++)
  400. {
  401. puts( wordCollection[i] );
  402. }
  403. }
  404. }
  405. &#39;;
  407. 		const char *delim = &quot; \t&quot;;
  409. 		for (const char *p = bigString; *p != &#39;
    #include &lt;stdio.h&gt;
  410. #include &lt;string.h&gt;
  411. int main( void )
  412. {
  413. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  414. char bigString[MAX_STRING_LEN];
  415. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  416. size_t count = 0;
  417. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  418. {
  419. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  420. const char *delim = &quot; \t&quot;;
  421. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  422. {
  423. p += strspn( p, delim );
  424. if (*p != &#39;\0&#39;)
  425. {
  426. size_t n = strcspn( p, delim );
  427. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  428. memcpy( wordCollection[count], p, len );
  429. wordCollection[count][len] = &#39;\0&#39;;
  430. ++count;
  431. p += n;
  432. }
  433. }
  434. for (size_t i = 0; i &lt; count; i++)
  435. {
  436. puts( wordCollection[i] );
  437. }
  438. }
  439. }
  440. &#39; &amp;&amp; count &lt; WORD_COUNT; )
  441. 		{
  442. 			p += strspn( p, delim );
  445. 			if (*p != &#39;
    #include &lt;stdio.h&gt;
  446. #include &lt;string.h&gt;
  447. int main( void )
  448. {
  449. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  450. char bigString[MAX_STRING_LEN];
  451. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  452. size_t count = 0;
  453. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  454. {
  455. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  456. const char *delim = &quot; \t&quot;;
  457. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  458. {
  459. p += strspn( p, delim );
  460. if (*p != &#39;\0&#39;)
  461. {
  462. size_t n = strcspn( p, delim );
  463. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  464. memcpy( wordCollection[count], p, len );
  465. wordCollection[count][len] = &#39;\0&#39;;
  466. ++count;
  467. p += n;
  468. }
  469. }
  470. for (size_t i = 0; i &lt; count; i++)
  471. {
  472. puts( wordCollection[i] );
  473. }
  474. }
  475. }
  476. &#39;)
  477. 			{
  478. 				size_t n = strcspn( p, delim );
  480. 				size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  482. 				memcpy( wordCollection[count], p, len );
  483. 				wordCollection[count][len] = &#39;
    #include &lt;stdio.h&gt;
  484. #include &lt;string.h&gt;
  485. int main( void )
  486. {
  487. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  488. char bigString[MAX_STRING_LEN];
  489. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  490. size_t count = 0;
  491. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  492. {
  493. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  494. const char *delim = &quot; \t&quot;;
  495. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  496. {
  497. p += strspn( p, delim );
  498. if (*p != &#39;\0&#39;)
  499. {
  500. size_t n = strcspn( p, delim );
  501. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  502. memcpy( wordCollection[count], p, len );
  503. wordCollection[count][len] = &#39;\0&#39;;
  504. ++count;
  505. p += n;
  506. }
  507. }
  508. for (size_t i = 0; i &lt; count; i++)
  509. {
  510. puts( wordCollection[i] );
  511. }
  512. }
  513. }
  514. &#39;;
  515. 				
  516. 				++count;
  518. 				p += n;
  519. 			}
  520. 		}
  522. 		for (size_t i = 0; i &lt; count; i++)
  523. 		{
  524. 			puts( wordCollection[i] );
  525. 		}
  526. 	}
  527. }
  528. &#39;)
  529. 			{
  530. 				size_t n = strcspn( p, delim );
  532. 				size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  534. 				memcpy( wordCollection[count], p, len );
  535. 				wordCollection[count][len] = &#39;
    #include &lt;stdio.h&gt;
  536. #include &lt;string.h&gt;
  538. int main( void )
  539. {
  540. 	enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  542. 	char bigString[MAX_STRING_LEN];
  543. 	char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  545. 	size_t count = 0;
  547. 	if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  548. 	{
  549. 		bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;
    #include &lt;stdio.h&gt;
  550. #include &lt;string.h&gt;
  551. int main( void )
  552. {
  553. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  554. char bigString[MAX_STRING_LEN];
  555. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  556. size_t count = 0;
  557. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  558. {
  559. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  560. const char *delim = &quot; \t&quot;;
  561. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  562. {
  563. p += strspn( p, delim );
  564. if (*p != &#39;\0&#39;)
  565. {
  566. size_t n = strcspn( p, delim );
  567. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  568. memcpy( wordCollection[count], p, len );
  569. wordCollection[count][len] = &#39;\0&#39;;
  570. ++count;
  571. p += n;
  572. }
  573. }
  574. for (size_t i = 0; i &lt; count; i++)
  575. {
  576. puts( wordCollection[i] );
  577. }
  578. }
  579. }
  580. &#39;;
  582. 		const char *delim = &quot; \t&quot;;
  584. 		for (const char *p = bigString; *p != &#39;
    #include &lt;stdio.h&gt;
  585. #include &lt;string.h&gt;
  586. int main( void )
  587. {
  588. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  589. char bigString[MAX_STRING_LEN];
  590. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  591. size_t count = 0;
  592. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  593. {
  594. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  595. const char *delim = &quot; \t&quot;;
  596. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  597. {
  598. p += strspn( p, delim );
  599. if (*p != &#39;\0&#39;)
  600. {
  601. size_t n = strcspn( p, delim );
  602. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  603. memcpy( wordCollection[count], p, len );
  604. wordCollection[count][len] = &#39;\0&#39;;
  605. ++count;
  606. p += n;
  607. }
  608. }
  609. for (size_t i = 0; i &lt; count; i++)
  610. {
  611. puts( wordCollection[i] );
  612. }
  613. }
  614. }
  615. &#39; &amp;&amp; count &lt; WORD_COUNT; )
  616. 		{
  617. 			p += strspn( p, delim );
  620. 			if (*p != &#39;
    #include &lt;stdio.h&gt;
  621. #include &lt;string.h&gt;
  622. int main( void )
  623. {
  624. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  625. char bigString[MAX_STRING_LEN];
  626. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  627. size_t count = 0;
  628. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  629. {
  630. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  631. const char *delim = &quot; \t&quot;;
  632. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  633. {
  634. p += strspn( p, delim );
  635. if (*p != &#39;\0&#39;)
  636. {
  637. size_t n = strcspn( p, delim );
  638. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  639. memcpy( wordCollection[count], p, len );
  640. wordCollection[count][len] = &#39;\0&#39;;
  641. ++count;
  642. p += n;
  643. }
  644. }
  645. for (size_t i = 0; i &lt; count; i++)
  646. {
  647. puts( wordCollection[i] );
  648. }
  649. }
  650. }
  651. &#39;)
  652. 			{
  653. 				size_t n = strcspn( p, delim );
  655. 				size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  657. 				memcpy( wordCollection[count], p, len );
  658. 				wordCollection[count][len] = &#39;
    #include &lt;stdio.h&gt;
  659. #include &lt;string.h&gt;
  660. int main( void )
  661. {
  662. enum { MAX_STRING_LEN = 1000, WORD_COUNT = 10, MAX_WORD_LEN = 100 };
  663. char bigString[MAX_STRING_LEN];
  664. char wordCollection[WORD_COUNT][MAX_WORD_LEN];
  665. size_t count = 0;
  666. if (fgets( bigString, MAX_STRING_LEN, stdin ) != NULL)
  667. {
  668. bigString[strcspn( bigString, &quot;\n&quot; )] = &#39;\0&#39;;
  669. const char *delim = &quot; \t&quot;;
  670. for (const char *p = bigString; *p != &#39;\0&#39; &amp;&amp; count &lt; WORD_COUNT; )
  671. {
  672. p += strspn( p, delim );
  673. if (*p != &#39;\0&#39;)
  674. {
  675. size_t n = strcspn( p, delim );
  676. size_t len = n &lt; MAX_WORD_LEN ? n : MAX_WORD_LEN - 1;
  677. memcpy( wordCollection[count], p, len );
  678. wordCollection[count][len] = &#39;\0&#39;;
  679. ++count;
  680. p += n;
  681. }
  682. }
  683. for (size_t i = 0; i &lt; count; i++)
  684. {
  685. puts( wordCollection[i] );
  686. }
  687. }
  688. }
  689. &#39;;
  690. 				
  691. 				++count;
  693. 				p += n;
  694. 			}
  695. 		}
  697. 		for (size_t i = 0; i &lt; count; i++)
  698. 		{
  699. 			puts( wordCollection[i] );
  700. 		}
  701. 	}
  702. }
  703. &#39;;
  704. 				
  705. 				++count;
  707. 				p += n;
  708. 			}
  709. 		}
  711. 		for (size_t i = 0; i &lt; count; i++)
  712. 		{
  713. 			puts( wordCollection[i] );
  714. 		}
  715. 	}
  716. }

The program output is

  1. This is a string
  2. This
  3. is
  4. a
  5. string

答案3

得分: 0

  1. 使用符号常量而不是魔法值。
  2. scanf("%s", ...) 读取以空格分隔的单词，因此 bigString 永远不会包含多于1个单词。你可以使用"%[^\n]"格式字符串来读取行（但请看下一个）。
  3. 使用 scanf() 读取字符串时，始终使用最大字段宽度。
  4. 检查 scanf() 的返回值，否则你可能会操作未初始化的数据。
  5. 我建议你使用 fgets() 而不是 scanf()。
  6. 我建议你使用单循环而不是双循环。这意味着你只需在一个地方进行边界检查。
  7. （未修复）考虑将打印与处理分开；如果这样做，bigString 的终止'\0'就是正常情况，而 break 可以移到循环底部。
  8. 你需要以'\0'终止单词；否则 printf() 将是未定义的行为。
  9. i=10; 后跟 wordCollection[i] 超出了边界，这意味着未定义的行为。
英文:
  1. Use symbolic constants instead of magic values.
  2. scanf(&quot;%s&quot;, ...) reads white space separated words so bigString will never contain more than 1 word. You can use a "%[^\n]" the format string to read lines (but see next).
  3. Always use a maximum field width when reading strings with scanf().
  4. Check the return value from scanf() otherwise you might be operating on uninitialized data.
  5. I suggest you use fgets() instead of scanf().
  6. I suggest you use a single loop instead of the double loop. This means you only have to do boundary checks in one place.
  7. (Not fixed) Consider separating print from processing; if you do then the terminating &#39;\0&#39; of bigString is just the normal case, and the break can move to the bottom of the loop.
  8. You need to '\0' terminate words; otherwise printf() will be undefined behavior.
  9. i=10; followed by wordCollection[i] is out of bounds which means undefined behavior.
  1. #include &lt;stdio.h&gt;
  2. #include &lt;stdlib.h&gt;
  3. #include &lt;string.h&gt;
  5. #define STRING_LEN 1000
  6. #define WORDS 10
  7. #define WORD_LEN 100
  9. int main(void) {
  10. 	char bigString[STRING_LEN];
  11. 	if(!fgets(bigString, STRING_LEN, stdin)) {
  12.          printf(&quot;fgets() failed\n&quot;);
  13.          return 1;
  14.     }
  15. 	bigString[strcspn(bigString, &quot;\n&quot;)] = &#39;
    #include &lt;stdio.h&gt;
  16. #include &lt;stdlib.h&gt;
  17. #include &lt;string.h&gt;
  18. #define STRING_LEN 1000
  19. #define WORDS 10
  20. #define WORD_LEN 100
  21. int main(void) {
  22. char bigString[STRING_LEN];
  23. if(!fgets(bigString, STRING_LEN, stdin)) {
  24. printf(&quot;fgets() failed\n&quot;);
  25. return 1;
  26. }
  27. bigString[strcspn(bigString, &quot;\n&quot;)] = &#39;\0&#39;;
  28. char wordCollection[WORDS][WORD_LEN];
  29. int word = 0;
  30. int word_i = 0;
  31. for(int i = 0;; i++) {
  32. if(word_i == WORD_LEN) {
  33. printf(&quot;word too big\n&quot;);
  34. return 1;
  35. }
  36. if(word == WORDS) {
  37. printf(&quot;too many words\n&quot;);
  38. return 1;
  39. }
  40. if(bigString[i] == &#39; &#39; || !bigString[i]) {
  41. wordCollection[word][word_i] = &#39;\0&#39;;
  42. printf(&quot;%s\n&quot;, wordCollection[word]);
  43. word++;
  44. word_i = 0;
  45. if(!bigString[i])
  46. break;
  47. continue;
  48. }
  49. wordCollection[word][word_i++] = bigString[i];
  50. }
  51. }
  52. &#39;;
  54. 	char wordCollection[WORDS][WORD_LEN];
  55. 	int word = 0;
  56. 	int word_i = 0;
  57. 	for(int i = 0;; i++) {
  58. 		if(word_i == WORD_LEN) {
  59. 			printf(&quot;word too big\n&quot;);
  60. 			return 1;
  61. 		}
  62. 		if(word == WORDS) {
  63. 			printf(&quot;too many words\n&quot;);
  64. 			return 1;
  65. 		}
  66. 		if(bigString[i] == &#39; &#39; || !bigString[i]) {
  67. 			wordCollection[word][word_i] = &#39;
    #include &lt;stdio.h&gt;
  68. #include &lt;stdlib.h&gt;
  69. #include &lt;string.h&gt;
  70. #define STRING_LEN 1000
  71. #define WORDS 10
  72. #define WORD_LEN 100
  73. int main(void) {
  74. char bigString[STRING_LEN];
  75. if(!fgets(bigString, STRING_LEN, stdin)) {
  76. printf(&quot;fgets() failed\n&quot;);
  77. return 1;
  78. }
  79. bigString[strcspn(bigString, &quot;\n&quot;)] = &#39;\0&#39;;
  80. char wordCollection[WORDS][WORD_LEN];
  81. int word = 0;
  82. int word_i = 0;
  83. for(int i = 0;; i++) {
  84. if(word_i == WORD_LEN) {
  85. printf(&quot;word too big\n&quot;);
  86. return 1;
  87. }
  88. if(word == WORDS) {
  89. printf(&quot;too many words\n&quot;);
  90. return 1;
  91. }
  92. if(bigString[i] == &#39; &#39; || !bigString[i]) {
  93. wordCollection[word][word_i] = &#39;\0&#39;;
  94. printf(&quot;%s\n&quot;, wordCollection[word]);
  95. word++;
  96. word_i = 0;
  97. if(!bigString[i])
  98. break;
  99. continue;
  100. }
  101. wordCollection[word][word_i++] = bigString[i];
  102. }
  103. }
  104. &#39;;
  105. 			printf(&quot;%s\n&quot;, wordCollection[word]);
  106. 			word++;
  107. 			word_i = 0;
  108. 			if(!bigString[i])
  109. 				break;
  110. 			continue;
  111. 		}
  112. 		wordCollection[word][word_i++] = bigString[i];
  113. 	}
  114. }

example run:

  1. hello world
  2. hello
  3. world
  1. 1 2 3 4 5 6 7 8 9 10 11
  2. 1
  3. 2
  4. 3
  5. 4
  6. 5
  7. 6
  8. 7
  9. 8
  10. 9
  11. 10
  12. too many words

and with WORD_LEN reduced to 10 (not enough space to write the terminating '\0'):

  1. 1234567890
  2. word too big

huangapple
  • 本文由 发表于 2023年6月9日 02:16:29
  • 转载请务必保留本文链接：https://go.coder-hub.com/76434661.html
  • c
  • c-strings
  • multidimensional-array
  • split
  • substring
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定