Передающая копия объекта к методу — кто делает копирование?

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

Таким образом, Вы хотите сделать что-то как

MyObject m = новый MyObject (); MyObject n = MyObjectProcessor.process (m);?

Кажется более простым мне сделать что-то как MyObject n = MyObjectProcessor.alter (m.clone ());

где ясно, кто делает что кто. Вы могли привести аргумент, что функция класса процессора должна быть свободна от побочных эффектов, т.е. это должно возвратить новый объект любое время, это собирается изменить состояние, но (AFAIK) это так последовательно не сопровождается в OO в противоположность функциональному программированию.

Что-то как вышеупомянутое, вероятно, безопасно, пока это ясно называют и документируют.

Мы могли посмотреть на рубин для руководства. Они используют a! символ, чтобы указать, что объект изменяется оперативный. Так, salary.add (10000) возвраты новый объект, но salary.add! (10000) возвраты исходный объект, но измененный. Вы могли использовать ту же идею в Java или PHP при помощи локального соглашения о присвоении имен.

Вызывающая сторона. Поскольку, иногда Вы хотите внести изменения в сами объекты и другие времена к копии.

Хотя, я считаю это плохой практикой для вызываемого для изменения переданных объектов (по крайней мере, на объектно-ориентированных языках). Это может вызвать много нежелательных побочных эффектов.

(после Вашего) РЕДАКТИРОВАНИЕ: В этом случае это - обязанность вызываемого осуществить контракт, таким образом, существует две опции:

• Вызываемый просто не изменяет объект
• или вызываемый копирует объект и работает с копией впоследствии

Зависит, там какая-либо причина, что метод можно было назвать в будущем, где Вы хотите, чтобы изменение было замечено вызывающей стороной? Раз так затем вызывающая сторона должна сделать копию. Иначе вызываемый должен сделать его. Я сказал бы, что второй случай, вероятно, более распространен.

Если Вы сделали, чтобы вызывающая сторона клонировала объект, он дает Вам гибкость для не использования копии (не клонируя его сначала) и также означает, что Вы не должны возвращать новый объект, можно просто воздействовать на ссылку, переданную в.

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

Это зависит от контракта, определенного между этими двумя методами. Метод, который вносит изменения, должен явно определить, что факт и позволил вызывающей стороне принять решение. ИЛИ, метод, который вносит изменения, должен явно определить, что НЕ внесет изменений в переданный объект, и затем это было бы ответственно за то, что сделало копию.

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

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

Я думаю, что вызывающая сторона должна сделать клон, только для создания именования легче. Можно назвать метод Foo () вместо CloneBarAndFooClone ().

Сравните:

void RemoveZeroDollarPayments(Order order)

по сравнению с.

Order CloneOrderAndRemoveZeroDollarPaymentsFromClone(Order order)

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

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