способ вызова функции

Question

Я пытался сделать API.Я просто хочу скрыть все детали от конечного программиста.Я также хочу предоставить им количество опций для вызова функции. Например,

У меня есть 4 функции с одинаковым именем, но с другой сигнатурой (перегруженные функции)

function1()
function1(arg1)
function1(arg1,arg2)
function1(arg1,arg2,arg3)

В приведенной выше последовательности 4-я функциято есть function1(arg1,arg2,arg3) имеет реальную логику.остальные функции вызывают следующую функцию с некоторыми значениями по умолчанию.

Теперь, если пользователь вызывает первую функцию в вышеуказанной последовательности, т.е. function1(), то он вызывает 2-ю функцию, т.е. function1(arg1) с некоторыми значениями по умолчанию.и т. д.

Мой вопрос заключается в том, что такого рода цепочки сохраняют LOC (строку кода) и увеличивают понимание.Но хорошо ли это с точки зрения производительности?

Условия со мной

1. Я использую Java
2. Я использую JDK1.4.Таким образом, поддерживается переменное количество аргументов.

Хотя вы можете предложить мне производительность и на других языках, при условии, что вы не предлагаете функцию «переменного количества аргументов».

Answer 1

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

Примечание:
Чтобы свести цепочку к минимуму, вы можете напрямую обращаться к самой подробной функции (со всеми объявленными параметрами) из всех упрощенных функций.

function1(){
  function1(null,null,null);
}
function1(arg1){
  function1(arg1,null,null);
}
function1(arg1,arg2){
  function1(arg1,arg2,null);
}

function1(arg1,arg2,arg3){
   // Actual logic here...
}

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

Примечание:
Компилятор может дать вам некоторые преимущества, оптимизируя вызовы для вас. Возможно даже, что компилятор заменит начальный вызов function1() вызовом function1(null,null,null), потому что это все, что делает function1().

Answer 2

В таких языках, как C / C ++, компилятор может обрабатывать такие вещи таким образом, чтобы не было никакого снижения производительности вообще.В таких языках, как Matlab, для каждого вызова функции есть заметное время.

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

Answer 3

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

public class function1 {

   private String arg1 = "ding";
   private String arg2 = "dong";
   private String arg3 = "dang";

   public function1 arg1(String arg1) {
       this.arg1 = arg1;
       return this;
   }

   public function1 arg2(String arg2) {
       this.arg2 = arg2;
       return this;
   }

   public function1 arg3(String arg3) {
       this.arg3 = arg3;
       return this;
   }

   public String eval() {
       return arg1 + arg2 + arg3;
   }

}

System.out.println(new function1().arg2("deng").eval());

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

Answer 4

Раньше в C было что-то подобное, где дополнительные аргументы всегда были значениями по умолчанию, если они не предоставлены.

Для этого я использовал #define ... возможно, не очень красиво, но он работает и не окажет никакого влияния на производительность в конечном двоичном файле (без дополнительного стекового пространства или скачков времени вокруг счетчика программы).

Answer 5

[Примечание: я предполагаю, что вы говорите о более современном языке программирования, когда задаете свой вопрос (поскольку он явно не помечен языком). Если это не так, пожалуйста, откажитесь от этого ответа.]

Во-первых, целью такой цепочки является , а не , и не должно быть сокращение LOC. Строки кода - наименее важная вещь с точки зрения производительности и, в некоторой степени, даже для удобочитаемости, особенно во времена современных IDE. (Для записи: «до некоторой степени». Я не говорю, что метод с 2500 строками хорош)

Цель состоит в том, чтобы избежать дублирования логики и удобства для программиста, что в противном случае было бы кошмаром сопровождения. (Если у вас будет логика во всех методах) и некоторые трудности для конечного программиста (если у вас будет только одна реализация)

В современных языках программирования издержки, вызванные дополнительным классом двух методов, незначительны. Такая оптимизация (сокращение количества вызовов методов) в большинстве случаев ведет в никуда.

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

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