Преобразование типов против неоднозначности типов

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

Скажем, я определяю постоянную переменную:

static const a = 5;

Теперь, что такое "а"? Попробуй еще раз...

static const max_number_of_buttons = 5;

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

void func(char a)
{
    char b;
    b = a;
    p = b * 3;
    g = a - 7;
}

Используя правильные соглашения об именах, и вы знаете, являются ли p и g локальными переменными, параметрами функции, переменными членами или глобальными переменными. (Эта функция очень мала, поэтому у вас есть идея, представьте себе функцию из 1000 строк кода [я видел их], после пары страниц вы понятия не имеете, что и как часто вы будете теневыми переменными таким образом, чтобы они действительно трудно отлаживать...)

void func(char a)
{
    char b;
    b = a;
    g_p = b * 3;
    f_g = a - 7;
}

Мое личное соглашение - добавить g_ для глобальных переменных и f_ для переменных членов. На данный момент я не различаю локальные и переменные параметров... хотя вы могли бы написать p_a вместо a только для параметра, и теперь вы знаете все переменные типы.

Хорошо, так что это имеет смысл в отношении неоднозначности имен переменных, хотя в вашем случае вы конкретно спрашиваете о типах. Посмотрим...

Ада известна своей очень сильной типизацией переменных. Например:

type a is 1 .. 100;
type b is 1 .. 100;

A: a;
B: b;

A := 5;
B := A;

Последняя строка НЕ компилируется. Хотя типы a и type b выглядят одинаково, компилятор рассматривает их как разные числовые типы. Другими словами, он достаточно ясен. Чтобы заставить его работать в Ada, вам нужно нажать A следующим образом:

B := B'(A);

То же самое в C/C++, вы объявляете два типа и переменных:

typedef int a;
typedef int b;

a A;
b B;

A = 5;
B = A;

Это работает как в C/C++, потому что тип a и тип b считаются точно такими же (int, хотя вы дали им имена a и b). Это очень НЕ ясно. Итак, пишу что-то вроде:

A = (b) 5;

явным образом скажу вам, что вы считаете, что 5 по типу b и преобразовать его (неявно) в тип a в присваивании. Вы также можете написать его таким образом, чтобы быть полностью явным:

A = a(b(5));

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

Теперь есть способ сгладить эту проблему в C/C++, хотя она почти никогда не используется, вы можете использовать класс для каждого объекта, включая числа. Тогда у вас будет определенный тип для каждого другого типа (потому что переменные класса A и класса B нельзя смешивать вместе, по крайней мере, если вы не позволите это, добавив функции для этой цели.) Очень откровенно, даже я этого не делаю что, поскольку было бы слишком много работы, чтобы написать любую программу на любой длине...

Так, как сказал Джури: 3.0 и (double) 3.0 - это точно одно и то же, и (двойное) литье является избыточным (pleonasm, как и вы говорите то же самое дважды). Тем не менее, это может помочь парню, который приходит позади вас, видеть, что вы действительно имели в виду, что это число должно быть двойным, а не то, что говорит этот язык.