Removing first word using pointers from char array(C++)

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

Removing first word using pointers from char array(C++)

问题

I need to write a program to remove the first word from a char array (char []) using only pointers. If there are multiple blank spaces in front, I have to ignore them and remove the first word.

These are the loops I used:

  1. #include <iostream>
  2. #include <cmath>
  4. int main()
  5. {
  6.     char sentence[1000];
  7.     std::cout << "Input sentence: ";
  8.     std::cin.getline(sentence, 1000);
  9.     char *p = sentence;
  10.     while (*p == ' ' && *p++ == ' ')
  11.     {
  12.         p++;
  13.     }
  14.     while (*p != ' ')
  15.     {
  16.         p++;
  17.     }
  18.     std::cout << "Sentence without first word: ";
  19.     while (*p != 0)
  20.     {
  21.         std::cout << *p;
  22.         p++;
  23.     }
  24.     std::cout << std::endl;
  25.     return 0;
  26. }

*p is a pointer to a character array (char *p = char int[1000]).

When I output the char array later to see if the program is working, it doesn't work properly if the array was an empty array or a one-word array.

Why does *p (pointer to character) print out random signs (chars) instead of nothing when the array is blank?

Example:

  1. Input:       word
  3. Output: #U

Full program instead of just loops for editing the array.

英文:

I need to write a program to remove the first word from a char array (char []) using only pointers. If there are multiple blank spaces in front, I have to ignore them and remove the first word.

These are the loops I used:

  1. #include &lt;iostream&gt;
  2. #include &lt;cmath&gt;
  4. int main()
  5. {
  6.     char sentence[1000];
  7.     std::cout&lt;&lt;&quot;Input sentence: &quot;;
  8.     std::cin.getline(sentence,1000);
  9.     char *p=sentence;
  10.     while(*p==&#39; &#39; &amp;&amp; *p++==&#39; &#39;)
  11.     {
  12.         p++;
  13.     }
  14.     while(*p!=&#39; &#39;)
  15.     {
  16.         p++;
  17.     }
  18.     std::cout&lt;&lt;&quot;Sentence without first word: &quot;;
  19.     while(*p!=0)
  20.     {
  21.         std::cout&lt;&lt;*p;
  22.         p++;
  23.     }
  24.     std::cout&lt;&lt;std::endl;
  25.     return 0;
  26. }

*p is a pointer to char[] (char *p=char int[1000])

When I output the char array later to see if the program is working, it doesn't work properly if the array was an empty array or a one-word array.

Why does *p (pointer to character) print out random signs (chars) instead of nothing, when the array is blank?

Example:

  1. Input:       word
  3. Output: #U

Full program instead of just loops for editing the array.

答案1

得分: 2

Your 1st and 2nd while loops don't stop if the null terminator '\0' is reached. So, when the array is empty or contains only 1 word, you are advancing p past the null terminator into an uninitialized section of the array, and possibly even beyond the end of the array into surrounding memory.

Also, you should not be doing p++ inside the 1st loop's condition like you are doing. Your 1st loop is advancing p by two characters per iteration when *p is a space character. It should be advancing p by only one character per iteration.

Try this instead:

  1. #include <iostream>
  3. int main()
  4. {
  5.     char sentence[1000] = {};
  6.     std::cout << "Input sentence: ";
  7.     std::cin.getline(sentence, 1000);
  9.     char *p = sentence;
  11.     // skip leading whitespace before 1st word
  12.     while (*p <= ' ' && *p != '
    #include <iostream>
  14. int main()
  15. {
  16.     char sentence[1000] = {};
  17.     std::cout << "Input sentence: ";
  18.     std::cin.getline(sentence, 1000);
  20.     char *p = sentence;
  22.     // skip leading whitespace before 1st word
  23.     while (*p <= ' ' && *p != '\0') {
  24.         ++p;
  25.     }
  27.     // skip 1st word
  28.     while (*p > ' ') {
  29.         ++p;
  30.     }
  32.     // skip whitespace between 1st and 2nd words
  33.     while (*p <= ' ' && *p != '\0') {
  34.         ++p;
  35.     }
  37.     std::cout << "Sentence without first word: ";
  38.     while (*p != '\0') {
  39.         std::cout << *p;
  40.         ++p;
  41.     }
  42.     // or simply:
  43.     // std::cout << p;
  45.     std::cout << std::endl;
  46.     return 0;
  47. }
  48. ') {
  49.         ++p;
  50.     }
  52.     // skip 1st word
  53.     while (*p > ' ') {
  54.         ++p;
  55.     }
  57.     // skip whitespace between 1st and 2nd words
  58.     while (*p <= ' ' && *p != '
    #include <iostream>
  60. int main()
  61. {
  62.     char sentence[1000] = {};
  63.     std::cout << "Input sentence: ";
  64.     std::cin.getline(sentence, 1000);
  66.     char *p = sentence;
  68.     // skip leading whitespace before 1st word
  69.     while (*p <= ' ' && *p != '\0') {
  70.         ++p;
  71.     }
  73.     // skip 1st word
  74.     while (*p > ' ') {
  75.         ++p;
  76.     }
  78.     // skip whitespace between 1st and 2nd words
  79.     while (*p <= ' ' && *p != '\0') {
  80.         ++p;
  81.     }
  83.     std::cout << "Sentence without first word: ";
  84.     while (*p != '\0') {
  85.         std::cout << *p;
  86.         ++p;
  87.     }
  88.     // or simply:
  89.     // std::cout << p;
  91.     std::cout << std::endl;
  92.     return 0;
  93. }
  94. ') {
  95.         ++p;
  96.     }
  98.     std::cout << "Sentence without first word: ";
  99.     while (*p != '
    #include <iostream>
  101. int main()
  102. {
  103.     char sentence[1000] = {};
  104.     std::cout << "Input sentence: ";
  105.     std::cin.getline(sentence, 1000);
  107.     char *p = sentence;
  109.     // skip leading whitespace before 1st word
  110.     while (*p <= ' ' && *p != '\0') {
  111.         ++p;
  112.     }
  114.     // skip 1st word
  115.     while (*p > ' ') {
  116.         ++p;
  117.     }
  119.     // skip whitespace between 1st and 2nd words
  120.     while (*p <= ' ' && *p != '\0') {
  121.         ++p;
  122.     }
  124.     std::cout << "Sentence without first word: ";
  125.     while (*p != '\0') {
  126.         std::cout << *p;
  127.         ++p;
  128.     }
  129.     // or simply:
  130.     // std::cout << p;
  132.     std::cout << std::endl;
  133.     return 0;
  134. }
  135. ') {
  136.         std::cout << *p;
  137.         ++p;
  138.     }
  139.     // or simply:
  140.     // std::cout << p;
  142.     std::cout << std::endl;
  143.     return 0;
  144. }
英文:

Your 1st and 2nd while loops don't stop if the null terminator &#39;\0&#39; is reached. So, when the array is empty or contains only 1 word, you are advancing p past the null terminator into an uninitialized section of the array, and possibly even beyond the end of the array into surrounding memory.

Also, you should not be doing p++ inside the 1st loop's condition like you are doing. Your 1st loop is advancing p by two characters per iteration when *p is a space character. It should be advancing p by only one character per iteration.

Try this instead:

  1. #include &lt;iostream&gt;
  3. int main()
  4. {
  5.     char sentence[1000] = {};
  6.     std::cout &lt;&lt; &quot;Input sentence: &quot;;
  7.     std::cin.getline(sentence, 1000);
  9.     char *p = sentence;
  11.     // skip leading whitespace before 1st word
  12.     while (*p &lt;= &#39; &#39; &amp;&amp; *p != &#39;
    #include &lt;iostream&gt;
  13. int main()
  14. {
  15. char sentence[1000] = {};
  16. std::cout &lt;&lt; &quot;Input sentence: &quot;;
  17. std::cin.getline(sentence, 1000);
  18. char *p = sentence;
  19. // skip leading whitespace before 1st word
  20. while (*p &lt;= &#39; &#39; &amp;&amp; *p != &#39;\0&#39;) {
  21. ++p;
  22. }
  23. // skip 1st word
  24. while (*p &gt; &#39; &#39;) {
  25. ++p;
  26. }
  27. // skip whitespace between 1st and 2nd words
  28. while (*p &lt;= &#39; &#39; &amp;&amp; *p != &#39;\0&#39;) {
  29. ++p;
  30. }
  31. std::cout &lt;&lt; &quot;Sentence without first word: &quot;;
  32. while (*p != &#39;\0&#39;) {
  33. std::cout &lt;&lt; *p;
  34. ++p;
  35. }
  36. // or simply:
  37. // std::cout &lt;&lt; p;
  38. std::cout &lt;&lt; std::endl;
  39. return 0;
  40. }
  41. &#39;) {
  42.         ++p;
  43.     }
  45.     // skip 1st word
  46.     while (*p &gt; &#39; &#39;) {
  47.         ++p;
  48.     }
  50.     // skip whitespace between 1st and 2nd words
  51.     while (*p &lt;= &#39; &#39; &amp;&amp; *p != &#39;
    #include &lt;iostream&gt;
  52. int main()
  53. {
  54. char sentence[1000] = {};
  55. std::cout &lt;&lt; &quot;Input sentence: &quot;;
  56. std::cin.getline(sentence, 1000);
  57. char *p = sentence;
  58. // skip leading whitespace before 1st word
  59. while (*p &lt;= &#39; &#39; &amp;&amp; *p != &#39;\0&#39;) {
  60. ++p;
  61. }
  62. // skip 1st word
  63. while (*p &gt; &#39; &#39;) {
  64. ++p;
  65. }
  66. // skip whitespace between 1st and 2nd words
  67. while (*p &lt;= &#39; &#39; &amp;&amp; *p != &#39;\0&#39;) {
  68. ++p;
  69. }
  70. std::cout &lt;&lt; &quot;Sentence without first word: &quot;;
  71. while (*p != &#39;\0&#39;) {
  72. std::cout &lt;&lt; *p;
  73. ++p;
  74. }
  75. // or simply:
  76. // std::cout &lt;&lt; p;
  77. std::cout &lt;&lt; std::endl;
  78. return 0;
  79. }
  80. &#39;) {
  81.         ++p;
  82.     }
  84.     std::cout &lt;&lt; &quot;Sentence without first word: &quot;;
  85.     while (*p != &#39;
    #include &lt;iostream&gt;
  86. int main()
  87. {
  88. char sentence[1000] = {};
  89. std::cout &lt;&lt; &quot;Input sentence: &quot;;
  90. std::cin.getline(sentence, 1000);
  91. char *p = sentence;
  92. // skip leading whitespace before 1st word
  93. while (*p &lt;= &#39; &#39; &amp;&amp; *p != &#39;\0&#39;) {
  94. ++p;
  95. }
  96. // skip 1st word
  97. while (*p &gt; &#39; &#39;) {
  98. ++p;
  99. }
  100. // skip whitespace between 1st and 2nd words
  101. while (*p &lt;= &#39; &#39; &amp;&amp; *p != &#39;\0&#39;) {
  102. ++p;
  103. }
  104. std::cout &lt;&lt; &quot;Sentence without first word: &quot;;
  105. while (*p != &#39;\0&#39;) {
  106. std::cout &lt;&lt; *p;
  107. ++p;
  108. }
  109. // or simply:
  110. // std::cout &lt;&lt; p;
  111. std::cout &lt;&lt; std::endl;
  112. return 0;
  113. }
  114. &#39;) {
  115.         std::cout &lt;&lt; *p;
  116.         ++p;
  117.     }
  118.     // or simply:
  119.     // std::cout &lt;&lt; p;
  121.     std::cout &lt;&lt; std::endl;
  122.     return 0;
  123. }

答案2

得分: 1

  1. while (*p != ' ')

字符串的末尾由一个 '\0' 字节标记。这个字节不是空格。因此，这个while循环会继续前进，寻找一个不存在的空格，导致未定义的行为。这是计算机编程黄金法则的一个例子：「你的计算机总是按照你告诉它做的事情来做，而不是你想让它做的事情。」你告诉你的计算机，在看到 '\0' 之前不要停止while循环。所以你的计算机会执行这个任务。你需要在这里检查空格和 '\0'。

  2. <details>
  3. <summary>英文:</summary>

while(*p!=' ')

  1. The end of a character string is marked by a &#39;`
    The end of a character string is marked by a &#39;`\0&#39;` byte.
  2. Which is not a space.
  3. So, this while loop will happily plow forward, looking for a nonexistent space, resulting in undefined behavior.
  4. This is an example of the Golden Rule Of Computer Programming in force: &quot;Your Computer Always Does Exactly What You Tell It To Do Instead Of What You Want It To Do&quot;. You told your computer to not stop the while loop until it sees a `&#39; &#39;`. So that&#39;s what your computer does. The end of the string will not stop your computer, from this mission.
  5. You need to check for both the space and a `&#39;\0&#39;`, here.
  6. </details>
  7. # 答案3
  8. **得分**: 1
  9. 这是一个关于C语言的问题，而不是C++问题，重要的是要记住，“传统”的C字符串以`'\0'`字节结尾。未能检查这一点会导致各种内存访问错误。
  10. 这是一个快速、粗糙、不太规范的实现，它跳过了输入的每一行的第一个单词，同时正确地检查C字符串的结束字节。是否应该跳过第一个单词之后的空格（而不仅仅是第一个单词之前的空格），这很容易调整。
  11. ```c++
  12. #include <iostream>
  13. #include <string>
  14. namespace {
  15. const char* skip_first_word_c_style(const char* c_str) {
  16. while (*c_str && *c_str == ' ') ++c_str;  // spaces before first word
  17. while (*c_str && *c_str != ' ') ++c_str;  // first word
  18. while (*c_str && *c_str == ' ') ++c_str;  // spaces after first word
  19. return c_str;
  20. }
  21. }  // namespace
  22. int main() {
  23. std::string line;
  24. while (std::getline(std::cin, line)) {
  25. std::cout << skip_first_word_c_style(line.c_str()) << std::endl;
  26. }
  27. }
  28. &#39;` byte.
  30. Which is not a space.
  32. So, this while loop will happily plow forward, looking for a nonexistent space, resulting in undefined behavior.
  34. This is an example of the Golden Rule Of Computer Programming in force: &quot;Your Computer Always Does Exactly What You Tell It To Do Instead Of What You Want It To Do&quot;. You told your computer to not stop the while loop until it sees a `&#39; &#39;`. So that&#39;s what your computer does. The end of the string will not stop your computer, from this mission.
  36. You need to check for both the space and a `&#39;
    The end of a character string is marked by a &#39;`\0&#39;` byte.
  37. Which is not a space.
  38. So, this while loop will happily plow forward, looking for a nonexistent space, resulting in undefined behavior.
  39. This is an example of the Golden Rule Of Computer Programming in force: &quot;Your Computer Always Does Exactly What You Tell It To Do Instead Of What You Want It To Do&quot;. You told your computer to not stop the while loop until it sees a `&#39; &#39;`. So that&#39;s what your computer does. The end of the string will not stop your computer, from this mission.
  40. You need to check for both the space and a `&#39;\0&#39;`, here.
  41. </details>
  42. # 答案3
  43. **得分**: 1
  44. 这是一个关于C语言的问题，而不是C++问题，重要的是要记住，“传统”的C字符串以`'\0'`字节结尾。未能检查这一点会导致各种内存访问错误。
  45. 这是一个快速、粗糙、不太规范的实现，它跳过了输入的每一行的第一个单词，同时正确地检查C字符串的结束字节。是否应该跳过第一个单词之后的空格（而不仅仅是第一个单词之前的空格），这很容易调整。
  46. ```c++
  47. #include <iostream>
  48. #include <string>
  49. namespace {
  50. const char* skip_first_word_c_style(const char* c_str) {
  51. while (*c_str && *c_str == ' ') ++c_str;  // spaces before first word
  52. while (*c_str && *c_str != ' ') ++c_str;  // first word
  53. while (*c_str && *c_str == ' ') ++c_str;  // spaces after first word
  54. return c_str;
  55. }
  56. }  // namespace
  57. int main() {
  58. std::string line;
  59. while (std::getline(std::cin, line)) {
  60. std::cout << skip_first_word_c_style(line.c_str()) << std::endl;
  61. }
  62. }
  63. &#39;`, here.
  66. </details>
  70. # 答案3
  71. **得分**: 1
  73. 这是一个关于C语言的问题，而不是C++问题，重要的是要记住，“传统”的C字符串以`'
    The end of a character string is marked by a &#39;`\0&#39;` byte.
  74. Which is not a space.
  75. So, this while loop will happily plow forward, looking for a nonexistent space, resulting in undefined behavior.
  76. This is an example of the Golden Rule Of Computer Programming in force: &quot;Your Computer Always Does Exactly What You Tell It To Do Instead Of What You Want It To Do&quot;. You told your computer to not stop the while loop until it sees a `&#39; &#39;`. So that&#39;s what your computer does. The end of the string will not stop your computer, from this mission.
  77. You need to check for both the space and a `&#39;\0&#39;`, here.
  78. </details>
  79. # 答案3
  80. **得分**: 1
  81. 这是一个关于C语言的问题，而不是C++问题，重要的是要记住，“传统”的C字符串以`'\0'`字节结尾。未能检查这一点会导致各种内存访问错误。
  82. 这是一个快速、粗糙、不太规范的实现，它跳过了输入的每一行的第一个单词，同时正确地检查C字符串的结束字节。是否应该跳过第一个单词之后的空格（而不仅仅是第一个单词之前的空格），这很容易调整。
  83. ```c++
  84. #include <iostream>
  85. #include <string>
  86. namespace {
  87. const char* skip_first_word_c_style(const char* c_str) {
  88. while (*c_str && *c_str == ' ') ++c_str;  // spaces before first word
  89. while (*c_str && *c_str != ' ') ++c_str;  // first word
  90. while (*c_str && *c_str == ' ') ++c_str;  // spaces after first word
  91. return c_str;
  92. }
  93. }  // namespace
  94. int main() {
  95. std::string line;
  96. while (std::getline(std::cin, line)) {
  97. std::cout << skip_first_word_c_style(line.c_str()) << std::endl;
  98. }
  99. }
  100. '`字节结尾。未能检查这一点会导致各种内存访问错误。
  102. 这是一个快速、粗糙、不太规范的实现，它跳过了输入的每一行的第一个单词，同时正确地检查C字符串的结束字节。是否应该跳过第一个单词之后的空格（而不仅仅是第一个单词之前的空格），这很容易调整。
  104. ```c++
  105. #include <iostream>
  106. #include <string>
  108. namespace {
  109. const char* skip_first_word_c_style(const char* c_str) {
  110.   while (*c_str && *c_str == ' ') ++c_str;  // spaces before first word
  111.   while (*c_str && *c_str != ' ') ++c_str;  // first word
  112.   while (*c_str && *c_str == ' ') ++c_str;  // spaces after first word
  113.   return c_str;
  114. }
  115. }  // namespace
  117. int main() {
  118.   std::string line;
  119.   while (std::getline(std::cin, line)) {
  120.     std::cout << skip_first_word_c_style(line.c_str()) << std::endl;
  121.   }
  122. }

如果您需要进一步的信息或帮助，请告诉我。

英文:

Well, this is a C question, not a C++ question, and it is important to keep in mind that “traditional” C strings end with a &#39;\0&#39; byte. Failing to check for that leads to all sorts of memory access errors.

Here’s a quick and dirty and sloppy implementation that skips the first word of each line on its input while checking for C-string ending bytes properly. Whether the spaces after the first word (and not only before the first word) should be skipped, that’s easy to adjust.

  1. #include &lt;iostream&gt;
  2. #include &lt;string&gt;
  4. namespace {
  5. const char* skip_first_word_c_style(const char* c_str) {
  6.   while (*c_str &amp;&amp; *c_str == &#39; &#39;) ++c_str;  // spaces before first word
  7.   while (*c_str &amp;&amp; *c_str != &#39; &#39;) ++c_str;  // first word
  8.   while (*c_str &amp;&amp; *c_str == &#39; &#39;) ++c_str;  // spaces after first word
  9.   return c_str;
  10. }
  11. }  // namespace
  13. int main() {
  14.   std::string line;
  15.   while (std::getline(std::cin, line)) {
  16.     std::cout &lt;&lt; skip_first_word_c_style(line.c_str()) &lt;&lt; std::endl;
  17.   }
  18. }

huangapple
  • 本文由 发表于 2023年4月13日 20:54:42
  • 转载请务必保留本文链接：https://go.coder-hub.com/76005690.html
  • arrays
  • c++
  • char
  • pointers
匿名

发表评论

匿名网友

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

确定