Динамическая типизация C

Преамбула

Эта статья была написана и опубликована мной на своем сайте более десяти лет назад, сам сайт с тех пор канул в лету, а я так и не начал писать что-то более вразумительное в плане статей. Все ниже описанное является результатом исследования C как языка двадцатилетним парнем, а, следовательно, не претендует на звание учебного пособия, несмотря на стиль изложения. Тем не менее, я искренне надеюсь, что она побудит молодых разработчиков погрузиться в эксперименты с C также, как когда-то делал это я.

Предупреждение

Эта короткая статья, окажется абсолютно бесполезной для опытных программистов C/C++, но кому-то из начинающих, возможно, позволит сэкономить время. Хочу подчеркнуть, что в большинстве хороших книг по C/C++ данная тема рассмотрена в достаточной степени.

Динамическая и статическая типизация

Во многих интерпретируемых языках используется динамическая типизация. Такой подход позволяет хранить в переменной с одним именем значения разных типов. В языке C используется статическая типизация, что, на мой взгляд более, чем правильно. Однако бывают случаи (хоть и не так часто), когда гораздо удобней было бы использовать динамическую типизацию. Зачастую, такая потребность напрямую связана с некачественным проектированием, но не всегда. Не зря же в Qt присутствует тип QVariant.

Здесь мы поговорим про язык C, хотя все, что описано ниже, применимо и к C++.

Магия указателя пустоты

На самом деле, никакой динамической типизации в C нет и быть не может, однако существует универсальный указатель, тип которому void *. Объявление переменной такого типа, скажем, в качестве аргумента функции, позволяет передавать в нее указатель на переменную любого типа, что может быть крайне полезно. И вот он — первый пример:

#include <stdio.h>

int main()
{
	void *var;
	int i = 22;
	var = &i;
	int *i_ptr = var;

	if(i_ptr)
		printf("i_ptr: %d\n", *i_ptr);

	double d = 22.5;
	var = &d;
	double *d_ptr = var;

	if(d_ptr)
		printf("d_ptr: %f\n", *d_ptr);

	return 0;
}

Вывод:

i_ptr: 22
d_ptr: 22.500000

Здесь мы одному и тому же указателю присвоили указатели (простите за тавтологию) как на тип int, так и на double.

Первый пример не нес никакой полезной нагрузки. Попробуем ее поискать во втором примере:

#include <stdio.h>
#include <math.h>

int lilround(const void *arg, const char type)
{
	if(type == 0) // если передан int
		return *((int *)arg); // просто возвращаем значение целого аргумента
	// если передан double
	return round(*(double *)arg); // округляем
}

int main()
{
	int i = 12;
	double j = 12.5;

	printf("round int: %d\n", lilround(&i, 0)); // пытаемся округлить целое число
	printf("round double: %d\n", lilround(&j, 1)); // пытаемся округлить число двойной точности

	return 0;
}

Вывод:

round int: 12
round double: 13

Здесь мы создали, можно сказать, универсальную функцию для округления как целых чисел (которым оно не требуется, конечно), так и для чисел двойной точности. Следует понимать, что функция может выполнять и что-то более полезное, в зависимости от типа аргумента.

Альтернативная реализация функции lilround():

int lilround(const void *arg, const char type)
{
    return type == 0 ? *((int *)arg) : round(*((double *)arg));
}

Но для того, чтобы функция знала — с чем имеет дело — мы передаем в нее второй аргумент. Если он равен 0, то первый интерпретируется как указатель на int, если нет — как указатель на double. Такой подход может во многих случаях сгодиться, но, в основном, смысл использования универсального указателя как раз-таки в том, чтобы не указывать тип передаваемого параметра.

Предположим, что у нас две или более структур (struct), которые содержат различный набор полей. Но так уж получилось, что нужно передать их одной и той же функции. Почему так вышло рассуждать не будем.

Что же делать? Ответ почти очевиден: передавать их в виде указателя неопределенного типа. И, все ничего, но как же тогда наша функция узнает об их типе? Все просто: в самое начало структуры добавим поле type, в которое будем записывать идентификатор структуры, по которому наша функция и будет определять ее тип, предварительно приведя неопределенный указатель к любой из структур. Идентификатором может быть поле любого типа, хоть еще одна структура, но оно должно стоять первым в каждой из структур и иметь один и тот же тип. Такое условие следует из способа расположения структур в памяти компьютера. Если написать так:

typedef struct {
	char type;
	int value;
} iStruct;

typedef struct {
	char type;
	double value;
} dStruct;

То все сработает корректно. Но если написать так:

typedef struct {
	char type;
	int value;
} iStruct;

typedef struct {
	double value;
	char type;
} dStruct;

То программа соберется, но во время работы выдаст неверный вариант, так как, в зависимости от того — к какой структуре приведем указатель, в случае обращения программа попытается считать первый байт из double value или, вообще, неизвестно откуда.

А вот и пример использования такого подхода:

#include <stdio.h>
#include <math.h>

#pragma pack(push, 1)
typedef struct {
	char type; // идентификатор типа структуры
	int value; // целочисленное значение
} iStruct;
#pragma pack(pop)

#pragma pack(push, 1)
typedef struct {
	char type; // идентификатор типа структуры
	double value; // значение двойной точности
} dStruct;
#pragma pack(pop)

int lilround(const void *arg)
{
	iStruct *s = (iStruct *)arg;
	if(s->type == 0) // если передан int
		return s->value; // просто возвращаем значение целого аргумента
	// если передан double
	double a = ((dStruct *)arg)->value;
	
	return round(a); // округляем
}

int main()
{
	iStruct i;
	i.type = 0;
	i.value = 12;

	dStruct j;
	j.type = 1;
	j.value = 12.5;

	printf("round int: %d\n", lilround(&i)); // пытаемся округлить целое число
	printf("round double: %d\n", lilround(&j)); // пытаемся округлить число двойной точности
	return 0;
}

Примечание: директивы компилятора #pragma pack(push, 1) и #pragma pack(pop) необходимо помещать до и после каждой специфической структуры, соответственно. Данная директива используется для выравнивания структуры в памяти, что обеспечит корректность метода. Однако не стоит также забывать о порядке полей.

В теле функции аргумент приводится к структуре iStruct и проверяется значение поля type. Дальше уже аргумент приводится к другому типу структуры, если нужно.

Перед тем, как перейти к последней части, стоить пояснить работу с простыми void-указателями. Сложение, вычитание, инкремент, декремент и т.д. запрещены для типа void, поэтому необходимо сперва привести аргумент к нужному типу, а уж затем совершать операцию:

#include <stdio.h>

int main()
{
	int i = 22;
	void *var = &i; // объявляем void-указатель и инициализируем его адресом переменной i
	(*(int *)var)++; // приводим void-указатель к int-указателю, разыменовываем его и производим операцию инкремента

	printf("result: %d\n", i); // выводим измененное значение i

	return 0;
}

Исходя из кода: для совершения операции необходимо записать (*(int *)var) и уже к данной записи применить требуемый оператор.

Подобие интерфейсов в C

Вернемся к структурам. Если структура "засылается" далеко и глубоко в код, возможно даже чужой, то имеет смысл передать вместе с ней и методы, которые будут обрабатывать ее значения. Для этого создадим дополнительную структуру, которая заменит поле type:

typedef struct {
	void (*printType)(); // указатель на функцию, выводящую тип
	int (*round)(const void *); // указатель на функцию, округляющую значение
} uMethods;

Опишем реализации указанных выше функций для разных типов структур, а также — функции инициализации. Результат ниже:

#include <stdio.h>
#include <math.h>

typedef struct {
	void (*printType)(); // указатель на функцию, выводящую тип
	int (*round)(const void *); // указатель на функцию, округляющую значение
} uMethods;

#pragma pack(push, 1)
typedef struct {
	uMethods m; // структура с указателями на функции
	int value; // целочисленное значение
} iStruct;
#pragma pack(pop)

#pragma pack(push, 1)
typedef struct {
	uMethods m; // структура с указателями на функции
	double value; // значение двойной точности
} dStruct;
#pragma pack(pop)

void intPrintType() // вывод типа для iStruct
{
	printf("integer\n");
}

int intRound(const void *arg) // округление для iStruct
{
	return ((iStruct *)arg)->value; // приводим аргумент к указателю на iStruct и возвращаем значение
}

void intInit(iStruct *s) // инициализация iStruct
{
	s->m.printType = intPrintType; // задаем полю printType указатель на функцию вывода для iStruct
	s->m.round = intRound; // задаем полю round указатель на функцию округления для iStruct
	s->value = 0;
}

void doublePrintType() // вывод типа для dStruct
{
	printf("double\n");
}

int doubleRound(const void *arg) // округление для dStruct
{
	return round(((dStruct *)arg)->value);
}

void doubleInit(dStruct *s)
{
	s->m.printType = doublePrintType; // задаем полю printType указатель на функцию вывода для dStruct
	s->m.round = doubleRound; // задаем полю round указатель на функцию округления для dStruct
	s->value = 0;
}

int lilround(const void *arg)
{
	((iStruct *)arg)->m.printType(); // приводим к любой структуре, в данном случае iStruct, и выводим тип
	return ((iStruct *)arg)->m.round(arg); // возвращаем округленное значение
}

int main()
{
	iStruct i;
	intInit(&i); // инициализируем целочисленную структуру
	i.value = 12;

	dStruct j;
	doubleInit(&j); // инициализируем структуру с данными двойной точности
	j.value = 12.5;

	printf("round int: %d\n", lilround(&i)); // пытаемся округлить целое число
	printf("round double: %d\n", lilround(&j)); // пытаемся округлить число двойной точности

	return 0;
}

Вывод:

integer
round int: 12
double
round double: 13

Примечание: директивами компилятора следует обрамлять только те структуры, которые необходимо использовать в качестве аргумента для void-указателя.

Заключение

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

UPD.: Спасибо модераторам хабра за указания на опечатки и досадные ошибки исходной версии текста.

UPD.: Спасибо mastan за то замечание по поводу усложненного некорректного округления, хоть это и не относится к теме статьи, все же, лучше исправить на использование round() из math.h. Также была перефразирована часть про арифметику с void (не void *) благодаря замечанию eanmos. При помощи разбора кода со стороны sergio_nsk код в статье стал более читаем и лишился спорной части с неподтвержденным примечанием.