Почему дополнительные параметры должны появиться в конце объявления

Дополнительные параметры в конце позволяют вам прекратить указывать параметры в какой-то момент, например

void Test(int a, optional int b = 0, optional int c = 0) { ... } 

Test(3);

Если вы сделаете c обязательным параметром, вам придется использовать такой синтаксис:

Test(3, , 2);
Test(a := 3, c := 2);

Преимущество необязательного параметра в том, что его можно рассматривать так, как если бы это не было ' т там . Если необязательные параметры находятся в середине списка параметров, это невозможно без «подсчета запятых» или использования чрезмерно подробного синтаксиса.

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

Это прекрасно работает в Ruby:

def foo(m1, m2, o1='o1', o2='o2', *rest, m3, m4)
  return m1, m2, o1, o2, rest, m3, m4
end

foo(1, 2, 3, 4)
# => [1, 2, 'o1', 'o2', [], 3, 4]

foo(1, 2, 3, 4, 5)
# => [1, 2, 3, 'o2', [], 4, 5]

foo(1, 2, 3, 4, 5, 6)
# => [1, 2, 3, 4, [], 5, 6]

foo(1, 2, 3, 4, 5, 6, 7)
# => [1, 2, 3, 4, [5], 6, 7]

foo(1, 2, 3, 4, 5, 6, 7, 8)
# => [1, 2, 3, 4, [5, 6], 7, 8]

Все обязательные аргументы должны быть предоставлены:

foo(1, 2, 3)
# => ArgumentError: wrong number of arguments (3 for 4)

Без остального параметра предоставление большего количества аргументов, чем число_обязательных + число_опциональных, является ошибкой:

def bar(m1, m2, o1='o1', o2='o2',  m3, m4)
  return m1, m2, o1, o2, m3, m4
end

bar(1, 2, 3, 4, 5, 6, 7)
# => ArgumentError: wrong number of arguments (7 for 6)

Обязательные параметры в начале списка параметров связываются слева направо от начала списка аргументов. Обязательные параметры в конце списка параметров привязываются справа налево от конца списка аргументов. Необязательные параметры привязываются слева направо от начала оставшегося списка аргументов. Все оставшиеся аргументы привязываются к остальным аргументам.

Рассмотрим такое объявление, как:

int foo(float a, int b=0, int c=0, float d);

(обратите внимание, как я определил параметры по умолчанию в середине списка), которое впоследствии вызывается как

foo(0.0,1,2.0)

Что это за вызов? В частности, b или c были опущены?

Разработчики компилятора могут обойти это, используя именованные параметры

foo(a=0,c=0,d=2.0)

, например, функцию, доступную в Python.

Просто гадаю на досуге: Возможно, это как-то связано с конвенциями вызова (например, параметры заталкиваются в стек слева направо, необязательные параметры просто опускаются, если они не были указаны).

Java и C # не имеют именованных параметров, поэтому вы не можете этого сделать:

myfunction(param1='Meh', optionalParam=2)

Вы должны сделать:

myfunction('Meh', 2)

В противном случае

myFunction(2, 'Meh')

неоднозначно. Как компилятор должен знать, что вы имели в виду, что 2 должны быть в наборе необязательных параметров?