今天闲逛看到了"魔王的语言"这数据结构题型~
题目大意是这样的~


看资料说用栈和队列完成~关键是算法的意义可以解决多重括号问题~不多不少和解决中缀表达式算法有关~有兴趣的可以看看有关资料~

而且栈和队列适用于我那个通用链表哦~~

弄了个储存不同类型数据的两种方法~~第一种是用共用体(数组)~~第二种是用抽象指针(空指针)~感觉共用体就是一个内存块多些引用不同数据类型的接口~实际本质应该就是一个内存块~和普通内存块没啥区别~至于课课提供变量类型接口其实是在预编译的时候处理好了~就是这样~~~~~

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

#define MAXLEN 32

typedef union U_Node
{
    void* s;
    int a;
    float b;
    double c;
}U_Node;

void fun(void** p,size_t size);
void Input(void** p,size_t n,void* e,size_t size);
void free_point(void** p);

int main()
{
    U_Node un[MAXLEN]={0};
    void** p=NULL;
    int a=3;
    float b=(float )1.23;
    double c=3.14159;

    fun(&un[0].s,sizeof("abcde"));
    memmove(un[0].s,"abcde",sizeof("abcde"));

    un[1].a=a;
    un[2].b=b;
    un[3].c=c;

    printf("%s\n",un[0].s);
    printf("%d\n",un[1].a);
    printf("%.2f\n",un[2].b);
    printf("%g\n",un[3].c);

    puts("");

    free_point(&un[0].s);

    fun(&(void* )p,sizeof(void* )*MAXLEN);
    Input(p,0,"abcde",sizeof("abcde"));
    Input(p,1,&a,sizeof(a));
    Input(p,2,&b,sizeof(b));
    Input(p,3,&c,sizeof(c));

    printf("%s\n",((char* )p[0]));
    printf("%d\n",*((char* )p[1]));
    printf("%.2f\n",*(float* )((char* )p[2]));
    printf("%g\n",*(double* )((char* )p[3]));

    free_point((void* )&((char* )p[0]));
    free_point((void* )&((char* )p[1]));
    free_point((void* )&((char* )p[2]));
    free_point((void* )&((char* )p[3]));
    free_point((void* )&p);

    return 0;
}

void fun(void** p,size_t size)
{
    *p=malloc(size);
    assert(*p);
    memset(*p,0,size);
}

void Input(void** p,size_t n,void* e,size_t size)
{
    void** pt=(char** )p+n;
    *pt=malloc(size);
    assert(*pt);
    memset(*pt,0,size);
    memmove(*pt,e,size);
}


void free_point(void** p)
{
    if (*p==NULL)
        return ;

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

[此贴子已经被作者于2017-5-26 23:05编辑过]

感觉第二种方法写得比较简单~~其实可以用一个结构体来保存每个空间长度信息~感觉一个共用体包含4个基本变量类型成员就可以了(其中一个是空指针)~就是这样~

现在有一个问题~~~~~~~就是如何判断共用体成员void* p是否被分配空间?~~
如果有一大堆数据集合~~则怎么判断该空间是否被释放？~~~感觉要自己另外记录数据类型的指向才行~~~

typedef enum UNION_TYPE
{
    POINT,CHAR,SHORT,INT,FLOAT,DOUBLE,SIZE,U_CHAR,U_SHORT,U_INT,EMPTY,
}UNION_TYPE;

typedef struct Node
{
    UNION_TYPE type;

    union un
    {
        void* p;
        char c;
        int i;
        short sh;
        float f;
        double d;


        unsigned char uc;
        unsigned short ush;
        unsigned int ui;

        size_t size;

    }un;
}Node;

这个可以试试做个基本的结构体~~

[此贴子已经被作者于2017-5-27 00:14编辑过]

联合的成员使用的是同一个空间呀，释放 int* 占用的空间 和释放　void *是一样的啊。


继续被NULL指针虐，不搞了，睡觉。以后再慢慢来。

太久不写代码，好生疏，我怀疑我现在还能不能写出一个程序

[此贴子已经被作者于2017-5-26 23:48编辑过]

端午回家~

游戏编程对接受离散信息的加工处理要用到傅里叶变换这方面的知识~表示消化这块是一个漫长的过程~还是先看看怎么样处理简单的图层结构问题~

简单来说图层就是一个区域的多元信息参数~例如推箱子里面箱子的位置和目的地的位置可以叠加(刚开始用"重合"这个词~后来感觉用"叠加"表示更恰当)~表示在不同的图层里面~而人的位置和箱子的位置不能叠加~表示在同一个图层里面~


多元信息储存空间是可以变换的~可以通过一种映射找到元和其值的关系~

例如如果图层参数只用表示0或1来表示有或无的时候可以用二次方指数来标记各信息参数~这样可以通过其值的唯一组合来推测出该域到底储存了什么信息~不过考虑到不是所有信息都在不同的图层里面~单位信息参数值还可以通过其图层结构进行优化~

[此贴子已经被作者于2017-5-28 08:06编辑过]

给一个简单的小练笔~怎么用一个16位数来记录一个俄罗斯方块的信息~~感觉这是处理信息问题的基础~~
如果要表示方向则可以用32位来表示(记得公开课是用一个char表示方向~或许这样会简单一点)~

[此贴子已经被作者于2017-5-28 09:11编辑过]

写了个输入处理文件~这个可以防止输入数据出错而引发bug~不过是用动态处理的~~用完后记得释放空间~~~

#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_UN_Int(char** );   //输入长无符号整数
void Absorb_Buffer(char** );  //对缓冲区残留数据进行处理

void Input_UN_Int(char** p)                //初始化数据
{
    char* pt=NULL;
    size_t length=0;

    pt=*p=(char* )malloc((BUFF_MAX)*sizeof(char));
    assert(*p!=NULL);
    memset(*p,0,sizeof(pt));

    while (isdigit(*pt=getchar()))
    {
        ++length;
        if (length%(BUFF_MAX-1)==0)
        {
            assert(realloc(*p,(length+BUFF_MAX)*sizeof(char)));
            memset(*p+length,0,BUFF_MAX*sizeof(char));

            pt=*p+length-1;
        }

        ++pt;
    }

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

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

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

    free(*p);
    *p=strdup("");
}

#undef BUFF_MAX

#endif  

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

    Input_UN_Int(&p1);
    Input_UN_Int(&p2);

    puts(p1);
    puts(p2);

    free(p1);
    free(p2);

    return 0;
}

[此贴子已经被作者于2017-5-28 21:56编辑过]

这里你错啦。

            realloc(*p,(length+BUFF_MAX)*sizeof(char));//realloc失败会返回NULL，但作为参数的p,是无影响的。
            assert(*p);//所以你断言 p != NULL 是多余的。