泛型值初始化分配器

Question

Messing around with / learning C. I want a one-liner for moving stack values into the heap and this is the best I could come up with.

#define defheapify(nm, T, sz) \
  T* heapify_##nm (const T x) { \
    T *nx = malloc(sz); \
    nx[0] = x; \
    return nx; \
  }

defheapify(char, char, sizeof(char));
defheapify(uchar, unsigned char, sizeof(unsigned char));
defheapify(short_int, short int, sizeof(short int));
defheapify(ushort_int, unsigned short int, sizeof(unsigned short int));
defheapify(int, int, sizeof(int));
defheapify(uint, unsigned int, sizeof(unsigned int));
defheapify(long_int, long int, sizeof(long int));
defheapify(ulong_int, unsigned long int, sizeof(unsigned long int));
defheapify(long_long_int, long long int, sizeof(long long int));
defheapify(ulong_long_int, unsigned long long int, sizeof(unsigned long long int));
defheapify(float, float, sizeof(float));
defheapify(double, double, sizeof(double));
defheapify(long_double, long double, sizeof(long double));

It seems to work:

  short int *si = heapify_short_int(20);
  printf("%d\n", ((int*)si)[0]); /* => 20 */

Is there a better way to accomplish this?

Answer 1

Since this is C:

void * heapify (const void *p, size_t sz) {
    void *x = malloc(sz);
    if (x) memcpy(x, p, sz);
    return x;
}

Then, if you insist:

#define defheapify(nm, T, sz) \
T* heapify_##nm (const T x) { return heapify(&x, sz); }

But, sz is redundant if you have T , so:

#define defheapify(nm, T) \
T* heapify_##nm (const T x) { return heapify(&x, sizeof(x)); }

However, if you are only ever concerned about the types you listed in your question, you can use a _Generic switch instead and simplify your interface. With the code below, you can remove the task of figuring out the type of the variable or constant you are dealing with. Just always call heapify_any .

#define heapify_T(T, X) \
(T *)heapify(&(struct{ T x; }){X}.x, sizeof(T))

#define heapify_G(T, X) T:heapify_T(T, X)

#define heapify_any(X) _Generic( \
X, \
heapify_G(_Bool, X), \
heapify_G(char, X), \
heapify_G(signed char, X), \
heapify_G(unsigned char, X), \
heapify_G(short int, X), \
heapify_G(unsigned short int, X), \
heapify_G(int, X), \
heapify_G(unsigned int, X), \
heapify_G(long int, X), \
heapify_G(unsigned long int, X), \
heapify_G(long long int, X), \
heapify_G(unsigned long long int, X), \
heapify_G(float, X), \
heapify_G(double, X), \
heapify_G(long double, X), \
default:(void)0 \
)

There is no such thing as a literal short (or char or _Bool ) value in C, so you would need a variable or a cast to use the heapify_any macro above.

short int *si = heapify_any((short)20);
printf("%hd\n", *si);

Try it online!