Значения массива, установленные в функции, работают правильно только для одного типа данных

Question

В этом фрагменте кода я пытаюсь поправиться с помощью арифметики указателей c и массивов. У меня есть функция, которая создает тип массива на основе того, что пользователь вводит (поэтому я и выбрал void * в качестве типа функции), а затем «скрывает» размер функции в месте с массивом [-1], поэтому всегда можно проиндексировать и иметь размер прямо там. Наконец, я приведу его как void и верну массив.

Он отлично работает с целыми числами, но без других типов данных.

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

void * createArray(int size, int soa)
{
int *array;
array = malloc(sizeof(int)+size*soa);
array[0] = size; array++;
return (void*)array;
}

int main(void)
{
int *array;
array = createArray(10, sizeof(int));
double *array2;
array2 = createArray(5, sizeof(double));
printf("%d\n", *(array-1));
printf("%f", *(array2-1));
}

Мой вывод: 10 0.000000

Итак, он правильно скрывает целое число, но что-то идет не так для всех других типов данных, и я в замешательстве. Любая помощь будет принята с благодарностью !!!

Answer 1

@ Azoros,

Ваш код работает для целых чисел, поскольку вы определяете тип указателя как целые числа. Когда вы определяете тип указателя как double, процессор попытается обработать каждый элемент как тип данных double. Внутренне целые и двойные числа хранятся в разных форматах. Вот почему, когда вы пытаетесь извлечь целочисленное значение из двойного типа данных, оно не работает.

Итак, если я правильно понимаю вашу проблему, вы хотите, чтобы массив с нулевым элементом определялся как целое число, которое содержит длину массива. Остальные элементы должны содержать значения данных, которые могут быть другого типа, чем первый элемент.

Я бы подошел к этой проблеме, определив указатель массива как байтовый массив (void *). Затем при доступе к элементам я просто скажу процессору, с каким типом данных он имеет дело.

Вот как это делается на практике:

Измените определение указателя на указатель байта.

void* array;

Выделите массив по размеру, который включает как элемент длины массива, так и элементы данных.

array = calloc(1, INT_SIZ + (noe * soe));

Переместите значение размера в первую позицию массива. Обратите внимание, что на машине Windows x86 это скопирует 4 байта данных.

memcpy(array, (void*)&noe, INT_SIZ);

Возвращает смещение адреса памяти на размер первого элемента. На компьютере x86 это будет смещено на 4 байта

return (void*)(((int*)(array)) + 1);

Здесь полный код, который использует модифицированную процедуру createArray.

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

# define INT_SIZ sizeof(int)
# define GetSize( pt ) ((int *)pt)[-1]
# define GetElement( pt, etype, idx ) ((etype *)pt)[idx]
# define InsertElement( pt, etype, idx, val ) \
  { \
     etype temp = val; \
     memcpy ( (void *) &((etype *)pt)[idx], &temp, sizeof(etype) ); \
  }



void * createArray(int noe,  /* Number of elements */
                   int soe)  /* Size of element */
{
   void *array;

   /* Allocate the array */    
   array = calloc(1, INT_SIZ + (noe * soe));
   if ( array == NULL ) return NULL;

   /* Copy the integer value representing the number of elements to the first
      element in the array */
   memcpy ( array, (void *) &noe, INT_SIZ );


   /* Return the pointer value offset by the size of an int */
   return (void *) (((int *)(array))+1);
}


int main(void)
{
   void *array;
   int i=0;

   array = createArray(10, sizeof(int));
   InsertElement ( array, int, 0, 65534 );

   printf("%d\n",  *(int *)( ((int *)(array)) - 1) );  /* pointer syntax */
   printf("%d\n",  ((int *)array)[-1]  );              /* array syntax   */
   printf("%d\n",  GetSize(array)  );
   printf ( "Element #%d: %d\n", 0, GetElement ( array, int, 0 ) );

   puts ( "\nDemonstrating Array of Doubles --------------------------------");
   array = createArray(10, sizeof(double));
   InsertElement ( array, double, 0, 3.0 );
   InsertElement ( array, double, 1, 3.1 );
   InsertElement ( array, double, 2, 3.2 );

   printf("Array size: %d\n",  GetSize(array)  );
   for ( i=0; i<3; i++ )
      printf ( "Element #%d: %lf\n", i, GetElement ( array, double, i ) );

   free ( ((int *)(array))-1 );
}

Вот вывод:

10
10
10
Element #0: 65534

Demonstrating Array of Doubles --------------------------------
Array size: 10
Element #0: 3.000000
Element #1: 3.100000
Element #2: 3.200000

Замечания по поводу кода

1. Массив обрабатывается как массив с нулевым основанием, как и любой другой массив C.
2. Хотя в процедуре, Я добавил проверку, чтобы увидеть, была ли выделена память, аналогичные проверки должны выполняться любыми вызывающими подпрограммами createArray.
3. Были добавлены определения макросов, чтобы сделать код более читабельным.