C++ 向上强制转换C中的数值类型总是可逆的吗

编辑:哦，天哪，我觉得自己很傻.当然，你不能从多头投掷到双打，而回头投球有更重要的部分.投出长双打会改善这一点吗？

我正在用C实现一个数组列表，我希望它是类型不可知的.我也不希望它在用法上如此冗长，因此我希望我的GET函数不返回空指针，并且需要用户进行类型转换.因此，我为该类型存储一个枚举(每个列表一个类型)，它可以是int、Float、Long或Double.参数作为Double传递(因此，如果您传递int、Float或Long，编译器将隐式强制转换)，然后根据列表中存储的数据类型，传递的Double将被强制转换为正确的类型.这会一直奏效吗？一个数字，转换为双精度型，然后返回到其原始类型，会有不同的值吗？这个最重要的 idea 还有其他问题吗？基本实现如下

#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <signal.h>

typedef enum{
    INT,
    LONG,
    FLOAT,
    DOUBLE
}TYPE;

typedef struct arrayList{
    void * data;
    TYPE type;
    size_t capacity;
    size_t num_elements;
}arrayList;

void reallocateArrayList(arrayList * list, size_t capacity){
    TYPE type=list->type;
    if(type == INT){
        void * toAllocate = malloc(capacity*sizeof(int));
        memcpy(toAllocate, list->data, list->num_elements*sizeof(int));
        if(list->data!=NULL){
            free(list->data);
        }
        list->data = toAllocate;
    }
    if(type == FLOAT){
        void * toAllocate = malloc(capacity*sizeof(float));
        memcpy(toAllocate, list->data, list->num_elements*sizeof(float));
        if(list->data!=NULL){
            free(list->data);
        }
        list->data = toAllocate;
    }
    if(type==LONG){
        void * toAllocate = malloc(capacity*sizeof(long));
        memcpy(toAllocate, list->data, list->num_elements*sizeof(long));
        if(list->data!=NULL){
            free(list->data);
        }
        list->data = toAllocate;
    }
    if(type==DOUBLE){
        void * toAllocate = malloc(capacity*sizeof(double));
        memcpy(toAllocate, list->data, list->num_elements*sizeof(double));
        if(list->data!=NULL){
            free(list->data);
        }
        list->data = toAllocate;        
    }
    list->capacity=capacity;
    if(list->data==NULL) raise(ENOMEM);
}

arrayList * createArrayList(TYPE type){
    arrayList * retval = (arrayList *) malloc(sizeof(arrayList));
    retval->capacity=256;
    retval->data = NULL;
    retval->type = type;
    retval->num_elements = 0;
    reallocateArrayList(retval, 256);
    return retval;

}

void add(arrayList * list, double val){
    if(list->capacity<=list->num_elements){
        reallocateArrayList(list, 4*list->capacity);
    }
    TYPE type=list->type;
    if(type == INT){
        ((int *)(list->data))[list->num_elements]=(int) val;
    }
    if(type == FLOAT){
        ((float *)(list->data))[list->num_elements]=(float) val;
    }
    if(type==LONG){
        ((long *)(list->data))[list->num_elements]=(long) val;

    }
    if(type==DOUBLE){
    ((double *)(list->data))[list->num_elements]=val;
    }
    list->num_elements++;
}

double get(arrayList * list, size_t index){
    double retval;
    if(index>=list->num_elements){
        printf("Error: arrayList get index out of range");
        raise(SIGSEGV);
    }
    if(list->type==INT){
        retval=((int*)(list->data))[index];
    }
    if(list->type==FLOAT){
        retval=((float*)(list->data))[index];
    }
    if(list->type==LONG){
        retval=((long*)(list->data))[index];
    }
    if(list->type==DOUBLE){
        retval=((double*)(list->data))[index];
    }
    return retval;
}