Передача аргументов в функцию - позиционные vs именованные - Компьютерные священные войны

Здравствуйте, Sinclair, Вы писали:

S>>Какой вариант вам удобнее?
S>Если в функции — сорок параметров, из которых 38 необязательные, то именованные удобнее. Если в функции — два параметра, и оба обязательные, то удобнее позиционные.
S>Ваш К.О.

Тут еще момент. Если два параметра и оба одного типа — как то два int — то в случае позиционных нужно держать в голове порядок. А зачем держать, если можно не держать?

Здравствуйте, Shmj, Вы писали:

S>Тут еще момент. Если два параметра и оба одного типа — как то два int — то в случае позиционных нужно держать в голове порядок. А зачем держать, если можно не держать?

Нормальные имена переменным задавать не пробовал?
Лично мне после передачи полутора десятков аргументов на фортране именованные параметры не очень и нужны.

Здравствуйте, Shmj, Вы писали:

S>Тут еще момент. Если два параметра и оба одного типа — как то два int — то в случае позиционных нужно держать в голове порядок. А зачем держать, если можно не держать?
Зачем заниматься умозрительными рассуждениями, когда можно просто попробовать написать код?
Практика — критерий истины:

var d = sub(sqr(b), mul(4, mul(a, c)));
if(d >= 0)
{
  var x1 = div(sub(neg(b), sqrt(d)), mul(2, a));
  var x2 = div(sum(neg(b), sqrt(d)), mul(2, a));
  Console.WriteLine("Solutions are {x1} and {x2}", x1, x2);
}

var d = sub(minuend = sqr(base = b), subtrahend = mul(multiplier=4, multiplicand = mul(multiplier = a, multiplicand = c)));
if(d >= 0)
{
  var x1 = div(dividend = sub(minuend = neg(subtrahend = b), subtrahend = sqrt(power = d)), divisor = mul(multiplier = 2, multiplicand = a));
  var x2 = div(dividend = sum(augend = neg(subtrahend = b), addend = sqrt(power = d)), divisor = mul(multiplier = 2, multiplicand = a));
  Console.WriteLine(formatString = "Solutions are {0} and {1}", zeroethArg = x1, firstArg = x2);
}

Какая из записей вам более понятна? Кстати, во втором варианте есть супербонус — можно же менять порядок аргументов. Как говорится, spot an error:

var d = sub(minuend = sqr(base = b), subtrahend = mul(multiplier=4, multiplicand = mul(multiplier = a, multiplicand = c)));
if(d >= 0)
{
  var x1 = div(dividend = sub(subtrahend = sqrt(power = d), minuend = neg(subtrahend = b)), divisor = mul(multiplier = 2, multiplicand = a));
  var x2 = div(divisor = mul(multiplier = 2, multiplicand = a), dividend = sum(augend = neg(subtrahend = b), addend = sqrt(power = d)));
  Console.WriteLine(formatString = "Solutions are {0} and {1}", firstArg = x1, zeroethArg = x2);
}

Здравствуйте, Sinclair, Вы писали:

S>Здравствуйте, Shmj, Вы писали:

S>>Тут еще момент. Если два параметра и оба одного типа — как то два int — то в случае позиционных нужно держать в голове порядок. А зачем держать, если можно не держать?
S>Зачем заниматься умозрительными рассуждениями, когда можно просто попробовать написать код?

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

wl.>В принципе CLion показывает, как называются параметры. По мне так это даже лучше, чем вручную именованные параметры набивать:

wl.>[img]
wl.>https://files.rsdn.org/69309/clion.png
wl.>[/img]

тоже самое делает vscode c clangd плагином

S>Если порядок аргументов изменился, то не нужно по всему коду выискивать и исправлять.
а если изменилось имя аргумента?

Здравствуйте, Shmj, Вы писали:

S>Вот стандартная практика — как бы по порядку. Т.е. через запятую последовательно.

S>А ведь есть более умные решения: именованные аргументы функции. Если порядок аргументов изменился, то не нужно по всему коду выискивать и исправлять.

S>Какой вариант вам удобнее?

Обычные позиционные аргументы эффективнее. Они просто кидаются в стек по-порядку с минимум накладных расходов. Или в случае __fastcall, вообще передаются в регистрах.

В случае же именнованных, надо как-то хранить соответствие имен и значений. В питоне, как я подозреваю, там dictionary передается.
В общем, не так уж и умно выходит. Надеюсь, ты не будешь злоупотреблять ими.

S>Какой вариант вам удобнее?

Который меньше буков при прочих равных.

Здравствуйте, jamesq, Вы писали:

J>Обычные позиционные аргументы эффективнее. Они просто кидаются в стек по-порядку с минимум накладных расходов. Или в случае __fastcall, вообще передаются в регистрах.

J>В случае же именнованных, надо как-то хранить соответствие имен и значений. В питоне, как я подозреваю, там dictionary передается.
J>В общем, не так уж и умно выходит. Надеюсь, ты не будешь злоупотреблять ими.

Если речь про питон, то там и позиционные параметры в виде list передаются.
А если про какой-нибудь C# то там всякая разница пропадает во время компиляции.
А в каком-нибудь С используются структуры, которые тоже замечательно на стеке хранятся.

С точки зрения производительности вообще непринципиально что использовать.

Здравствуйте, Muxa, Вы писали:

S>>Если порядок аргументов изменился, то не нужно по всему коду выискивать и исправлять.
M>а если изменилось имя аргумента?

То проект не соберётся и заставит исправлять ошибки. Тогда как, если поменялись местами аргументы одинакового типа, всё будет молчать.

Здравствуйте, Privalov, Вы писали:

P>Нормальные имена переменным задавать не пробовал?
P>Лично мне после передачи полутора десятков аргументов на фортране именованные параметры не очень и нужны.

И тут, вдруг, ты узнал, что твоим кодом пользуются люди, и делают ошибки. Не, нуачё, пусть внимательнее будут

S>>>Если порядок аргументов изменился, то не нужно по всему коду выискивать и исправлять.
M>>а если изменилось имя аргумента?
D>То проект не соберётся и заставит исправлять ошибки.
Для ТС это минус, я так понял — то что нужно лазить по всему коду и чот там исправлять.

Здравствуйте, Sinclair, Вы писали:

S>Какая из записей вам более понятна? Кстати, во втором варианте есть супербонус — можно же менять порядок аргументов. Как говорится, spot an error:
S>

S>var d = sub(minuend = sqr(base = b), subtrahend = mul(multiplier=4, multiplicand = mul(multiplier = a, multiplicand = c)));
S>if(d >= 0)
S>{
S>  var x1 = div(dividend = sub(subtrahend = sqrt(power = d), minuend = neg(subtrahend = b)), divisor = mul(multiplier = 2, multiplicand = a));
S>  var x2 = div(divisor = mul(multiplier = 2, multiplicand = a), dividend = sum(augend = neg(subtrahend = b), addend = sqrt(power = d)));
S>  Console.WriteLine(formatString = "Solutions are {0} and {1}", firstArg = x1, zeroethArg = x2);
S>}
S>

Чисто теоритически, язык может предоставить опции по совмещению подходов, как питон, например.

Здравствуйте, Doom100500, Вы писали:

D>Чисто теоритически, язык может предоставить опции по совмещению подходов, как питон, например.
Чисто практически, C# такие опции тоже предоставляет.
Речь-то шла не о том, что есть в языке, а чего нету. А о том, что удобнее использовать.

Здравствуйте, Muxa, Вы писали:

S>>Если порядок аргументов изменился, то не нужно по всему коду выискивать и исправлять.
M>а если изменилось имя аргумента?

Как, например, в примере выше:

sqrt(power = d))

неправильное именование, аргумент для sqrt -- это не power (степень), а просто некое число. Теперь везде переименовывать. А учитывая, что это функция, наверняка, стандартнобиблиотечная, то весь код, который её использует, во всём мире придётся обновлять.

Здравствуйте, Doom100500, Вы писали:

D>И тут, вдруг, ты узнал, что твоим кодом пользуются люди, и делают ошибки. Не, нуачё, пусть внимательнее будут

.

С Фортраном приходилось так или иначе быть внимательным. Материалов "Грабли в Фортране" было намного больше, чем "Как писать на Фортране". А "Фортран за 21 день" вообще не было.
Тогда было два способа передавать данные: либо через параметры, либо через COMMON-блоки. Именно тогда мы усвоили: за беспорядочное использование COMMON-блоков наду отрывать руки. Поэтому и передавали по десятку параметров. И за ними следили. Именно поэтому у меня не было проблем с использованием фортрановских библиотек, того же Графора.
Естественно, с переходом на Фортран-90 я и подпрограммы interface начал активно использовать, и implicit none. Но кода на старом добром Fortran IV было немало. И, по слухам, он всё ещё работает.
Позже мне этот опыт пригодился, когда я работал с Васиком на "Искре-226". У него вообще всё было очень сложно по части граблей. Но проект, в котором я участвовал, не содержал ни одной строчки говнокода. И был я как раз в роли тех людей, которые пользуются чужим кодом. Да, нужно было соблюдать правила гигиены, не писать как попало. Зато всё работало без сербёзных багов.
А на православной Java я и NPE мог пропустить, правда, всего один раз такое случилось.
В любом случае внимательным надо быть. IDE, конечно, здорово помогают. Но последнее слово всё равно за разработчиком. Потому как никакая IDE не предотвращает написание говнокода.

Здравствуйте, Sinclair, Вы писали:

S>Зачем заниматься умозрительными рассуждениями, когда можно просто попробовать написать код?
S>Практика — критерий истины:

S>

S>var d = sub(minuend = sqr(base = b), subtrahend = mul(multiplier=4, multiplicand = mul(multiplier = a, multiplicand = c)));
S>if(d >= 0)
S>{
S>  var x1 = div(dividend = sub(minuend = neg(subtrahend = b), subtrahend = sqrt(power = d)), divisor = mul(multiplier = 2, multiplicand = a));
S>  var x2 = div(dividend = sum(augend = neg(subtrahend = b), addend = sqrt(power = d)), divisor = mul(multiplier = 2, multiplicand = a));
S>  Console.WriteLine(formatString = "Solutions are {0} and {1}", zeroethArg = x1, firstArg = x2);
S>}
S>

S>Какая из записей вам более понятна?

Такой код нужно форматировать по-другому, выстраивая параметры в столбик:

    let d = sub ~minuend:    (sqr ~base: b)
                ~subtrahend: (mul ~multiplier:   4.
                                  ~multiplicand: (mul ~multiplier:   a
                                                      ~multiplicand: c))
    in
    if d >= 0. then
      let x1 = div ~dividend: (sub ~minuend:    (neg ~subtrahend: b)
                                   ~subtrahend: (sqrt ~number: d))
                   ~divisor:  (mul ~multiplier:   2.
                                   ~multiplicand: a)
      and x2 = div ~dividend: (add ~augend: (neg ~subtrahend: b)
                                   ~addend: (sqrt ~number: d))
                   ~divisor:  (mul ~multiplier:   2.
                                   ~multiplicand: a)
      in
      Printf.printf "Solutions are %.1f and %.1f\n" x1 x2

Не то что бы стало сопоставимо с обычными, позиционными функциями, но чуть проще понять структуру (вложенность).

Здравствуйте, Sinclair, Вы писали:

S>Здравствуйте, Shmj, Вы писали:

S>>Какой вариант вам удобнее?
S>Если в функции — сорок параметров, из которых 38 необязательные, то именованные удобнее. Если в функции — два параметра, и оба обязательные, то удобнее позиционные.
S>Ваш К.О.

(голосом удава) А три — это куча?

Я в одном проекте нашёл три или четыре места, где у memset() перепутали длину и заполнитель, а так в C++ это параметры оба целые, никакого плача от компилятора не было.

В итоге я выдвинул правку — сделать хелпер типа

class MemsetCaller {
  void *mAddress;
  size_t mLength;
public:
  MemsetCaller(void *address, size_t length) : mAddress(address), mLength(length) {}
  void fillWith(char c) { ::memset(mAddress, c, mLength); // сам проверял по ману когда это сейчас писал
  }
};

и все вызовы перекинул на MemsetCaller(a, len).fillWith('\xA5') и в таком же духе.

Это отличный пример, где принудительно именованные аргументы точно пригодились бы.

UPD: Кто скажет, мол, IDE должна помочь — подставляйте лоб, метаю камень без раздумий. Полно случаев, когда IDE не справляется или вообще не может быть применена.

	От:	Shmj
	Дата:	18.03.25 14:09
	Оценка:

От:	Sinclair	https://github.com/evilguest/
Дата:	18.03.25 14:32
Оценка:	+3

	От:	Shmj
	Дата:	18.03.25 14:37
	Оценка:

	От:	Privalov
	Дата:	18.03.25 14:41
	Оценка:

От:	Sinclair	https://github.com/evilguest/
Дата:	18.03.25 15:26
Оценка:	3 (1) +2

	От:	Константин Б.
	Дата:	19.03.25 04:37
	Оценка:	1 (1)

От:	netch80	http://netch80.dreamwidth.org/
Дата:	19.03.25 09:50
Оценка:	3 (1) +3