[已解决]怎样才能让字符数组根据输入的字符数自动变化大小

nahongyan1997

代码

#include<stdio.h>


//这里被限制住了导致最大只能输入这么大的字符
char str[10000000];



int main() {
    printf("请输入任意字符：");
    fgets(str, sizeof(str) / sizeof(char), stdin);
    fputs(str, stdout);

    return 0;
}

最佳答案

月排行榜 / 总排行榜

永恒的蓝色梦想

2020-8-15 10:25:49

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>



char* autoalloc_gets(char* str, size_t* capacity) {//自动扩容版的 gets
    char* temp;
    size_t index = 0;


    for (;;) {
        if (index + 1 < *capacity) {
            switch (str[index] = getchar()) {//遇到以下字符，终止扫描
                case '\n':
                case '\r':
                case EOF:
                    str[index] = '\0';//'\0' 的话，就不需要重置了

                case '\0':
                    *capacity = index + 1;
                    return (char*)realloc(str, *capacity * sizeof(char));
            }

            ++index;
        }
        else {//扩容
            *capacity <<= 1;//默认扩容为原容量的 2 倍

            if (temp = (char*)realloc(str, *capacity * sizeof(char))) {//为了防止 realloc 返回 NULL 造成内存泄露
                str = temp;
            }
            else {//扩容失败，直接返回
                str[index] = '\0';//放置字符串终止符
                *capacity >>= 1;//退回来
                return str;
            }
        }
    }


    return 0;//装饰，防止编译器报错
}



int main() {
    size_t capacity = 100;
    puts(autoalloc_gets((char*)malloc(100 * sizeof(char)), &capacity));
    return 0;
}

---

这个就可以自动扩容啦~满意麻烦给个最佳哦~

跳转到最佳答案楼层

xieglt

#inclue<stdlib>

char * str;
int num;

scanf("%d",&num);
str = malloc(num);
...

free(str);

xieglt

如果是C++，则可以用std::string,如：

#include<string>

std::string str;

str = "hello";
str += " world";

永恒的蓝色梦想

我正在写自动扩容的 gets，稍等~

Shuranima

你好，根据你的需求，你需要了解动态分配（malloc），然后学习链表，二叉树等数据结构即可完成。

永恒的蓝色梦想

Shuranima 发表于 2020-8-15 06:15
你好，根据你的需求，你需要了解动态分配（malloc），然后学习链表，二叉树等数据结构即可完成。

你说的也太夸张了……

永恒的蓝色梦想

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>



char* autoalloc_gets(char* str, size_t* capacity) {//自动扩容版的 gets
    char* temp;
    size_t index = 0;


    for (;;) {
        if (index + 1 < *capacity) {
            switch (str[index] = getchar()) {//遇到以下字符，终止扫描
                case '\n':
                case '\r':
                case EOF:
                    str[index] = '\0';//'\0' 的话，就不需要重置了

                case '\0':
                    *capacity = index + 1;
                    return (char*)realloc(str, *capacity * sizeof(char));
            }

            ++index;
        }
        else {//扩容
            *capacity <<= 1;//默认扩容为原容量的 2 倍

            if (temp = (char*)realloc(str, *capacity * sizeof(char))) {//为了防止 realloc 返回 NULL 造成内存泄露
                str = temp;
            }
            else {//扩容失败，直接返回
                str[index] = '\0';//放置字符串终止符
                *capacity >>= 1;//退回来
                return str;
            }
        }
    }


    return 0;//装饰，防止编译器报错
}



int main() {
    size_t capacity = 100;
    puts(autoalloc_gets((char*)malloc(100 * sizeof(char)), &capacity));
    return 0;
}

---

这个就可以自动扩容啦~满意麻烦给个最佳哦~

风过无痕1989

永恒的蓝色梦想 发表于 2020-8-15 10:25

---

这个就可以自动扩容啦~满意麻烦给个最佳哦~

收藏了，谢谢!

永恒的蓝色梦想

风过无痕1989 发表于 2020-8-15 13:08
收藏了，谢谢!

看这里
https://fishc.com.cn/thread-177756-1-1.html

风过无痕1989

永恒的蓝色梦想 发表于 2020-8-15 13:09
看这里
https://fishc.com.cn/thread-177756-1-1.html

那边收藏了，这边删除了

Shuranima

永恒的蓝色梦想 发表于 2020-8-15 10:20
你说的也太夸张了……

不算吧，至少学了链表就行了。

永恒的蓝色梦想

Shuranima 发表于 2020-8-17 09:56
不算吧，至少学了链表就行了。

这要用链表？火箭打蚊子？

Shuranima

永恒的蓝色梦想 发表于 2020-8-17 10:42
这要用链表？火箭打蚊子？

链表也是火箭？ 初学者都会吧？

Shuranima

永恒的蓝色梦想 发表于 2020-8-17 10:42
这要用链表？火箭打蚊子？

你这样说的搞得别人以为好难，都不敢去 碰，这有什么问题嘛？

永恒的蓝色梦想

Shuranima 发表于 2020-8-21 13:24
你这样说的搞得别人以为好难，都不敢去 碰，这有什么问题嘛？

兄弟你属实逗笑我了，你也不看看你自己说的什么？

你好，根据你的需求，你需要了解动态分配（malloc），然后学习链表，二叉树等数据结构即可完成。

明明一个动态分配内存的问题，被你扯出来链表、二叉树，还说我 “搞得别人以为好难，都不敢去碰”，这不是贼喊捉贼么？

Shuranima

永恒的蓝色梦想 发表于 2020-8-21 15:53
兄弟你属实逗笑我了，你也不看看你自己说的什么？明明一个动态分配内存的问题，被你扯出来链表、二叉树 ...

大哥，单说链表确实不难啊，是你这样说的好像很难一样。

永恒的蓝色梦想

Shuranima 发表于 2020-8-22 07:10
大哥，单说链表确实不难啊，是你这样说的好像很难一样。

这里体现的是“大材小用”，而非“很难”，好不好？

Shuranima

永恒的蓝色梦想 发表于 2020-8-22 10:30
这里体现的是“大材小用”，而非“很难”，好不好？

行行行，不争辩了。