设为首页收藏本站
切换到窄版

鱼C论坛

 找回密码
 立即注册
鱼C论坛»论坛 › 编程语言专区 › C\C++交流 › C++小白求助
返回列表 发新帖
查看: 926|回复: 9

C++小白求助

[复制链接]
kkken
发表于 2021-11-20 17:33:52 From FishC Mobile | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能^_^

您需要 登录 才可以下载或查看，没有账号？立即注册

x
本帖最后由 kkken 于 2021-11-20 17:35 编辑

想输出等于的内容，而它们是在?/&之间，加号是空一格的意思。
eg
cin>>anb?ef=12+3&g=ab&sk=&hijk=12-A
cout:
[hijk] equals [12-A]
[sk ] equals [ ]
[g   ] equals [ab]
[ef  ] equals [12 3]

左边的[ ] 大小要一致。
只能用iostream 和cstring。

谢谢各位大神。
小甲鱼最新课程 -> https://ilovefishc.com
回复

使用道具 举报

人造人
发表于 2021-11-20 20:19:34 | 显示全部楼层
解析这个字符串不让用库函数就不好整，还要限定 只能用iostream 和cstring，就更不好整了

main.cpp
  1. #include "list.h"
  2. #include <iostream>
  3. #include <cstring>

  5. list_t *split(const char *str, char sep) {
  6.     list_t *res = list_init();
  7.     const char *begin = str;
  8.     for(size_t i = 0; ; ++i) {
  9.         if(*begin == '\0') break;
  10.         if(str[i] == '\0' || str[i] == sep) {
  11.             size_t size = &str[i] - begin;
  12.             char *temp = (char *)malloc(size + 1);
  13.             memcpy(temp, begin, size);
  14.             temp[size] = '\0';
  15.             list_append(res, temp, size + 1);
  16.             free(temp);
  17.             begin = str[i] != '\0' ? &str[i] + 1 : &str[i];
  18.         }
  19.     }
  20.     return res;
  21. }

  23. void split_equals(const list_t *list, list_t *left, list_t *raw_right) {
  24.     char buff[1024];
  25.     list_clean(left); list_clean(raw_right);
  26.     for(size_t i = 0; i < list_size(list); ++i) {
  27.         list_get(list, i, buff, 1024);
  28.         list_t *temp = split(buff, '=');
  29.         list_get(temp, 0, buff, 1024);
  30.         list_append(left, buff, strlen(buff) + 1);
  31.         if(list_size(temp) == 2) {
  32.             list_get(temp, 1, buff, 1024);
  33.             list_append(raw_right, buff, strlen(buff) + 1);
  34.         } else list_append(raw_right, " ", 2);
  35.         list_deinit(temp);
  36.     }
  37. }

  39. void output(const list_t *left, const list_t *raw_right) {
  40.     size_t count = 0;
  41.     char buff[1024];
  42.     for(size_t i = 0; i < list_size(left); ++i) {
  43.         list_get(left, i, buff, 1024);
  44.         size_t temp = strlen(buff);
  45.         count = count < temp ? temp : count;
  46.     }
  47.     for(size_t i = 0; i < list_size(left); ++i) {
  48.         list_get(left, i, buff, 1024);
  49.         std::cout << '[' << buff;
  50.         size_t space_count = count - strlen(buff);
  51.         for(size_t j = 0; j < space_count; ++j) std::cout << ' ';
  52.         std::cout << "] equals [";
  53.         list_get(raw_right, i, buff, 1024);
  54.         list_t *right = split(buff, '+');
  55.         const char *sep = "";
  56.         for(size_t j = 0; j < list_size(right); ++j) {
  57.             list_get(right, j, buff, 1024);
  58.             std::cout << sep << buff;
  59.             sep = " ";
  60.         }
  61.         list_deinit(right);
  62.         std::cout << ']' << std::endl;
  63.     }
  64. }

  66. int main(void) {
  67.     char buff[1024]; fgets(buff, 1024, stdin);
  68.     buff[strlen(buff) - 1] = '\0';
  69.     list_t *list = split(buff, '&');
  70.     list_get(list, 0, buff, 1024);
  71.     list_t *temp = split(buff, '?');
  72.     list_get(temp, 1, buff, 1024);
  73.     list_set(list, 0, buff, strlen(buff) + 1);  // 去掉?前面的内容
  74.     list_deinit(temp);
  75.     list_t *left = list_init();
  76.     list_t *raw_right = list_init();
  77.     split_equals(list, left, raw_right);
  78.     list_deinit(list);
  79.     output(left, raw_right);
  80.     list_deinit(raw_right);
  81.     list_deinit(left);
  82.     return 0;
  83. }
复制代码


list.h
  1. #ifndef _LIST_H_
  2. #define _LIST_H_

  4. #include <stddef.h>
  5. #include <stdbool.h>

  7. struct list_node_tag {
  8.     void *data; size_t size;
  9.     struct list_node_tag *next;
  10. };

  12. typedef struct {
  13.     struct list_node_tag *head;
  14.     size_t size;
  15. } list_t;

  17. list_t *list_init(void);
  18. void list_deinit(list_t *list);
  19. bool list_clean(list_t *list);
  20. bool list_insert(list_t *list, size_t index, const void *data, size_t size);
  21. bool list_delete(list_t *list, size_t index);
  22. bool list_get(const list_t *list, size_t index, void *data, size_t size);
  23. bool list_set(list_t *list, size_t index, const void *data, size_t size);
  24. bool list_append(list_t *list, const void *data, size_t size);
  25. size_t list_size(const list_t *list);
  26. bool list_empty(const list_t *list);

  28. #endif
复制代码


list.c
  1. #include "list.h"
  2. #include <stdlib.h>
  3. #include <memory.h>

  5. list_t *list_init(void) {
  6.     list_t *list = (list_t *)malloc(sizeof(*list));
  7.     if(!list) return NULL;
  8.     list->head = NULL;
  9.     list->size = 0;
  10.     return list;
  11. }

  13. void list_deinit(list_t *list) {
  14.     if(!list) return;
  15.     list_clean(list);
  16.     free(list);
  17. }

  19. bool list_clean(list_t *list) {
  20.     if(!list) return false;
  21.     while(!list_empty(list)) list_delete(list, 0);
  22.     return true;
  23. }

  25. bool list_insert(list_t *list, size_t index, const void *data, size_t size) {
  26.     if(!list) return false;
  27.     if(list_size(list) < index) return false;
  28.     if(!data) return false;
  29.     struct list_node_tag **current = &list->head;
  30.     while(index--) current = &(*current)->next;
  31.     struct list_node_tag *node = (struct list_node_tag *)malloc(sizeof(*node));
  32.     if(!node) return false;
  33.     node->data = malloc(size);
  34.     if(!node->data) {free(node); return false;}
  35.     memcpy(node->data, data, size);
  36.     node->size = size;
  37.     node->next = *current;
  38.     *current = node;
  39.     ++list->size;
  40.     return true;
  41. }

  43. bool list_delete(list_t *list, size_t index) {
  44.     if(!list) return false;
  45.     if(list_size(list) <= index) return false;
  46.     struct list_node_tag **current = &list->head;
  47.     while(index--) current = &(*current)->next;
  48.     struct list_node_tag *temp = *current;
  49.     *current = temp->next;
  50.     free(temp->data); free(temp);
  51.     --list->size;
  52.     return true;
  53. }

  55. bool list_get(const list_t *list, size_t index, void *data, size_t size) {
  56.     if(!list) return false;
  57.     if(list_size(list) <= index) return false;
  58.     if(!data) return false;
  59.     struct list_node_tag *const *current = &list->head;
  60.     while(index--) current = &(*current)->next;
  61.     struct list_node_tag *temp = *current;
  62.     if(temp->size > size) return false;
  63.     memcpy(data, temp->data, temp->size);
  64.     return true;
  65. }

  67. bool list_set(list_t *list, size_t index, const void *data, size_t size) {
  68.     bool res = list_delete(list, index);
  69.     return res ? list_insert(list, index, data, size) : res;
  70. }

  72. bool list_append(list_t *list, const void *data, size_t size) {
  73.     if(!list) return false;
  74.     return list_insert(list, list_size(list), data, size);
  75. }

  77. size_t list_size(const list_t *list) {
  78.     if(!list) return 0;
  79.     return list->size;
  80. }

  82. bool list_empty(const list_t *list) {
  83.     if(!list) return true;
  84.     return list_size(list) == 0;
  85. }
复制代码

  1. $ g++-debug -o main main.cpp list.c
  2. $ ./main
  3. anb?ef=12+3&g=ab&sk=&hijk=12-A
  4. [ef  ] equals [12 3]
  5. [g   ] equals [ab]
  6. [sk  ] equals [ ]
  7. [hijk] equals [12-A]
  8. $
复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

人造人
发表于 2021-11-20 20:24:10 | 显示全部楼层
你不让我用 vector，还不让我自己写一个了？
我本来是打算用 vector 存储中间数据的，但是题目不让用，而且最近刚好写了 list，用C语言写的，就拿过来用一下
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

人造人
发表于 2021-11-20 20:25:14 | 显示全部楼层
还有，最后必须是反序输出？
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

人造人
发表于 2021-11-20 20:29:12 | 显示全部楼层
只能用iostream 和cstring
那么，能不能这样？
  1. #include "list.h"
复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

人造人
发表于 2021-11-20 20:33:38 | 显示全部楼层
不能？
那这样呢？这次可是只有 iostream 和 cstring

  1. #include <iostream>
  2. #include <cstring>

  4. #ifndef _LIST_H_
  5. #define _LIST_H_

  7. struct list_node_tag {
  8.     void *data; size_t size;
  9.     struct list_node_tag *next;
  10. };

  12. typedef struct {
  13.     struct list_node_tag *head;
  14.     size_t size;
  15. } list_t;

  17. list_t *list_init(void);
  18. void list_deinit(list_t *list);
  19. bool list_clean(list_t *list);
  20. bool list_insert(list_t *list, size_t index, const void *data, size_t size);
  21. bool list_delete(list_t *list, size_t index);
  22. bool list_get(const list_t *list, size_t index, void *data, size_t size);
  23. bool list_set(list_t *list, size_t index, const void *data, size_t size);
  24. bool list_append(list_t *list, const void *data, size_t size);
  25. size_t list_size(const list_t *list);
  26. bool list_empty(const list_t *list);

  28. #endif

  30. list_t *list_init(void) {
  31.     list_t *list = (list_t *)malloc(sizeof(*list));
  32.     if(!list) return NULL;
  33.     list->head = NULL;
  34.     list->size = 0;
  35.     return list;
  36. }

  38. void list_deinit(list_t *list) {
  39.     if(!list) return;
  40.     list_clean(list);
  41.     free(list);
  42. }

  44. bool list_clean(list_t *list) {
  45.     if(!list) return false;
  46.     while(!list_empty(list)) list_delete(list, 0);
  47.     return true;
  48. }

  50. bool list_insert(list_t *list, size_t index, const void *data, size_t size) {
  51.     if(!list) return false;
  52.     if(list_size(list) < index) return false;
  53.     if(!data) return false;
  54.     struct list_node_tag **current = &list->head;
  55.     while(index--) current = &(*current)->next;
  56.     struct list_node_tag *node = (struct list_node_tag *)malloc(sizeof(*node));
  57.     if(!node) return false;
  58.     node->data = malloc(size);
  59.     if(!node->data) {free(node); return false;}
  60.     memcpy(node->data, data, size);
  61.     node->size = size;
  62.     node->next = *current;
  63.     *current = node;
  64.     ++list->size;
  65.     return true;
  66. }

  68. bool list_delete(list_t *list, size_t index) {
  69.     if(!list) return false;
  70.     if(list_size(list) <= index) return false;
  71.     struct list_node_tag **current = &list->head;
  72.     while(index--) current = &(*current)->next;
  73.     struct list_node_tag *temp = *current;
  74.     *current = temp->next;
  75.     free(temp->data); free(temp);
  76.     --list->size;
  77.     return true;
  78. }

  80. bool list_get(const list_t *list, size_t index, void *data, size_t size) {
  81.     if(!list) return false;
  82.     if(list_size(list) <= index) return false;
  83.     if(!data) return false;
  84.     struct list_node_tag *const *current = &list->head;
  85.     while(index--) current = &(*current)->next;
  86.     struct list_node_tag *temp = *current;
  87.     if(temp->size > size) return false;
  88.     memcpy(data, temp->data, temp->size);
  89.     return true;
  90. }

  92. bool list_set(list_t *list, size_t index, const void *data, size_t size) {
  93.     bool res = list_delete(list, index);
  94.     return res ? list_insert(list, index, data, size) : res;
  95. }

  97. bool list_append(list_t *list, const void *data, size_t size) {
  98.     if(!list) return false;
  99.     return list_insert(list, list_size(list), data, size);
  100. }

  102. size_t list_size(const list_t *list) {
  103.     if(!list) return 0;
  104.     return list->size;
  105. }

  107. bool list_empty(const list_t *list) {
  108.     if(!list) return true;
  109.     return list_size(list) == 0;
  110. }

  112. list_t *split(const char *str, char sep) {
  113.     list_t *res = list_init();
  114.     const char *begin = str;
  115.     for(size_t i = 0; ; ++i) {
  116.         if(*begin == '\0') break;
  117.         if(str[i] == '\0' || str[i] == sep) {
  118.             size_t size = &str[i] - begin;
  119.             char *temp = (char *)malloc(size + 1);
  120.             memcpy(temp, begin, size);
  121.             temp[size] = '\0';
  122.             list_append(res, temp, size + 1);
  123.             free(temp);
  124.             begin = str[i] != '\0' ? &str[i] + 1 : &str[i];
  125.         }
  126.     }
  127.     return res;
  128. }

  130. void split_equals(const list_t *list, list_t *left, list_t *raw_right) {
  131.     char buff[1024];
  132.     list_clean(left); list_clean(raw_right);
  133.     for(size_t i = 0; i < list_size(list); ++i) {
  134.         list_get(list, i, buff, 1024);
  135.         list_t *temp = split(buff, '=');
  136.         list_get(temp, 0, buff, 1024);
  137.         list_append(left, buff, strlen(buff) + 1);
  138.         if(list_size(temp) == 2) {
  139.             list_get(temp, 1, buff, 1024);
  140.             list_append(raw_right, buff, strlen(buff) + 1);
  141.         } else list_append(raw_right, " ", 2);
  142.         list_deinit(temp);
  143.     }
  144. }

  146. void output(const list_t *left, const list_t *raw_right) {
  147.     size_t count = 0;
  148.     char buff[1024];
  149.     for(size_t i = 0; i < list_size(left); ++i) {
  150.         list_get(left, i, buff, 1024);
  151.         size_t temp = strlen(buff);
  152.         count = count < temp ? temp : count;
  153.     }
  154.     for(size_t i = 0; i < list_size(left); ++i) {
  155.         list_get(left, i, buff, 1024);
  156.         std::cout << '[' << buff;
  157.         size_t space_count = count - strlen(buff);
  158.         for(size_t j = 0; j < space_count; ++j) std::cout << ' ';
  159.         std::cout << "] equals [";
  160.         list_get(raw_right, i, buff, 1024);
  161.         list_t *right = split(buff, '+');
  162.         const char *sep = "";
  163.         for(size_t j = 0; j < list_size(right); ++j) {
  164.             list_get(right, j, buff, 1024);
  165.             std::cout << sep << buff;
  166.             sep = " ";
  167.         }
  168.         list_deinit(right);
  169.         std::cout << ']' << std::endl;
  170.     }
  171. }

  173. int main(void) {
  174.     char buff[1024]; fgets(buff, 1024, stdin);
  175.     buff[strlen(buff) - 1] = '\0';
  176.     list_t *list = split(buff, '&');
  177.     list_get(list, 0, buff, 1024);
  178.     list_t *temp = split(buff, '?');
  179.     list_get(temp, 1, buff, 1024);
  180.     list_set(list, 0, buff, strlen(buff) + 1);  // 去掉?前面的内容
  181.     list_deinit(temp);
  182.     list_t *left = list_init();
  183.     list_t *raw_right = list_init();
  184.     split_equals(list, left, raw_right);
  185.     list_deinit(list);
  186.     output(left, raw_right);
  187.     list_deinit(raw_right);
  188.     list_deinit(left);
  189.     return 0;
  190. }
复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

人造人
发表于 2021-11-20 20:34:43 | 显示全部楼层
  1. $ g++-debug -o main main.cpp
  2. $ ./main
  3. anb?ef=12+3&g=ab&sk=&hijk=12-A
  4. [ef  ] equals [12 3]
  5. [g   ] equals [ab]
  6. [sk  ] equals [ ]
  7. [hijk] equals [12-A]
  8. $
复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

kkken
 楼主| 发表于 2021-11-23 16:45:45 From FishC Mobile | 显示全部楼层
人造人 发表于 2021-11-20 20:25
还有，最后必须是反序输出？

须反序输出
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

人造人
发表于 2021-11-23 17:00:09 | 显示全部楼层
kkken 发表于 2021-11-23 16:45
须反序输出

那你改一下代码不就好了
  1. #include "list.h"
  2. #include <iostream>
  3. #include <cstring>

  5. list_t *split(const char *str, char sep) {
  6.     list_t *res = list_init();
  7.     const char *begin = str;
  8.     for(size_t i = 0; ; ++i) {
  9.         if(*begin == '\0') break;
  10.         if(str[i] == '\0' || str[i] == sep) {
  11.             size_t size = &str[i] - begin;
  12.             char *temp = (char *)malloc(size + 1);
  13.             memcpy(temp, begin, size);
  14.             temp[size] = '\0';
  15.             list_append(res, temp, size + 1);
  16.             free(temp);
  17.             begin = str[i] != '\0' ? &str[i] + 1 : &str[i];
  18.         }
  19.     }
  20.     return res;
  21. }

  23. void split_equals(const list_t *list, list_t *left, list_t *raw_right) {
  24.     char buff[1024];
  25.     list_clean(left); list_clean(raw_right);
  26.     for(size_t i = 0; i < list_size(list); ++i) {
  27.         list_get(list, i, buff, 1024);
  28.         list_t *temp = split(buff, '=');
  29.         list_get(temp, 0, buff, 1024);
  30.         list_append(left, buff, strlen(buff) + 1);
  31.         if(list_size(temp) == 2) {
  32.             list_get(temp, 1, buff, 1024);
  33.             list_append(raw_right, buff, strlen(buff) + 1);
  34.         } else list_append(raw_right, " ", 2);
  35.         list_deinit(temp);
  36.     }
  37. }

  39. void output(const list_t *left, const list_t *raw_right) {
  40.     size_t count = 0;
  41.     char buff[1024];
  42.     for(size_t i = 0; i < list_size(left); ++i) {
  43.         list_get(left, i, buff, 1024);
  44.         size_t temp = strlen(buff);
  45.         count = count < temp ? temp : count;
  46.     }
  47.     //for(size_t i = 0; i < list_size(left); ++i) {
  48.     for(size_t i = list_size(left) - 1; i != (size_t)-1; --i) {
  49.         list_get(left, i, buff, 1024);
  50.         std::cout << '[' << buff;
  51.         size_t space_count = count - strlen(buff);
  52.         for(size_t j = 0; j < space_count; ++j) std::cout << ' ';
  53.         std::cout << "] equals [";
  54.         list_get(raw_right, i, buff, 1024);
  55.         list_t *right = split(buff, '+');
  56.         const char *sep = "";
  57.         for(size_t j = 0; j < list_size(right); ++j) {
  58.             list_get(right, j, buff, 1024);
  59.             std::cout << sep << buff;
  60.             sep = " ";
  61.         }
  62.         list_deinit(right);
  63.         std::cout << ']' << std::endl;
  64.     }
  65. }

  67. int main(void) {
  68.     char buff[1024]; fgets(buff, 1024, stdin);
  69.     buff[strlen(buff) - 1] = '\0';
  70.     list_t *list = split(buff, '&');
  71.     list_get(list, 0, buff, 1024);
  72.     list_t *temp = split(buff, '?');
  73.     list_get(temp, 1, buff, 1024);
  74.     list_set(list, 0, buff, strlen(buff) + 1);  // 去掉?前面的内容
  75.     list_deinit(temp);
  76.     list_t *left = list_init();
  77.     list_t *raw_right = list_init();
  78.     split_equals(list, left, raw_right);
  79.     list_deinit(list);
  80.     output(left, raw_right);
  81.     list_deinit(raw_right);
  82.     list_deinit(left);
  83.     return 0;
  84. }
复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

18408238295
发表于 2021-11-23 20:15:23 | 显示全部楼层
小甲鱼最新课程 -> https://ilovefishc.com
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备18085999号-1 | 粤公网安备 44051102000585号)

GMT+8, 2025-4-25 16:13

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表