Повторная коллизия - практика кодирования

какой из них вы предпочитаете? (конечно, getSize не делает никакого сложного подсчета, просто возвращает значение члена)

void method1(Object & o)
{
    int size = o.getSize();

    someAction(size);
    someOtherAction(size);
}

или

void method2(Object & o)
{
    someAction(o.getSize());
    someOtherAction(o.getSize());
}

Я знаю, что могу измерить, какой из них быстрее, но мне нужны некоторые комментарии... Не просто выполнение связанного времени... например. если вы предпочитаете метод2, сколько раз максимально использовать o.getSize и каков номер, что заставляет использовать метод method1? Любые лучшие практики? (представьте себе даже разные типы, тогда int) TY

Ответ 1

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

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

(и да, для других ответов, сделайте size a const int, чтобы убедиться, что он не был изменен, если он передан ссылкой на что-то еще).

Ответ 2

Поскольку вы не хотите, чтобы size изменялся при вызове someAction() или someOtherAction() (как это не возможно, когда это возвращаемое значение функции), рассмотрите:

void method3(const Object& o)
{
    const int size = o.getSize();

    someAction(size);
    someOtherAction(size);
}

getSize() может быть простым, или это может стоить дорогостоящий расчет. Кроме того, размер o может быть изменен другим потоком между вашими вызовами на someAction() и someOtherAction().

Ответ 3

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

Ответ 4

Когда я вызываю функцию, которая возвращает что-то несколько раз (примерно в 2-3 раза), я обычно сохраняю возвращаемое значение в локальной переменной. Это потому, что я ценю скорость программы больше, чем сохранение памяти. Не то, чтобы память не была важна. Это зависит от ситуации. Вызов функции, которая не требует много времени для выполнения, не требует много времени, но функция с несколькими циклами, называемая большим количеством раз, отправит вашу программу в долгие ожидания.

Ответ 5

Первый исключает ненужные вызовы функции, поэтому я предпочитаю метод1(), поскольку код также выглядит немного чище.

Однако вы должны знать, что в зависимости от контекста они могут давать разные результаты. Скажем, если в someAction() изменяется размер, и вы используете значение, хранящееся в переменной размера, вы не можете получить желаемый результат.

Ответ 6

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