#ifndef INPUT_DATA
#define INPUT_DATA

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
#include<ctype.h>

#define BUFF_MAX 10  //最大缓冲区

void Input_Init_DATA(void** ,size_t );      //初始化输入数据
void Input_Absorb_Buffer(char** );          //对缓冲区残留数据进行处理
int Input_Solve_Negative(char** );          //对输入负数进行处理
void Input_Free(void** );                   //释放堆空间
void Input_Catch(char* ,char** );           //异常处理


int Input_Big_Int(char** );           //输入大整数(支持输入负数)
void Input_String(void** );           //从输入字符串
int Input_Data(const void* ,void* );  //输入数据

void Input_Init_Data(void** p,size_t size)   //初始化输入数据
{
    *p=(char* )malloc((BUFF_MAX)*sizeof(char));

    assert(*p!=NULL);

    memset(*p,0,sizeof(size));
}

void Input_DATA(char** p,char** pt,size_t* length)     //对输入数据进行处理
{
    ++*length;

    if (*length%(BUFF_MAX-1)==0)
    {
        char* ps=realloc(*p,(*length+BUFF_MAX)*sizeof(char));

        Input_Catch(ps,p);

        *p=ps;

         memset(*p+*length,0,BUFF_MAX*sizeof(char));

         *pt=*p+*length-1;
    }

        ++*pt;
}

int Input_Solve_Negative(char** p)             //对输入负数进行处理
{
    int flag=0;
    int flag2=0;

    while (1)   //对负数输入进行处理
    {
        **p=getchar();

        if (**p=='+'&&flag2!=1)
        {
            flag2=1;
            continue;
        }
        else if (**p=='+'&&flag2==1)
            return EOF;

        if (**p=='-'&&flag2!=-1)
        {
            flag=!flag;
            flag2=-1;
            continue;
        }
        else if (**p=='-'&&flag2==-1)
            return EOF;

        break;
    }

    if (!isdigit(**p))
        return EOF;

    if (flag)
    {
        char buff=**p;
        **p='-';
        ++*p;
        **p=buff;
    }

    return flag;
}

void Input_Absorb_Buffer(char** p)
{
    while (getchar()!='\n');

    Input_Free(p);

    *p=strdup("");
}

void Input_Free(void** p)                  //释放堆空间
{
    if (*p==NULL)
        return ;

    free(*p);
    *p=NULL;
}

void Input_Catch(char* ps,char** p)
{
    if (ps!=NULL)
        return ;

    Input_Free(p);
    assert(1);
}

int Input_Big_Int(char** p)                //初始化数据
{
    char* pt=NULL;
    int k=0;
    size_t length=0;

    Input_Init_Data(p,(BUFF_MAX)*sizeof(char));

    pt=*p;

    k=Input_Solve_Negative(&pt);       //对输入负数进行处理

    if (*pt=='\n')
    {
        *pt='\0';
        return EOF;
    }

    if (k==EOF)
    {
        Input_Absorb_Buffer(p);
        return EOF;
    }

    do
    {
        Input_DATA(p,&pt,&length);
    }while (isdigit(*pt=getchar()));           //对输入缓冲区进行处理

    if (*pt=='\n')
    {
        *pt='\0';
        return EOF;
    }

    Input_Absorb_Buffer(p);   //对缓冲区残留数据进行处理

    return 1;
}

void Input_String(char** p)   //输入字符串
{
    char* pt=NULL;
    size_t length=0;

    Input_Init_Data(p,(BUFF_MAX)*sizeof(char));

    pt=*p;

    while ((*pt=getchar())!='\n')
        Input_DATA(p,&pt,&length);

    *pt='\0';
}

int Input_Data(const void* format,void* s)
{
    if (scanf(format,s)!=1)
        while (getchar()!='\n');

    return 1;
}

#undef BUFF_MAX

#endif  

#include<stdio.h>
#include"Input.h"
#include"Big_Intger.h"
int main()
{
    char* p1=NULL;
    char* p2=NULL;

    Input_Big_Int(&p1);
    Input_String(&p2);

    puts(p1);
    puts(p2);

    free(p1);
    free(p2);

    return 0;
}

很久很久以前曾经写了个字符过滤器~用正则表达式匹配输入的字符~~不过回家后的电脑找不到了~打算回校再补充~这个可以看看效果如何~

[此贴子已经被作者于2017-5-29 16:16编辑过]

感觉可以写个模拟scanf的输入函数~~不过还没有看可变长度参数的用法~关键是要解决scanf的安全性问题(例如输入错误可能会导致死循环等等)~这个以后再改进吧~~

这样啊~那我还是先放一下了~不过因为输入数据类型不匹配而引发死循环这个基本问题还是要解决一下的~

改进了一下~现在大整数输入支持输入负数了~~主要是用于大整数运算输入处理~~~

strdup包含在string.h里面~意思是从堆空间分配与原字符串长度相匹配的空间(相当于复制)~之所以不用NULL代替是因为如果输入不匹配的字符串返回NULL释放空间时会出错(其实这个我也是在renkejun1942那里学回来的)

至于2、while (getchar()!='\n');
这里是吸收缓冲去残留的字符~是在不匹配的情况下调用的~就是这样~

大一~

就像为什么有些人这么有钱一样~其实和大土豪比起来还是有很大差距的~~~