需要帮助清理C代码中的内存泄漏并解决分段错误问题,使用malloc和free。

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

Need help cleaning memory leaks and resolving segmentation fault in C code using malloc and free

问题

  1. 我一直在使用C语言编写这段代码,但是它有很多内存泄漏问题,我不知道如何清理。
  2. 当我在主函数中调用get_next_line时,我希望它能返回.txt文件的下一行内容。
  3. 有人可以帮助我吗?
  4. 我已经做了几次更改,但始终出现内存泄漏和分段错误。
  5. 我期望的只是读取文件。
英文:

I've been working on this code in C and it has lots of leaks that I don´t know how to clean.

What I want when I call get_next_line on main is for it to return the next line of a .txt file.

Can somebody help me pls?

  1. size_t ft_strlen(char *s)
  2. {
  3. size_t i;
  4. if (!s)
  5. return (0);
  6. i = 0;
  7. while (s[i] != '
  8. size_t	ft_strlen(char *s)
  9. {
  10. size_t	i;
  11. if (!s)
  12. return (0);
  13. i = 0;
  14. while (s[i] != '\0')
  15. i++;
  16. return (i);
  17. }
  18. char	*ft_strchr(char *s, int c)
  19. {
  20. size_t	i;
  21. i = 0;
  22. if (!s)
  23. return (0);
  24. while ((s[i] != '\0') && (s[i] != (unsigned char)c))
  25. i++;
  26. if ((s[i] == (unsigned char)c) || (c == '\0'))
  27. return ((char *)&s[i]);
  28. return (0);
  29. }
  30. char	*ft_substr(char *s, unsigned int start, size_t len)
  31. {
  32. size_t	i;
  33. size_t	j;
  34. char	*sub;
  35. i = 0;
  36. j = 0;
  37. if (start >= ft_strlen(s) || !s || !len)
  38. {
  39. sub = malloc(1 * sizeof(char));
  40. sub[0] = '\0';
  41. return (sub);
  42. }
  43. while (s[start + j] != '\0' && j < len)
  44. j++;
  45. if (s[start + j] != '\0')
  46. j++;
  47. sub = malloc((j + 1) * sizeof(char));
  48. if (!sub)
  49. {
  50. free(s);
  51. return (0);	
  52. }
  53. while (s[start] != '\0' && j > i)
  54. sub[i++] = s[start++];
  55. sub[i] = '\0';
  56. //free(s);
  57. return (sub);
  58. }
  59. char	*ft_strjoin(char *s1, char *s2)
  60. {
  61. char	*cat;
  62. size_t	i;
  63. size_t	j;
  64. i = 0;
  65. j = 0;
  66. if (!s1)
  67. {
  68. s1 = malloc(sizeof(char) * 1);
  69. s1[0] = '\0';
  70. }
  71. cat = (char *)malloc((ft_strlen(s1) + ft_strlen(s2) + 1) * sizeof(char));
  72. if (!cat)
  73. return (NULL);
  74. while (s1[i] != '\0')
  75. {
  76. cat[i] = s1[i];
  77. i++;
  78. }
  79. while (s2[j] != '\0')
  80. cat[i++] = s2[j++];
  81. free(s1);
  82. cat[i] = '\0';
  83. return (cat);
  84. }
  85. char	*ft_content(int fd, char *content)
  86. {
  87. char	*buf;
  88. int		buf_nb;
  89. buf_nb = 1;
  90. buf = (char *)malloc((BUFFER_SIZE + 1) * sizeof(char));
  91. if (!buf)
  92. return (0);
  93. while ((!ft_strchr(content, '\n')) && buf_nb != 0)
  94. {
  95. buf_nb = read(fd, buf, BUFFER_SIZE);
  96. if (buf_nb == -1)
  97. {
  98. free(buf);
  99. free(content);
  100. return (NULL);
  101. }
  102. buf[buf_nb] = '\0';
  103. content = ft_strjoin(content, buf);
  104. }
  105. free(buf);
  106. return (content);
  107. }
  108. char	*get_next_line(int fd)
  109. {
  110. static char	*content;
  111. char		*sub;
  112. int			i;
  113. int			len;
  114. i = 0;
  115. if (fd < 0 || BUFFER_SIZE <= 0)
  116. return (NULL);
  117. content = ft_content(fd, content);
  118. if (content == NULL)
  119. return (NULL);
  120. if (content[0] == '\0')
  121. return (NULL);
  122. while (content[i] != '\n' && content[i] != '\0')
  123. i++;
  124. sub = ft_substr(content, 0, i);
  125. len = ft_strlen(content);
  126. i++;
  127. content = ft_substr(content, i, len);
  128. return (sub);
  129. }
  130. int    main(void)
  131. {
  132. int    a = open("exemplo.txt", O_RDONLY);
  133. printf("%s", get_next_line(a));
  134. printf("%s", get_next_line(a));
  135. printf("%s", get_next_line(a));
  136. printf("%s", get_next_line(a));
  137. return (0);
  138. }
  139. ')
  140. i++;
  141. return (i);
  142. }
  143. char *ft_strchr(char *s, int c)
  144. {
  145. size_t i;
  146. i = 0;
  147. if (!s)
  148. return (0);
  149. while ((s[i] != '
  150. size_t	ft_strlen(char *s)
  151. {
  152. size_t	i;
  153. if (!s)
  154. return (0);
  155. i = 0;
  156. while (s[i] != '\0')
  157. i++;
  158. return (i);
  159. }
  160. char	*ft_strchr(char *s, int c)
  161. {
  162. size_t	i;
  163. i = 0;
  164. if (!s)
  165. return (0);
  166. while ((s[i] != '\0') && (s[i] != (unsigned char)c))
  167. i++;
  168. if ((s[i] == (unsigned char)c) || (c == '\0'))
  169. return ((char *)&s[i]);
  170. return (0);
  171. }
  172. char	*ft_substr(char *s, unsigned int start, size_t len)
  173. {
  174. size_t	i;
  175. size_t	j;
  176. char	*sub;
  177. i = 0;
  178. j = 0;
  179. if (start >= ft_strlen(s) || !s || !len)
  180. {
  181. sub = malloc(1 * sizeof(char));
  182. sub[0] = '\0';
  183. return (sub);
  184. }
  185. while (s[start + j] != '\0' && j < len)
  186. j++;
  187. if (s[start + j] != '\0')
  188. j++;
  189. sub = malloc((j + 1) * sizeof(char));
  190. if (!sub)
  191. {
  192. free(s);
  193. return (0);	
  194. }
  195. while (s[start] != '\0' && j > i)
  196. sub[i++] = s[start++];
  197. sub[i] = '\0';
  198. //free(s);
  199. return (sub);
  200. }
  201. char	*ft_strjoin(char *s1, char *s2)
  202. {
  203. char	*cat;
  204. size_t	i;
  205. size_t	j;
  206. i = 0;
  207. j = 0;
  208. if (!s1)
  209. {
  210. s1 = malloc(sizeof(char) * 1);
  211. s1[0] = '\0';
  212. }
  213. cat = (char *)malloc((ft_strlen(s1) + ft_strlen(s2) + 1) * sizeof(char));
  214. if (!cat)
  215. return (NULL);
  216. while (s1[i] != '\0')
  217. {
  218. cat[i] = s1[i];
  219. i++;
  220. }
  221. while (s2[j] != '\0')
  222. cat[i++] = s2[j++];
  223. free(s1);
  224. cat[i] = '\0';
  225. return (cat);
  226. }
  227. char	*ft_content(int fd, char *content)
  228. {
  229. char	*buf;
  230. int		buf_nb;
  231. buf_nb = 1;
  232. buf = (char *)malloc((BUFFER_SIZE + 1) * sizeof(char));
  233. if (!buf)
  234. return (0);
  235. while ((!ft_strchr(content, '\n')) && buf_nb != 0)
  236. {
  237. buf_nb = read(fd, buf, BUFFER_SIZE);
  238. if (buf_nb == -1)
  239. {
  240. free(buf);
  241. free(content);
  242. return (NULL);
  243. }
  244. buf[buf_nb] = '\0';
  245. content = ft_strjoin(content, buf);
  246. }
  247. free(buf);
  248. return (content);
  249. }
  250. char	*get_next_line(int fd)
  251. {
  252. static char	*content;
  253. char		*sub;
  254. int			i;
  255. int			len;
  256. i = 0;
  257. if (fd < 0 || BUFFER_SIZE <= 0)
  258. return (NULL);
  259. content = ft_content(fd, content);
  260. if (content == NULL)
  261. return (NULL);
  262. if (content[0] == '\0')
  263. return (NULL);
  264. while (content[i] != '\n' && content[i] != '\0')
  265. i++;
  266. sub = ft_substr(content, 0, i);
  267. len = ft_strlen(content);
  268. i++;
  269. content = ft_substr(content, i, len);
  270. return (sub);
  271. }
  272. int    main(void)
  273. {
  274. int    a = open("exemplo.txt", O_RDONLY);
  275. printf("%s", get_next_line(a));
  276. printf("%s", get_next_line(a));
  277. printf("%s", get_next_line(a));
  278. printf("%s", get_next_line(a));
  279. return (0);
  280. }
  281. ') && (s[i] != (unsigned char)c))
  282. i++;
  283. if ((s[i] == (unsigned char)c) || (c == '
  284. size_t	ft_strlen(char *s)
  285. {
  286. size_t	i;
  287. if (!s)
  288. return (0);
  289. i = 0;
  290. while (s[i] != '\0')
  291. i++;
  292. return (i);
  293. }
  294. char	*ft_strchr(char *s, int c)
  295. {
  296. size_t	i;
  297. i = 0;
  298. if (!s)
  299. return (0);
  300. while ((s[i] != '\0') && (s[i] != (unsigned char)c))
  301. i++;
  302. if ((s[i] == (unsigned char)c) || (c == '\0'))
  303. return ((char *)&s[i]);
  304. return (0);
  305. }
  306. char	*ft_substr(char *s, unsigned int start, size_t len)
  307. {
  308. size_t	i;
  309. size_t	j;
  310. char	*sub;
  311. i = 0;
  312. j = 0;
  313. if (start >= ft_strlen(s) || !s || !len)
  314. {
  315. sub = malloc(1 * sizeof(char));
  316. sub[0] = '\0';
  317. return (sub);
  318. }
  319. while (s[start + j] != '\0' && j < len)
  320. j++;
  321. if (s[start + j] != '\0')
  322. j++;
  323. sub = malloc((j + 1) * sizeof(char));
  324. if (!sub)
  325. {
  326. free(s);
  327. return (0);	
  328. }
  329. while (s[start] != '\0' && j > i)
  330. sub[i++] = s[start++];
  331. sub[i] = '\0';
  332. //free(s);
  333. return (sub);
  334. }
  335. char	*ft_strjoin(char *s1, char *s2)
  336. {
  337. char	*cat;
  338. size_t	i;
  339. size_t	j;
  340. i = 0;
  341. j = 0;
  342. if (!s1)
  343. {
  344. s1 = malloc(sizeof(char) * 1);
  345. s1[0] = '\0';
  346. }
  347. cat = (char *)malloc((ft_strlen(s1) + ft_strlen(s2) + 1) * sizeof(char));
  348. if (!cat)
  349. return (NULL);
  350. while (s1[i] != '\0')
  351. {
  352. cat[i] = s1[i];
  353. i++;
  354. }
  355. while (s2[j] != '\0')
  356. cat[i++] = s2[j++];
  357. free(s1);
  358. cat[i] = '\0';
  359. return (cat);
  360. }
  361. char	*ft_content(int fd, char *content)
  362. {
  363. char	*buf;
  364. int		buf_nb;
  365. buf_nb = 1;
  366. buf = (char *)malloc((BUFFER_SIZE + 1) * sizeof(char));
  367. if (!buf)
  368. return (0);
  369. while ((!ft_strchr(content, '\n')) && buf_nb != 0)
  370. {
  371. buf_nb = read(fd, buf, BUFFER_SIZE);
  372. if (buf_nb == -1)
  373. {
  374. free(buf);
  375. free(content);
  376. return (NULL);
  377. }
  378. buf[buf_nb] = '\0';
  379. content = ft_strjoin(content, buf);
  380. }
  381. free(buf);
  382. return (content);
  383. }
  384. char	*get_next_line(int fd)
  385. {
  386. static char	*content;
  387. char		*sub;
  388. int			i;
  389. int			len;
  390. i = 0;
  391. if (fd < 0 || BUFFER_SIZE <= 0)
  392. return (NULL);
  393. content = ft_content(fd, content);
  394. if (content == NULL)
  395. return (NULL);
  396. if (content[0] == '\0')
  397. return (NULL);
  398. while (content[i] != '\n' && content[i] != '\0')
  399. i++;
  400. sub = ft_substr(content, 0, i);
  401. len = ft_strlen(content);
  402. i++;
  403. content = ft_substr(content, i, len);
  404. return (sub);
  405. }
  406. int    main(void)
  407. {
  408. int    a = open("exemplo.txt", O_RDONLY);
  409. printf("%s", get_next_line(a));
  410. printf("%s", get_next_line(a));
  411. printf("%s", get_next_line(a));
  412. printf("%s", get_next_line(a));
  413. return (0);
  414. }
  415. '))
  416. return ((char *)&s[i]);
  417. return (0);
  418. }
  419. char *ft_substr(char *s, unsigned int start, size_t len)
  420. {
  421. size_t i;
  422. size_t j;
  423. char *sub;
  424. i = 0;
  425. j = 0;
  426. if (start >= ft_strlen(s) || !s || !len)
  427. {
  428. sub = malloc(1 * sizeof(char));
  429. sub[0] = '
  430. size_t	ft_strlen(char *s)
  431. {
  432. size_t	i;
  433. if (!s)
  434. return (0);
  435. i = 0;
  436. while (s[i] != '\0')
  437. i++;
  438. return (i);
  439. }
  440. char	*ft_strchr(char *s, int c)
  441. {
  442. size_t	i;
  443. i = 0;
  444. if (!s)
  445. return (0);
  446. while ((s[i] != '\0') && (s[i] != (unsigned char)c))
  447. i++;
  448. if ((s[i] == (unsigned char)c) || (c == '\0'))
  449. return ((char *)&s[i]);
  450. return (0);
  451. }
  452. char	*ft_substr(char *s, unsigned int start, size_t len)
  453. {
  454. size_t	i;
  455. size_t	j;
  456. char	*sub;
  457. i = 0;
  458. j = 0;
  459. if (start >= ft_strlen(s) || !s || !len)
  460. {
  461. sub = malloc(1 * sizeof(char));
  462. sub[0] = '\0';
  463. return (sub);
  464. }
  465. while (s[start + j] != '\0' && j < len)
  466. j++;
  467. if (s[start + j] != '\0')
  468. j++;
  469. sub = malloc((j + 1) * sizeof(char));
  470. if (!sub)
  471. {
  472. free(s);
  473. return (0);	
  474. }
  475. while (s[start] != '\0' && j > i)
  476. sub[i++] = s[start++];
  477. sub[i] = '\0';
  478. //free(s);
  479. return (sub);
  480. }
  481. char	*ft_strjoin(char *s1, char *s2)
  482. {
  483. char	*cat;
  484. size_t	i;
  485. size_t	j;
  486. i = 0;
  487. j = 0;
  488. if (!s1)
  489. {
  490. s1 = malloc(sizeof(char) * 1);
  491. s1[0] = '\0';
  492. }
  493. cat = (char *)malloc((ft_strlen(s1) + ft_strlen(s2) + 1) * sizeof(char));
  494. if (!cat)
  495. return (NULL);
  496. while (s1[i] != '\0')
  497. {
  498. cat[i] = s1[i];
  499. i++;
  500. }
  501. while (s2[j] != '\0')
  502. cat[i++] = s2[j++];
  503. free(s1);
  504. cat[i] = '\0';
  505. return (cat);
  506. }
  507. char	*ft_content(int fd, char *content)
  508. {
  509. char	*buf;
  510. int		buf_nb;
  511. buf_nb = 1;
  512. buf = (char *)malloc((BUFFER_SIZE + 1) * sizeof(char));
  513. if (!buf)
  514. return (0);
  515. while ((!ft_strchr(content, '\n')) && buf_nb != 0)
  516. {
  517. buf_nb = read(fd, buf, BUFFER_SIZE);
  518. if (buf_nb == -1)
  519. {
  520. free(buf);
  521. free(content);
  522. return (NULL);
  523. }
  524. buf[buf_nb] = '\0';
  525. content = ft_strjoin(content, buf);
  526. }
  527. free(buf);
  528. return (content);
  529. }
  530. char	*get_next_line(int fd)
  531. {
  532. static char	*content;
  533. char		*sub;
  534. int			i;
  535. int			len;
  536. i = 0;
  537. if (fd < 0 || BUFFER_SIZE <= 0)
  538. return (NULL);
  539. content = ft_content(fd, content);
  540. if (content == NULL)
  541. return (NULL);
  542. if (content[0] == '\0')
  543. return (NULL);
  544. while (content[i] != '\n' && content[i] != '\0')
  545. i++;
  546. sub = ft_substr(content, 0, i);
  547. len = ft_strlen(content);
  548. i++;
  549. content = ft_substr(content, i, len);
  550. return (sub);
  551. }
  552. int    main(void)
  553. {
  554. int    a = open("exemplo.txt", O_RDONLY);
  555. printf("%s", get_next_line(a));
  556. printf("%s", get_next_line(a));
  557. printf("%s", get_next_line(a));
  558. printf("%s", get_next_line(a));
  559. return (0);
  560. }
  561. ';
  562. return (sub);
  563. }
  564. while (s[start + j] != '
  565. size_t	ft_strlen(char *s)
  566. {
  567. size_t	i;
  568. if (!s)
  569. return (0);
  570. i = 0;
  571. while (s[i] != '\0')
  572. i++;
  573. return (i);
  574. }
  575. char	*ft_strchr(char *s, int c)
  576. {
  577. size_t	i;
  578. i = 0;
  579. if (!s)
  580. return (0);
  581. while ((s[i] != '\0') && (s[i] != (unsigned char)c))
  582. i++;
  583. if ((s[i] == (unsigned char)c) || (c == '\0'))
  584. return ((char *)&s[i]);
  585. return (0);
  586. }
  587. char	*ft_substr(char *s, unsigned int start, size_t len)
  588. {
  589. size_t	i;
  590. size_t	j;
  591. char	*sub;
  592. i = 0;
  593. j = 0;
  594. if (start >= ft_strlen(s) || !s || !len)
  595. {
  596. sub = malloc(1 * sizeof(char));
  597. sub[0] = '\0';
  598. return (sub);
  599. }
  600. while (s[start + j] != '\0' && j < len)
  601. j++;
  602. if (s[start + j] != '\0')
  603. j++;
  604. sub = malloc((j + 1) * sizeof(char));
  605. if (!sub)
  606. {
  607. free(s);
  608. return (0);	
  609. }
  610. while (s[start] != '\0' && j > i)
  611. sub[i++] = s[start++];
  612. sub[i] = '\0';
  613. //free(s);
  614. return (sub);
  615. }
  616. char	*ft_strjoin(char *s1, char *s2)
  617. {
  618. char	*cat;
  619. size_t	i;
  620. size_t	j;
  621. i = 0;
  622. j = 0;
  623. if (!s1)
  624. {
  625. s1 = malloc(sizeof(char) * 1);
  626. s1[0] = '\0';
  627. }
  628. cat = (char *)malloc((ft_strlen(s1) + ft_strlen(s2) + 1) * sizeof(char));
  629. if (!cat)
  630. return (NULL);
  631. while (s1[i] != '\0')
  632. {
  633. cat[i] = s1[i];
  634. i++;
  635. }
  636. while (s2[j] != '\0')
  637. cat[i++] = s2[j++];
  638. free(s1);
  639. cat[i] = '\0';
  640. return (cat);
  641. }
  642. char	*ft_content(int fd, char *content)
  643. {
  644. char	*buf;
  645. int		buf_nb;
  646. buf_nb = 1;
  647. buf = (char *)malloc((BUFFER_SIZE + 1) * sizeof(char));
  648. if (!buf)
  649. return (0);
  650. while ((!ft_strchr(content, '\n')) && buf_nb != 0)
  651. {
  652. buf_nb = read(fd, buf, BUFFER_SIZE);
  653. if (buf_nb == -1)
  654. {
  655. free(buf);
  656. free(content);
  657. return (NULL);
  658. }
  659. buf[buf_nb] = '\0';
  660. content = ft_strjoin(content, buf);
  661. }
  662. free(buf);
  663. return (content);
  664. }
  665. char	*get_next_line(int fd)
  666. {
  667. static char	*content;
  668. char		*sub;
  669. int			i;
  670. int			len;
  671. i = 0;
  672. if (fd < 0 || BUFFER_SIZE <= 0)
  673. return (NULL);
  674. content = ft_content(fd, content);
  675. if (content == NULL)
  676. return (NULL);
  677. if (content[0] == '\0')
  678. return (NULL);
  679. while (content[i] != '\n' && content[i] != '\0')
  680. i++;
  681. sub = ft_substr(content, 0, i);
  682. len = ft_strlen(content);
  683. i++;
  684. content = ft_substr(content, i, len);
  685. return (sub);
  686. }
  687. int    main(void)
  688. {
  689. int    a = open("exemplo.txt", O_RDONLY);
  690. printf("%s", get_next_line(a));
  691. printf("%s", get_next_line(a));
  692. printf("%s", get_next_line(a));
  693. printf("%s", get_next_line(a));
  694. return (0);
  695. }
  696. ' && j < len)
  697. j++;
  698. if (s[start + j] != '
  699. size_t	ft_strlen(char *s)
  700. {
  701. size_t	i;
  702. if (!s)
  703. return (0);
  704. i = 0;
  705. while (s[i] != '\0')
  706. i++;
  707. return (i);
  708. }
  709. char	*ft_strchr(char *s, int c)
  710. {
  711. size_t	i;
  712. i = 0;
  713. if (!s)
  714. return (0);
  715. while ((s[i] != '\0') && (s[i] != (unsigned char)c))
  716. i++;
  717. if ((s[i] == (unsigned char)c) || (c == '\0'))
  718. return ((char *)&s[i]);
  719. return (0);
  720. }
  721. char	*ft_substr(char *s, unsigned int start, size_t len)
  722. {
  723. size_t	i;
  724. size_t	j;
  725. char	*sub;
  726. i = 0;
  727. j = 0;
  728. if (start >= ft_strlen(s) || !s || !len)
  729. {
  730. sub = malloc(1 * sizeof(char));
  731. sub[0] = '\0';
  732. return (sub);
  733. }
  734. while (s[start + j] != '\0' && j < len)
  735. j++;
  736. if (s[start + j] != '\0')
  737. j++;
  738. sub = malloc((j + 1) * sizeof(char));
  739. if (!sub)
  740. {
  741. free(s);
  742. return (0);	
  743. }
  744. while (s[start] != '\0' && j > i)
  745. sub[i++] = s[start++];
  746. sub[i] = '\0';
  747. //free(s);
  748. return (sub);
  749. }
  750. char	*ft_strjoin(char *s1, char *s2)
  751. {
  752. char	*cat;
  753. size_t	i;
  754. size_t	j;
  755. i = 0;
  756. j = 0;
  757. if (!s1)
  758. {
  759. s1 = malloc(sizeof(char) * 1);
  760. s1[0] = '\0';
  761. }
  762. cat = (char *)malloc((ft_strlen(s1) + ft_strlen(s2) + 1) * sizeof(char));
  763. if (!cat)
  764. return (NULL);
  765. while (s1[i] != '\0')
  766. {
  767. cat[i] = s1[i];
  768. i++;
  769. }
  770. while (s2[j] != '\0')
  771. cat[i++] = s2[j++];
  772. free(s1);
  773. cat[i] = '\0';
  774. return (cat);
  775. }
  776. char	*ft_content(int fd, char *content)
  777. {
  778. char	*buf;
  779. int		buf_nb;
  780. buf_nb = 1;
  781. buf = (char *)malloc((BUFFER_SIZE + 1) * sizeof(char));
  782. if (!buf)
  783. return (0);
  784. while ((!ft_strchr(content, '\n')) && buf_nb != 0)
  785. {
  786. buf_nb = read(fd, buf, BUFFER_SIZE);
  787. if (buf_nb == -1)
  788. {
  789. free(buf);
  790. free(content);
  791. return (NULL);
  792. }
  793. buf[buf_nb] = '\0';
  794. content = ft_strjoin(content, buf);
  795. }
  796. free(buf);
  797. return (content);
  798. }
  799. char	*get_next_line(int fd)
  800. {
  801. static char	*content;
  802. char		*sub;
  803. int			i;
  804. int			len;
  805. i = 0;
  806. if (fd < 0 || BUFFER_SIZE <= 0)
  807. return (NULL);
  808. content = ft_content(fd, content);
  809. if (content == NULL)
  810. return (NULL);
  811. if (content[0] == '\0')
  812. return (NULL);
  813. while (content[i] != '\n' && content[i] != '\0')
  814. i++;
  815. sub = ft_substr(content, 0, i);
  816. len = ft_strlen(content);
  817. i++;
  818. content = ft_substr(content, i, len);
  819. return (sub);
  820. }
  821. int    main(void)
  822. {
  823. int    a = open("exemplo.txt", O_RDONLY);
  824. printf("%s", get_next_line(a));
  825. printf("%s", get_next_line(a));
  826. printf("%s", get_next_line(a));
  827. printf("%s", get_next_line(a));
  828. return (0);
  829. }
  830. ')
  831. j++;
  832. sub = malloc((j + 1) * sizeof(char));
  833. if (!sub)
  834. {
  835. free(s);
  836. return (0);
  837. }
  838. while (s[start] != '
  839. size_t	ft_strlen(char *s)
  840. {
  841. size_t	i;
  842. if (!s)
  843. return (0);
  844. i = 0;
  845. while (s[i] != '\0')
  846. i++;
  847. return (i);
  848. }
  849. char	*ft_strchr(char *s, int c)
  850. {
  851. size_t	i;
  852. i = 0;
  853. if (!s)
  854. return (0);
  855. while ((s[i] != '\0') && (s[i] != (unsigned char)c))
  856. i++;
  857. if ((s[i] == (unsigned char)c) || (c == '\0'))
  858. return ((char *)&s[i]);
  859. return (0);
  860. }
  861. char	*ft_substr(char *s, unsigned int start, size_t len)
  862. {
  863. size_t	i;
  864. size_t	j;
  865. char	*sub;
  866. i = 0;
  867. j = 0;
  868. if (start >= ft_strlen(s) || !s || !len)
  869. {
  870. sub = malloc(1 * sizeof(char));
  871. sub[0] = '\0';
  872. return (sub);
  873. }
  874. while (s[start + j] != '\0' && j < len)
  875. j++;
  876. if (s[start + j] != '\0')
  877. j++;
  878. sub = malloc((j + 1) * sizeof(char));
  879. if (!sub)
  880. {
  881. free(s);
  882. return (0);	
  883. }
  884. while (s[start] != '\0' && j > i)
  885. sub[i++] = s[start++];
  886. sub[i] = '\0';
  887. //free(s);
  888. return (sub);
  889. }
  890. char	*ft_strjoin(char *s1, char *s2)
  891. {
  892. char	*cat;
  893. size_t	i;
  894. size_t	j;
  895. i = 0;
  896. j = 0;
  897. if (!s1)
  898. {
  899. s1 = malloc(sizeof(char) * 1);
  900. s1[0] = '\0';
  901. }
  902. cat = (char *)malloc((ft_strlen(s1) + ft_strlen(s2) + 1) * sizeof(char));
  903. if (!cat)
  904. return (NULL);
  905. while (s1[i] != '\0')
  906. {
  907. cat[i] = s1[i];
  908. i++;
  909. }
  910. while (s2[j] != '\0')
  911. cat[i++] = s2[j++];
  912. free(s1);
  913. cat[i] = '\0';
  914. return (cat);
  915. }
  916. char	*ft_content(int fd, char *content)
  917. {
  918. char	*buf;
  919. int		buf_nb;
  920. buf_nb = 1;
  921. buf = (char *)malloc((BUFFER_SIZE + 1) * sizeof(char));
  922. if (!buf)
  923. return (0);
  924. while ((!ft_strchr(content, '\n')) && buf_nb != 0)
  925. {
  926. buf_nb = read(fd, buf, BUFFER_SIZE);
  927. if (buf_nb == -1)
  928. {
  929. free(buf);
  930. free(content);
  931. return (NULL);
  932. }
  933. buf[buf_nb] = '\0';
  934. content = ft_strjoin(content, buf);
  935. }
  936. free(buf);
  937. return (content);
  938. }
  939. char	*get_next_line(int fd)
  940. {
  941. static char	*content;
  942. char		*sub;
  943. int			i;
  944. int			len;
  945. i = 0;
  946. if (fd < 0 || BUFFER_SIZE <= 0)
  947. return (NULL);
  948. content = ft_content(fd, content);
  949. if (content == NULL)
  950. return (NULL);
  951. if (content[0] == '\0')
  952. return (NULL);
  953. while (content[i] != '\n' && content[i] != '\0')
  954. i++;
  955. sub = ft_substr(content, 0, i);
  956. len = ft_strlen(content);
  957. i++;
  958. content = ft_substr(content, i, len);
  959. return (sub);
  960. }
  961. int    main(void)
  962. {
  963. int    a = open("exemplo.txt", O_RDONLY);
  964. printf("%s", get_next_line(a));
  965. printf("%s", get_next_line(a));
  966. printf("%s", get_next_line(a));
  967. printf("%s", get_next_line(a));
  968. return (0);
  969. }
  970. ' && j > i)
  971. sub[i++] = s[start++];
  972. sub[i] = '
  973. size_t	ft_strlen(char *s)
  974. {
  975. size_t	i;
  976. if (!s)
  977. return (0);
  978. i = 0;
  979. while (s[i] != '\0')
  980. i++;
  981. return (i);
  982. }
  983. char	*ft_strchr(char *s, int c)
  984. {
  985. size_t	i;
  986. i = 0;
  987. if (!s)
  988. return (0);
  989. while ((s[i] != '\0') && (s[i] != (unsigned char)c))
  990. i++;
  991. if ((s[i] == (unsigned char)c) || (c == '\0'))
  992. return ((char *)&s[i]);
  993. return (0);
  994. }
  995. char	*ft_substr(char *s, unsigned int start, size_t len)
  996. {
  997. size_t	i;
  998. size_t	j;
  999. char	*sub;
  1000. i = 0;
  1001. j = 0;
  1002. if (start >= ft_strlen(s) || !s || !len)
  1003. {
  1004. sub = malloc(1 * sizeof(char));
  1005. sub[0] = '\0';
  1006. return (sub);
  1007. }
  1008. while (s[start + j] != '\0' && j < len)
  1009. j++;
  1010. if (s[start + j] != '\0')
  1011. j++;
  1012. sub = malloc((j + 1) * sizeof(char));
  1013. if (!sub)
  1014. {
  1015. free(s);
  1016. return (0);	
  1017. }
  1018. while (s[start] != '\0' && j > i)
  1019. sub[i++] = s[start++];
  1020. sub[i] = '\0';
  1021. //free(s);
  1022. return (sub);
  1023. }
  1024. char	*ft_strjoin(char *s1, char *s2)
  1025. {
  1026. char	*cat;
  1027. size_t	i;
  1028. size_t	j;
  1029. i = 0;
  1030. j = 0;
  1031. if (!s1)
  1032. {
  1033. s1 = malloc(sizeof(char) * 1);
  1034. s1[0] = '\0';
  1035. }
  1036. cat = (char *)malloc((ft_strlen(s1) + ft_strlen(s2) + 1) * sizeof(char));
  1037. if (!cat)
  1038. return (NULL);
  1039. while (s1[i] != '\0')
  1040. {
  1041. cat[i] = s1[i];
  1042. i++;
  1043. }
  1044. while (s2[j] != '\0')
  1045. cat[i++] = s2[j++];
  1046. free(s1);
  1047. cat[i] = '\0';
  1048. return (cat);
  1049. }
  1050. char	*ft_content(int fd, char *content)
  1051. {
  1052. char	*buf;
  1053. int		buf_nb;
  1054. buf_nb = 1;
  1055. buf = (char *)malloc((BUFFER_SIZE + 1) * sizeof(char));
  1056. if (!buf)
  1057. return (0);
  1058. while ((!ft_strchr(content, '\n')) && buf_nb != 0)
  1059. {
  1060. buf_nb = read(fd, buf, BUFFER_SIZE);
  1061. if (buf_nb == -1)
  1062. {
  1063. free(buf);
  1064. free(content);
  1065. return (NULL);
  1066. }
  1067. buf[buf_nb] = '\0';
  1068. content = ft_strjoin(content, buf);
  1069. }
  1070. free(buf);
  1071. return (content);
  1072. }
  1073. char	*get_next_line(int fd)
  1074. {
  1075. static char	*content;
  1076. char		*sub;
  1077. int			i;
  1078. int			len;
  1079. i = 0;
  1080. if (fd < 0 || BUFFER_SIZE <= 0)
  1081. return (NULL);
  1082. content = ft_content(fd, content);
  1083. if (content == NULL)
  1084. return (NULL);
  1085. if (content[0] == '\0')
  1086. return (NULL);
  1087. while (content[i] != '\n' && content[i] != '\0')
  1088. i++;
  1089. sub = ft_substr(content, 0, i);
  1090. len = ft_strlen(content);
  1091. i++;
  1092. content = ft_substr(content, i, len);
  1093. return (sub);
  1094. }
  1095. int    main(void)
  1096. {
  1097. int    a = open("exemplo.txt", O_RDONLY);
  1098. printf("%s", get_next_line(a));
  1099. printf("%s", get_next_line(a));
  1100. printf("%s", get_next_line(a));
  1101. printf("%s", get_next_line(a));
  1102. return (0);
  1103. }
  1104. ';
  1105. //free(s);
  1106. return (sub);
  1107. }
  1108. char *ft_strjoin(char *s1, char *s2)
  1109. {
  1110. char *cat;
  1111. size_t i;
  1112. size_t j;
  1113. i = 0;
  1114. j = 0;
  1115. if (!s1)
  1116. {
  1117. s1 = malloc(sizeof(char) * 1);
  1118. s1[0] = '
  1119. size_t	ft_strlen(char *s)
  1120. {
  1121. size_t	i;
  1122. if (!s)
  1123. return (0);
  1124. i = 0;
  1125. while (s[i] != '\0')
  1126. i++;
  1127. return (i);
  1128. }
  1129. char	*ft_strchr(char *s, int c)
  1130. {
  1131. size_t	i;
  1132. i = 0;
  1133. if (!s)
  1134. return (0);
  1135. while ((s[i] != '\0') && (s[i] != (unsigned char)c))
  1136. i++;
  1137. if ((s[i] == (unsigned char)c) || (c == '\0'))
  1138. return ((char *)&s[i]);
  1139. return (0);
  1140. }
  1141. char	*ft_substr(char *s, unsigned int start, size_t len)
  1142. {
  1143. size_t	i;
  1144. size_t	j;
  1145. char	*sub;
  1146. i = 0;
  1147. j = 0;
  1148. if (start >= ft_strlen(s) || !s || !len)
  1149. {
  1150. sub = malloc(1 * sizeof(char));
  1151. sub[0] = '\0';
  1152. return (sub);
  1153. }
  1154. while (s[start + j] != '\0' && j < len)
  1155. j++;
  1156. if (s[start + j] != '\0')
  1157. j++;
  1158. sub = malloc((j + 1) * sizeof(char));
  1159. if (!sub)
  1160. {
  1161. free(s);
  1162. return (0);	
  1163. }
  1164. while (s[start] != '\0' && j > i)
  1165. sub[i++] = s[start++];
  1166. sub[i] = '\0';
  1167. //free(s);
  1168. return (sub);
  1169. }
  1170. char	*ft_strjoin(char *s1, char *s2)
  1171. {
  1172. char	*cat;
  1173. size_t	i;
  1174. size_t	j;
  1175. i = 0;
  1176. j = 0;
  1177. if (!s1)
  1178. {
  1179. s1 = malloc(sizeof(char) * 1);
  1180. s1[0] = '\0';
  1181. }
  1182. cat = (char *)malloc((ft_strlen(s1) + ft_strlen(s2) + 1) * sizeof(char));
  1183. if (!cat)
  1184. return (NULL);
  1185. while (s1[i] != '\0')
  1186. {
  1187. cat[i] = s1[i];
  1188. i++;
  1189. }
  1190. while (s2[j] != '\0')
  1191. cat[i++] = s2[j++];
  1192. free(s1);
  1193. cat[i] = '\0';
  1194. return (cat);
  1195. }
  1196. char	*ft_content(int fd, char *content)
  1197. {
  1198. char	*buf;
  1199. int		buf_nb;
  1200. buf_nb = 1;
  1201. buf = (char *)malloc((BUFFER_SIZE + 1) * sizeof(char));
  1202. if (!buf)
  1203. return (0);
  1204. while ((!ft_strchr(content, '\n')) && buf_nb != 0)
  1205. {
  1206. buf_nb = read(fd, buf, BUFFER_SIZE);
  1207. if (buf_nb == -1)
  1208. {
  1209. free(buf);
  1210. free(content);
  1211. return (NULL);
  1212. }
  1213. buf[buf_nb] = '\0';
  1214. content = ft_strjoin(content, buf);
  1215. }
  1216. free(buf);
  1217. return (content);
  1218. }
  1219. char	*get_next_line(int fd)
  1220. {
  1221. static char	*content;
  1222. char		*sub;
  1223. int			i;
  1224. int			len;
  1225. i = 0;
  1226. if (fd < 0 || BUFFER_SIZE <= 0)
  1227. return (NULL);
  1228. content = ft_content(fd, content);
  1229. if (content == NULL)
  1230. return (NULL);
  1231. if (content[0] == '\0')
  1232. return (NULL);
  1233. while (content[i] != '\n' && content[i] != '\0')
  1234. i++;
  1235. sub = ft_substr(content, 0, i);
  1236. len = ft_strlen(content);
  1237. i++;
  1238. content = ft_substr(content, i, len);
  1239. return (sub);
  1240. }
  1241. int    main(void)
  1242. {
  1243. int    a = open("exemplo.txt", O_RDONLY);
  1244. printf("%s", get_next_line(a));
  1245. printf("%s", get_next_line(a));
  1246. printf("%s", get_next_line(a));
  1247. printf("%s", get_next_line(a));
  1248. return (0);
  1249. }
  1250. ';
  1251. }
  1252. cat = (char *)malloc((ft_strlen(s1) + ft_strlen(s2) + 1) * sizeof(char));
  1253. if (!cat)
  1254. return (NULL);
  1255. while (s1[i] != '
  1256. size_t	ft_strlen(char *s)
  1257. {
  1258. size_t	i;
  1259. if (!s)
  1260. return (0);
  1261. i = 0;
  1262. while (s[i] != '\0')
  1263. i++;
  1264. return (i);
  1265. }
  1266. char	*ft_strchr(char *s, int c)
  1267. {
  1268. size_t	i;
  1269. i = 0;
  1270. if (!s)
  1271. return (0);
  1272. while ((s[i] != '\0') && (s[i] != (unsigned char)c))
  1273. i++;
  1274. if ((s[i] == (unsigned char)c) || (c == '\0'))
  1275. return ((char *)&s[i]);
  1276. return (0);
  1277. }
  1278. char	*ft_substr(char *s, unsigned int start, size_t len)
  1279. {
  1280. size_t	i;
  1281. size_t	j;
  1282. char	*sub;
  1283. i = 0;
  1284. j = 0;
  1285. if (start >= ft_strlen(s) || !s || !len)
  1286. {
  1287. sub = malloc(1 * sizeof(char));
  1288. sub[0] = '\0';
  1289. return (sub);
  1290. }
  1291. while (s[start + j] != '\0' && j < len)
  1292. j++;
  1293. if (s[start + j] != '\0')
  1294. j++;
  1295. sub = malloc((j + 1) * sizeof(char));
  1296. if (!sub)
  1297. {
  1298. free(s);
  1299. return (0);	
  1300. }
  1301. while (s[start] != '\0' && j > i)
  1302. sub[i++] = s[start++];
  1303. sub[i] = '\0';
  1304. //free(s);
  1305. return (sub);
  1306. }
  1307. char	*ft_strjoin(char *s1, char *s2)
  1308. {
  1309. char	*cat;
  1310. size_t	i;
  1311. size_t	j;
  1312. i = 0;
  1313. j = 0;
  1314. if (!s1)
  1315. {
  1316. s1 = malloc(sizeof(char) * 1);
  1317. s1[0] = '\0';
  1318. }
  1319. cat = (char *)malloc((ft_strlen(s1) + ft_strlen(s2) + 1) * sizeof(char));
  1320. if (!cat)
  1321. return (NULL);
  1322. while (s1[i] != '\0')
  1323. {
  1324. cat[i] = s1[i];
  1325. i++;
  1326. }
  1327. while (s2[j] != '\0')
  1328. cat[i++] = s2[j++];
  1329. free(s1);
  1330. cat[i] = '\0';
  1331. return (cat);
  1332. }
  1333. char	*ft_content(int fd, char *content)
  1334. {
  1335. char	*buf;
  1336. int		buf_nb;
  1337. buf_nb = 1;
  1338. buf = (char *)malloc((BUFFER_SIZE + 1) * sizeof(char));
  1339. if (!buf)
  1340. return (0);
  1341. while ((!ft_strchr(content, '\n')) && buf_nb != 0)
  1342. {
  1343. buf_nb = read(fd, buf, BUFFER_SIZE);
  1344. if (buf_nb == -1)
  1345. {
  1346. free(buf);
  1347. free(content);
  1348. return (NULL);
  1349. }
  1350. buf[buf_nb] = '\0';
  1351. content = ft_strjoin(content, buf);
  1352. }
  1353. free(buf);
  1354. return (content);
  1355. }
  1356. char	*get_next_line(int fd)
  1357. {
  1358. static char	*content;
  1359. char		*sub;
  1360. int			i;
  1361. int			len;
  1362. i = 0;
  1363. if (fd < 0 || BUFFER_SIZE <= 0)
  1364. return (NULL);
  1365. content = ft_content(fd, content);
  1366. if (content == NULL)
  1367. return (NULL);
  1368. if (content[0] == '\0')
  1369. return (NULL);
  1370. while (content[i] != '\n' && content[i] != '\0')
  1371. i++;
  1372. sub = ft_substr(content, 0, i);
  1373. len = ft_strlen(content);
  1374. i++;
  1375. content = ft_substr(content, i, len);
  1376. return (sub);
  1377. }
  1378. int    main(void)
  1379. {
  1380. int    a = open("exemplo.txt", O_RDONLY);
  1381. printf("%s", get_next_line(a));
  1382. printf("%s", get_next_line(a));
  1383. printf("%s", get_next_line(a));
  1384. printf("%s", get_next_line(a));
  1385. return (0);
  1386. }
  1387. ')
  1388. {
  1389. cat[i] = s1[i];
  1390. i++;
  1391. }
  1392. while (s2[j] != '
  1393. size_t	ft_strlen(char *s)
  1394. {
  1395. size_t	i;
  1396. if (!s)
  1397. return (0);
  1398. i = 0;
  1399. while (s[i] != '\0')
  1400. i++;
  1401. return (i);
  1402. }
  1403. char	*ft_strchr(char *s, int c)
  1404. {
  1405. size_t	i;
  1406. i = 0;
  1407. if (!s)
  1408. return (0);
  1409. while ((s[i] != '\0') && (s[i] != (unsigned char)c))
  1410. i++;
  1411. if ((s[i] == (unsigned char)c) || (c == '\0'))
  1412. return ((char *)&s[i]);
  1413. return (0);
  1414. }
  1415. char	*ft_substr(char *s, unsigned int start, size_t len)
  1416. {
  1417. size_t	i;
  1418. size_t	j;
  1419. char	*sub;
  1420. i = 0;
  1421. j = 0;
  1422. if (start >= ft_strlen(s) || !s || !len)
  1423. {
  1424. sub = malloc(1 * sizeof(char));
  1425. sub[0] = '\0';
  1426. return (sub);
  1427. }
  1428. while (s[start + j] != '\0' && j < len)
  1429. j++;
  1430. if (s[start + j] != '\0')
  1431. j++;
  1432. sub = malloc((j + 1) * sizeof(char));
  1433. if (!sub)
  1434. {
  1435. free(s);
  1436. return (0);	
  1437. }
  1438. while (s[start] != '\0' && j > i)
  1439. sub[i++] = s[start++];
  1440. sub[i] = '\0';
  1441. //free(s);
  1442. return (sub);
  1443. }
  1444. char	*ft_strjoin(char *s1, char *s2)
  1445. {
  1446. char	*cat;
  1447. size_t	i;
  1448. size_t	j;
  1449. i = 0;
  1450. j = 0;
  1451. if (!s1)
  1452. {
  1453. s1 = malloc(sizeof(char) * 1);
  1454. s1[0] = '\0';
  1455. }
  1456. cat = (char *)malloc((ft_strlen(s1) + ft_strlen(s2) + 1) * sizeof(char));
  1457. if (!cat)
  1458. return (NULL);
  1459. while (s1[i] != '\0')
  1460. {
  1461. cat[i] = s1[i];
  1462. i++;
  1463. }
  1464. while (s2[j] != '\0')
  1465. cat[i++] = s2[j++];
  1466. free(s1);
  1467. cat[i] = '\0';
  1468. return (cat);
  1469. }
  1470. char	*ft_content(int fd, char *content)
  1471. {
  1472. char	*buf;
  1473. int		buf_nb;
  1474. buf_nb = 1;
  1475. buf = (char *)malloc((BUFFER_SIZE + 1) * sizeof(char));
  1476. if (!buf)
  1477. return (0);
  1478. while ((!ft_strchr(content, '\n')) && buf_nb != 0)
  1479. {
  1480. buf_nb = read(fd, buf, BUFFER_SIZE);
  1481. if (buf_nb == -1)
  1482. {
  1483. free(buf);
  1484. free(content);
  1485. return (NULL);
  1486. }
  1487. buf[buf_nb] = '\0';
  1488. content = ft_strjoin(content, buf);
  1489. }
  1490. free(buf);
  1491. return (content);
  1492. }
  1493. char	*get_next_line(int fd)
  1494. {
  1495. static char	*content;
  1496. char		*sub;
  1497. int			i;
  1498. int			len;
  1499. i = 0;
  1500. if (fd < 0 || BUFFER_SIZE <= 0)
  1501. return (NULL);
  1502. content = ft_content(fd, content);
  1503. if (content == NULL)
  1504. return (NULL);
  1505. if (content[0] == '\0')
  1506. return (NULL);
  1507. while (content[i] != '\n' && content[i] != '\0')
  1508. i++;
  1509. sub = ft_substr(content, 0, i);
  1510. len = ft_strlen(content);
  1511. i++;
  1512. content = ft_substr(content, i, len);
  1513. return (sub);
  1514. }
  1515. int    main(void)
  1516. {
  1517. int    a = open("exemplo.txt", O_RDONLY);
  1518. printf("%s", get_next_line(a));
  1519. printf("%s", get_next_line(a));
  1520. printf("%s", get_next_line(a));
  1521. printf("%s", get_next_line(a));
  1522. return (0);
  1523. }
  1524. ')
  1525. cat[i++] = s2[j++];
  1526. free(s1);
  1527. cat[i] = '
  1528. size_t	ft_strlen(char *s)
  1529. {
  1530. size_t	i;
  1531. if (!s)
  1532. return (0);
  1533. i = 0;
  1534. while (s[i] != '\0')
  1535. i++;
  1536. return (i);
  1537. }
  1538. char	*ft_strchr(char *s, int c)
  1539. {
  1540. size_t	i;
  1541. i = 0;
  1542. if (!s)
  1543. return (0);
  1544. while ((s[i] != '\0') && (s[i] != (unsigned char)c))
  1545. i++;
  1546. if ((s[i] == (unsigned char)c) || (c == '\0'))
  1547. return ((char *)&s[i]);
  1548. return (0);
  1549. }
  1550. char	*ft_substr(char *s, unsigned int start, size_t len)
  1551. {
  1552. size_t	i;
  1553. size_t	j;
  1554. char	*sub;
  1555. i = 0;
  1556. j = 0;
  1557. if (start >= ft_strlen(s) || !s || !len)
  1558. {
  1559. sub = malloc(1 * sizeof(char));
  1560. sub[0] = '\0';
  1561. return (sub);
  1562. }
  1563. while (s[start + j] != '\0' && j < len)
  1564. j++;
  1565. if (s[start + j] != '\0')
  1566. j++;
  1567. sub = malloc((j + 1) * sizeof(char));
  1568. if (!sub)
  1569. {
  1570. free(s);
  1571. return (0);	
  1572. }
  1573. while (s[start] != '\0' && j > i)
  1574. sub[i++] = s[start++];
  1575. sub[i] = '\0';
  1576. //free(s);
  1577. return (sub);
  1578. }
  1579. char	*ft_strjoin(char *s1, char *s2)
  1580. {
  1581. char	*cat;
  1582. size_t	i;
  1583. size_t	j;
  1584. i = 0;
  1585. j = 0;
  1586. if (!s1)
  1587. {
  1588. s1 = malloc(sizeof(char) * 1);
  1589. s1[0] = '\0';
  1590. }
  1591. cat = (char *)malloc((ft_strlen(s1) + ft_strlen(s2) + 1) * sizeof(char));
  1592. if (!cat)
  1593. return (NULL);
  1594. while (s1[i] != '\0')
  1595. {
  1596. cat[i] = s1[i];
  1597. i++;
  1598. }
  1599. while (s2[j] != '\0')
  1600. cat[i++] = s2[j++];
  1601. free(s1);
  1602. cat[i] = '\0';
  1603. return (cat);
  1604. }
  1605. char	*ft_content(int fd, char *content)
  1606. {
  1607. char	*buf;
  1608. int		buf_nb;
  1609. buf_nb = 1;
  1610. buf = (char *)malloc((BUFFER_SIZE + 1) * sizeof(char));
  1611. if (!buf)
  1612. return (0);
  1613. while ((!ft_strchr(content, '\n')) && buf_nb != 0)
  1614. {
  1615. buf_nb = read(fd, buf, BUFFER_SIZE);
  1616. if (buf_nb == -1)
  1617. {
  1618. free(buf);
  1619. free(content);
  1620. return (NULL);
  1621. }
  1622. buf[buf_nb] = '\0';
  1623. content = ft_strjoin(content, buf);
  1624. }
  1625. free(buf);
  1626. return (content);
  1627. }
  1628. char	*get_next_line(int fd)
  1629. {
  1630. static char	*content;
  1631. char		*sub;
  1632. int			i;
  1633. int			len;
  1634. i = 0;
  1635. if (fd < 0 || BUFFER_SIZE <= 0)
  1636. return (NULL);
  1637. content = ft_content(fd, content);
  1638. if (content == NULL)
  1639. return (NULL);
  1640. if (content[0] == '\0')
  1641. return (NULL);
  1642. while (content[i] != '\n' && content[i] != '\0')
  1643. i++;
  1644. sub = ft_substr(content, 0, i);
  1645. len = ft_strlen(content);
  1646. i++;
  1647. content = ft_substr(content, i, len);
  1648. return (sub);
  1649. }
  1650. int    main(void)
  1651. {
  1652. int    a = open("exemplo.txt", O_RDONLY);
  1653. printf("%s", get_next_line(a));
  1654. printf("%s", get_next_line(a));
  1655. printf("%s", get_next_line(a));
  1656. printf("%s", get_next_line(a));
  1657. return (0);
  1658. }
  1659. ';
  1660. return (cat);
  1661. }
  1662. char *ft_content(int fd, char *content)
  1663. {
  1664. char *buf;
  1665. int buf_nb;
  1666. buf_nb = 1;
  1667. buf = (char *)malloc((BUFFER_SIZE + 1) * sizeof(char));
  1668. if (!buf)
  1669. return (0);
  1670. while ((!ft_strchr(content, '\n')) && buf_nb != 0)
  1671. {
  1672. buf_nb = read(fd, buf, BUFFER_SIZE);
  1673. if (buf_nb == -1)
  1674. {
  1675. free(buf);
  1676. free(content);
  1677. return (NULL);
  1678. }
  1679. buf[buf_nb] = '
  1680. size_t	ft_strlen(char *s)
  1681. {
  1682. size_t	i;
  1683. if (!s)
  1684. return (0);
  1685. i = 0;
  1686. while (s[i] != '\0')
  1687. i++;
  1688. return (i);
  1689. }
  1690. char	*ft_strchr(char *s, int c)
  1691. {
  1692. size_t	i;
  1693. i = 0;
  1694. if (!s)
  1695. return (0);
  1696. while ((s[i] != '\0') && (s[i] != (unsigned char)c))
  1697. i++;
  1698. if ((s[i] == (unsigned char)c) || (c == '\0'))
  1699. return ((char *)&s[i]);
  1700. return (0);
  1701. }
  1702. char	*ft_substr(char *s, unsigned int start, size_t len)
  1703. {
  1704. size_t	i;
  1705. size_t	j;
  1706. char	*sub;
  1707. i = 0;
  1708. j = 0;
  1709. if (start >= ft_strlen(s) || !s || !len)
  1710. {
  1711. sub = malloc(1 * sizeof(char));
  1712. sub[0] = '\0';
  1713. return (sub);
  1714. }
  1715. while (s[start + j] != '\0' && j < len)
  1716. j++;
  1717. if (s[start + j] != '\0')
  1718. j++;
  1719. sub = malloc((j + 1) * sizeof(char));
  1720. if (!sub)
  1721. {
  1722. free(s);
  1723. return (0);	
  1724. }
  1725. while (s[start] != '\0' && j > i)
  1726. sub[i++] = s[start++];
  1727. sub[i] = '\0';
  1728. //free(s);
  1729. return (sub);
  1730. }
  1731. char	*ft_strjoin(char *s1, char *s2)
  1732. {
  1733. char	*cat;
  1734. size_t	i;
  1735. size_t	j;
  1736. i = 0;
  1737. j = 0;
  1738. if (!s1)
  1739. {
  1740. s1 = malloc(sizeof(char) * 1);
  1741. s1[0] = '\0';
  1742. }
  1743. cat = (char *)malloc((ft_strlen(s1) + ft_strlen(s2) + 1) * sizeof(char));
  1744. if (!cat)
  1745. return (NULL);
  1746. while (s1[i] != '\0')
  1747. {
  1748. cat[i] = s1[i];
  1749. i++;
  1750. }
  1751. while (s2[j] != '\0')
  1752. cat[i++] = s2[j++];
  1753. free(s1);
  1754. cat[i] = '\0';
  1755. return (cat);
  1756. }
  1757. char	*ft_content(int fd, char *content)
  1758. {
  1759. char	*buf;
  1760. int		buf_nb;
  1761. buf_nb = 1;
  1762. buf = (char *)malloc((BUFFER_SIZE + 1) * sizeof(char));
  1763. if (!buf)
  1764. return (0);
  1765. while ((!ft_strchr(content, '\n')) && buf_nb != 0)
  1766. {
  1767. buf_nb = read(fd, buf, BUFFER_SIZE);
  1768. if (buf_nb == -1)
  1769. {
  1770. free(buf);
  1771. free(content);
  1772. return (NULL);
  1773. }
  1774. buf[buf_nb] = '\0';
  1775. content = ft_strjoin(content, buf);
  1776. }
  1777. free(buf);
  1778. return (content);
  1779. }
  1780. char	*get_next_line(int fd)
  1781. {
  1782. static char	*content;
  1783. char		*sub;
  1784. int			i;
  1785. int			len;
  1786. i = 0;
  1787. if (fd < 0 || BUFFER_SIZE <= 0)
  1788. return (NULL);
  1789. content = ft_content(fd, content);
  1790. if (content == NULL)
  1791. return (NULL);
  1792. if (content[0] == '\0')
  1793. return (NULL);
  1794. while (content[i] != '\n' && content[i] != '\0')
  1795. i++;
  1796. sub = ft_substr(content, 0, i);
  1797. len = ft_strlen(content);
  1798. i++;
  1799. content = ft_substr(content, i, len);
  1800. return (sub);
  1801. }
  1802. int    main(void)
  1803. {
  1804. int    a = open("exemplo.txt", O_RDONLY);
  1805. printf("%s", get_next_line(a));
  1806. printf("%s", get_next_line(a));
  1807. printf("%s", get_next_line(a));
  1808. printf("%s", get_next_line(a));
  1809. return (0);
  1810. }
  1811. ';
  1812. content = ft_strjoin(content, buf);
  1813. }
  1814. free(buf);
  1815. return (content);
  1816. }
  1817. char *get_next_line(int fd)
  1818. {
  1819. static char *content;
  1820. char *sub;
  1821. int i;
  1822. int len;
  1823. i = 0;
  1824. if (fd < 0 || BUFFER_SIZE <= 0)
  1825. return (NULL);
  1826. content = ft_content(fd, content);
  1827. if (content == NULL)
  1828. return (NULL);
  1829. if (content[0] == '
  1830. size_t	ft_strlen(char *s)
  1831. {
  1832. size_t	i;
  1833. if (!s)
  1834. return (0);
  1835. i = 0;
  1836. while (s[i] != '\0')
  1837. i++;
  1838. return (i);
  1839. }
  1840. char	*ft_strchr(char *s, int c)
  1841. {
  1842. size_t	i;
  1843. i = 0;
  1844. if (!s)
  1845. return (0);
  1846. while ((s[i] != '\0') && (s[i] != (unsigned char)c))
  1847. i++;
  1848. if ((s[i] == (unsigned char)c) || (c == '\0'))
  1849. return ((char *)&s[i]);
  1850. return (0);
  1851. }
  1852. char	*ft_substr(char *s, unsigned int start, size_t len)
  1853. {
  1854. size_t	i;
  1855. size_t	j;
  1856. char	*sub;
  1857. i = 0;
  1858. j = 0;
  1859. if (start >= ft_strlen(s) || !s || !len)
  1860. {
  1861. sub = malloc(1 * sizeof(char));
  1862. sub[0] = '\0';
  1863. return (sub);
  1864. }
  1865. while (s[start + j] != '\0' && j < len)
  1866. j++;
  1867. if (s[start + j] != '\0')
  1868. j++;
  1869. sub = malloc((j + 1) * sizeof(char));
  1870. if (!sub)
  1871. {
  1872. free(s);
  1873. return (0);	
  1874. }
  1875. while (s[start] != '\0' && j > i)
  1876. sub[i++] = s[start++];
  1877. sub[i] = '\0';
  1878. //free(s);
  1879. return (sub);
  1880. }
  1881. char	*ft_strjoin(char *s1, char *s2)
  1882. {
  1883. char	*cat;
  1884. size_t	i;
  1885. size_t	j;
  1886. i = 0;
  1887. j = 0;
  1888. if (!s1)
  1889. {
  1890. s1 = malloc(sizeof(char) * 1);
  1891. s1[0] = '\0';
  1892. }
  1893. cat = (char *)malloc((ft_strlen(s1) + ft_strlen(s2) + 1) * sizeof(char));
  1894. if (!cat)
  1895. return (NULL);
  1896. while (s1[i] != '\0')
  1897. {
  1898. cat[i] = s1[i];
  1899. i++;
  1900. }
  1901. while (s2[j] != '\0')
  1902. cat[i++] = s2[j++];
  1903. free(s1);
  1904. cat[i] = '\0';
  1905. return (cat);
  1906. }
  1907. char	*ft_content(int fd, char *content)
  1908. {
  1909. char	*buf;
  1910. int		buf_nb;
  1911. buf_nb = 1;
  1912. buf = (char *)malloc((BUFFER_SIZE + 1) * sizeof(char));
  1913. if (!buf)
  1914. return (0);
  1915. while ((!ft_strchr(content, '\n')) && buf_nb != 0)
  1916. {
  1917. buf_nb = read(fd, buf, BUFFER_SIZE);
  1918. if (buf_nb == -1)
  1919. {
  1920. free(buf);
  1921. free(content);
  1922. return (NULL);
  1923. }
  1924. buf[buf_nb] = '\0';
  1925. content = ft_strjoin(content, buf);
  1926. }
  1927. free(buf);
  1928. return (content);
  1929. }
  1930. char	*get_next_line(int fd)
  1931. {
  1932. static char	*content;
  1933. char		*sub;
  1934. int			i;
  1935. int			len;
  1936. i = 0;
  1937. if (fd < 0 || BUFFER_SIZE <= 0)
  1938. return (NULL);
  1939. content = ft_content(fd, content);
  1940. if (content == NULL)
  1941. return (NULL);
  1942. if (content[0] == '\0')
  1943. return (NULL);
  1944. while (content[i] != '\n' && content[i] != '\0')
  1945. i++;
  1946. sub = ft_substr(content, 0, i);
  1947. len = ft_strlen(content);
  1948. i++;
  1949. content = ft_substr(content, i, len);
  1950. return (sub);
  1951. }
  1952. int    main(void)
  1953. {
  1954. int    a = open("exemplo.txt", O_RDONLY);
  1955. printf("%s", get_next_line(a));
  1956. printf("%s", get_next_line(a));
  1957. printf("%s", get_next_line(a));
  1958. printf("%s", get_next_line(a));
  1959. return (0);
  1960. }
  1961. ')
  1962. return (NULL);
  1963. while (content[i] != '\n' && content[i] != '
  1964. size_t	ft_strlen(char *s)
  1965. {
  1966. size_t	i;
  1967. if (!s)
  1968. return (0);
  1969. i = 0;
  1970. while (s[i] != '\0')
  1971. i++;
  1972. return (i);
  1973. }
  1974. char	*ft_strchr(char *s, int c)
  1975. {
  1976. size_t	i;
  1977. i = 0;
  1978. if (!s)
  1979. return (0);
  1980. while ((s[i] != '\0') && (s[i] != (unsigned char)c))
  1981. i++;
  1982. if ((s[i] == (unsigned char)c) || (c == '\0'))
  1983. return ((char *)&s[i]);
  1984. return (0);
  1985. }
  1986. char	*ft_substr(char *s, unsigned int start, size_t len)
  1987. {
  1988. size_t	i;
  1989. size_t	j;
  1990. char	*sub;
  1991. i = 0;
  1992. j = 0;
  1993. if (start >= ft_strlen(s) || !s || !len)
  1994. {
  1995. sub = malloc(1 * sizeof(char));
  1996. sub[0] = '\0';
  1997. return (sub);
  1998. }
  1999. while (s[start + j] != '\0' && j < len)
  2000. j++;
  2001. if (s[start + j] != '\0')
  2002. j++;
  2003. sub = malloc((j + 1) * sizeof(char));
  2004. if (!sub)
  2005. {
  2006. free(s);
  2007. return (0);	
  2008. }
  2009. while (s[start] != '\0' && j > i)
  2010. sub[i++] = s[start++];
  2011. sub[i] = '\0';
  2012. //free(s);
  2013. return (sub);
  2014. }
  2015. char	*ft_strjoin(char *s1, char *s2)
  2016. {
  2017. char	*cat;
  2018. size_t	i;
  2019. size_t	j;
  2020. i = 0;
  2021. j = 0;
  2022. if (!s1)
  2023. {
  2024. s1 = malloc(sizeof(char) * 1);
  2025. s1[0] = '\0';
  2026. }
  2027. cat = (char *)malloc((ft_strlen(s1) + ft_strlen(s2) + 1) * sizeof(char));
  2028. if (!cat)
  2029. return (NULL);
  2030. while (s1[i] != '\0')
  2031. {
  2032. cat[i] = s1[i];
  2033. i++;
  2034. }
  2035. while (s2[j] != '\0')
  2036. cat[i++] = s2[j++];
  2037. free(s1);
  2038. cat[i] = '\0';
  2039. return (cat);
  2040. }
  2041. char	*ft_content(int fd, char *content)
  2042. {
  2043. char	*buf;
  2044. int		buf_nb;
  2045. buf_nb = 1;
  2046. buf = (char *)malloc((BUFFER_SIZE + 1) * sizeof(char));
  2047. if (!buf)
  2048. return (0);
  2049. while ((!ft_strchr(content, '\n')) && buf_nb != 0)
  2050. {
  2051. buf_nb = read(fd, buf, BUFFER_SIZE);
  2052. if (buf_nb == -1)
  2053. {
  2054. free(buf);
  2055. free(content);
  2056. return (NULL);
  2057. }
  2058. buf[buf_nb] = '\0';
  2059. content = ft_strjoin(content, buf);
  2060. }
  2061. free(buf);
  2062. return (content);
  2063. }
  2064. char	*get_next_line(int fd)
  2065. {
  2066. static char	*content;
  2067. char		*sub;
  2068. int			i;
  2069. int			len;
  2070. i = 0;
  2071. if (fd < 0 || BUFFER_SIZE <= 0)
  2072. return (NULL);
  2073. content = ft_content(fd, content);
  2074. if (content == NULL)
  2075. return (NULL);
  2076. if (content[0] == '\0')
  2077. return (NULL);
  2078. while (content[i] != '\n' && content[i] != '\0')
  2079. i++;
  2080. sub = ft_substr(content, 0, i);
  2081. len = ft_strlen(content);
  2082. i++;
  2083. content = ft_substr(content, i, len);
  2084. return (sub);
  2085. }
  2086. int    main(void)
  2087. {
  2088. int    a = open("exemplo.txt", O_RDONLY);
  2089. printf("%s", get_next_line(a));
  2090. printf("%s", get_next_line(a));
  2091. printf("%s", get_next_line(a));
  2092. printf("%s", get_next_line(a));
  2093. return (0);
  2094. }
  2095. ')
  2096. i++;
  2097. sub = ft_substr(content, 0, i);
  2098. len = ft_strlen(content);
  2099. i++;
  2100. content = ft_substr(content, i, len);
  2101. return (sub);
  2102. }
  2103. int main(void)
  2104. {
  2105. int a = open("exemplo.txt", O_RDONLY);
  2106. printf("%s", get_next_line(a));
  2107. printf("%s", get_next_line(a));
  2108. printf("%s", get_next_line(a));
  2109. printf("%s", get_next_line(a));
  2110. return (0);
  2111. }

I've done several changes but I always get memory leaks and segmentation fault.

What I expected was just to read the file.

答案1

得分: 1

如果您正在使用gcc或clang编译器,您可以尝试在编译程序时使用命令行选项-fsanitize=leak,以检测任何内存泄漏。

有关更多信息,请参阅gcc手册中的此页面

英文:

If you are using the compilers gcc or clang, you can try using the command-line option -fsanitize=leak when compiling the program, in order to detect any memory leaks.

See this page from the gcc manual for further information.

huangapple
  • 本文由 发表于 2023年6月1日 23:47:00
  • 转载请务必保留本文链接:https://go.coder-hub.com/76383661.html
匿名

发表评论

匿名网友

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

确定