Внедрение зависимости в C++

Вы можете использовать команду печати с помощью grob и viewport. Сначала зарисуйте свою базовую графику, затем добавьте ggplot

library(grid)

# Let's say that P is your plot
P <- ggplot(acd, # etc... )

# create an apporpriate viewport.  Modify the dimensions and coordinates as needed
vp.BottomRight <- viewport(height=unit(.5, "npc"), width=unit(0.5, "npc"), 
                           just=c("left","top"), 
                           y=0.5, x=0.5)

# plot your base graphics 
par(mfrow=c(2,2))
plot(y,type #etc .... )

# plot the ggplot using the print command
print(P, vp=vp.BottomRight)
24
задан Yorgos Pagles 9 December 2008 в 14:26
поделиться

8 ответов

Этот разговор о Java и внедрении зависимости.

В C++ мы пробуем НЕ для раздавания НЕОБРАБОТАННЫХ указателей. Это вызвано тем, что НЕОБРАБОТАННЫЙ указатель не имеет никакой семантики владения, связанной с ним. Если у Вас нет владения тогда, мы не знаем, кто ответственен за чистку объекта.

я нахожу, что большую часть времени внедрение зависимости сделано через ссылки в C++.
В редких случаях, где необходимо использовать указатели, оберните их в станд.:: unique_ptr<> или станд.:: shared_ptr<> в зависимости от того, как Вы хотите управлять владением.
В случае, если Вы не можете использовать C++ 11 функций, используйте станд.:: auto_ptr<> или повышение:: shared_ptr<>.

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

13
ответ дан this.myself 28 November 2019 в 23:45
поделиться

Используйте RAII.

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

shared_ptr<> может сделать это; вторым аргументом его конструктора может быть функциональный объект, который знает, как удалить объект.

3
ответ дан Kaz Dragon 28 November 2019 в 23:45
поделиться

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

2
ответ дан Evgeny Lazin 28 November 2019 в 23:45
поделиться

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

Лично я сказал бы "нет": объект, в который введена зависимость, вымоется впоследствии. При попытке сделать это через разработчика означает, что разработчик должен будет жить дольше и, чем зависимость и, чем объект, в который это введено. Это вызывает больше проблем, чем это решает, по-моему, потому что разработчик больше не служит полезной цели после того, как конструкция с внедрением зависимости была завершена.

2
ответ дан aib 28 November 2019 в 23:45
поделиться

Интересно, что DI на C++ использует шаблоны:

http://adam.younglogic.com/?p=146

Думаю, автор делает правильные шаги, чтобы не переводить Java DI на C++ слишком буквально. Стоит прочитать.

9
ответ дан 28 November 2019 в 23:45
поделиться

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

Иногда перекрестная зависимость неизбежна, а четкого права собственности нет. Например, (m) экземпляры A имеют (n) экземпляры B, а некоторые экземпляры B могут принадлежать нескольким экземплярам As. В этом случае, Наилучшим подходом является применение подсчета ссылок на В, аналогично подсчету ссылок на СОМ. Любые функции, которые вступают во владение B*, должны сначала увеличить счетчик ссылок, а затем уменьшить его при освобождении от владения.

Я также избегаю использования boost::shared_ptr, так как это создает новый тип (shared_ptr и B* становятся двумя разными типами). Я обнаружил, что это приносит больше головной боли при добавлении методов.

2
ответ дан 28 November 2019 в 23:45
поделиться

Недавно меня укусил жучок DI. Я думаю, что он решает многие проблемы сложности, особенно автоматизированной части. Я написал прототип, который позволяет вам использовать DI в довольно C++ способе, или, по крайней мере, я так думаю. Вы можете взглянуть на пример кода здесь: http://codepad.org/GpOujZ79

То, чего явно не хватает: отсутствие скопинга, отсутствие привязки интерфейса к реализации. Последнее довольно легко решить, первое - не имею понятия.

Буду благодарен, если у кого-нибудь здесь есть мнение по поводу этого кода.

6
ответ дан 28 November 2019 в 23:45
поделиться

Вы также можете проверить FFEAD Dependency Injection. Он обеспечивает DI по образцу Spring для JAVA и имеет ненавязчивый способ работы с вещами. Он также имеет множество других важных функций, таких как встроенная поддержка AJAX, Reflection, Serialization, C++ Interpreter, Business Components For C++, ORM, Messaging, Web-Services, Thread-Pools и сервер приложений, который поддерживает все эти функции.

1
ответ дан 28 November 2019 в 23:45
поделиться
Другие вопросы по тегам:

Похожие вопросы: