这样长度不同还是没有普片性~~还是建议使用时每个数组的一维长度要一致~因为强制转型的时候数组长度参数不能带有变量~~这也说明了某些编译器在处理数组长度方面的时候不是在编译过程中处理的~而是在预编译的时候处理的(这也是为什么一些老式编译器数组长度大小不能为变量的原因)~~~

顺带一句~sizeof 得出来的是常量~~是在预编译的时候已经转换成机器指令的常量~所以在编译过程中同一个sizeof的值是不会发生变化的~~~

PS:这种方法的适应度感觉还是不高~原因在于运算数据的转型是一个常量而不是变量所以如果要读取多维数据的话……还是要调用多维参数作为变量并在读取数据进行一维运算~如果数据类型不同就要调用数据单位长度参数作为变量获取内存数据~

所以得出结论就是本来就没有"维度"这个概念~有的只是数据类型影响影响指针偏移量~读取指针地址似乎是在读取"维度空间"~实际上是对数据进行转型并读取其中内容~所以如果要进行一些通用化操作就要进行"原子尺度"上的操作--既以字节为单位读取或者修改数据~所以如果要对多维数据进行定位的时候~除了用默认定义的变量类型或者强制转型的方法外~通用的方法就是对读取数据传入参数进行定位……~~~这样就意味着储存数据本身就没有数据类型这个概念~就光是一个值(不管那个储存值是什么)~~数据类型的作用只是存取或者修改的过程中对数据执行机器指令的处理~

还有一点值得一提~每个地址都对应一个值~每个值都对应一个地址(注意~地址本身是常量)~所以这样理解的话就不存在"地址级数"问题~所以*p的值有两种情况~一种是还是地址值(例如二维数组)~~另一种就是地址里面的储存内容(注意这里的"内容"可能是一个地址的"值"--例如二重指针)~~至于*p读取的是地址还是内容就要看*p的数据类型是否具有数组属性了~所以虽然指针虽然具有数组属性~但却不具备"长度"属性~~所谓对"长度"的理解有两点--第一点就是在长度作用范围之内的数据受"保护"(既不会被系统非法占用或改写)第二点就是读取地址的行为是以"地址"的形式而非"储存值"的形式---这样看的话int a[1]和int a看上去数据类型和占用单元都一样~但实际上前者具备"数组"属性而后者不具备~所以前者读取a的值是地址而后者是储存值~

所以数组合和指针是有一定区别的~~~~

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

今天自己帮休息一下~~~~~

无意闲逛看了一个神级别的平方根倒数速算法~看过这个算法挺闻名的~不过理解上来就~~~~~

float InvSqrt(float x)

{

    float xhalf = 0.5f*x;

    int i = *(int*)&x; // get bits for floating VALUE

    i = 0x5f375a86- (i>>1); // gives initial guess y0

    x = *(float*)&i; // convert bits BACK to float

    x = x*(1.5f-xhalf*x*x); // Newton step, repeating increases accuracy

    return x;

}

反正现阶段我也没有去怎么消化~有兴趣的可以看看这方面的资料~~~

PS:我这个也是摘抄回来的~或许会搜到其它类似算法和这个有点出入~记得还有几个类似的版本~有兴趣的可以去了解一下~~~

[此贴子已经被作者于2017-5-24 18:10编辑过]

无意闲逛~发现了一个很好玩的宏~看来我那个通用链表可以改进一下了~去查查offsetof宏的相关用法也好~

#include<stdio.h>
#include<stddef.h>
typedef struct Node
{
    int a[10];
    double b;
    char c;
}Node;
int main()
{
    Node node={0};
    
    printf("%d\n",offsetof(Node,a));
    printf("%d\n",offsetof(Node,b));
    printf("%d\n",offsetof(Node,c));
    
    return 0;
}

关键是a不能单独成为一个变量~这是一个实际应用问题~感觉这用法有点独特~~如果可以写成node.a则可以当一个完整的变量调用了~~

突然知道匿名指针是怎么回事了~就是指向一个地址加偏移量……是用来实现泛型的……其实可以自己开个内存块里面存放各种不同类型的数据~感觉结构体就是类似于这种结构而且还多个结构体成员作为引用接口……在堆空间里面理论上其实是可以用开辟内存空间附加一些引用方法来起到结构体效果的~~~

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


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

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

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

#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编辑过]