Roman
тогда твой друг - reflect
reflect никому не друг, он всем торговец наркотиками из тёмного переулка
Roman
ну кроме как сделать все поля приватными и доступ оставить только через методы
Roman
мне кажется, это никогда не сделать атомарно
сделать, если есть прототип-константа
Roman
Roman
либо будешь скучать по мьютексу
Roman
сделать, если есть прототип-константа
мне кажется, это очень редкий случай и в реальной жизни так бывает примерно никогда
Roman
либо будешь скучать по мьютексу
ну вот да. все под мьютекс
Roman
ну сделай глобальный образец структуры и от него клонируй всегда
что? как это решит проблему копирования a в b если там атомарные поля и указатели?
Roman
а что делает copy constructor как ты думаешь?
Roman
под капотом
Roman
а что делает copy constructor как ты думаешь?
не путайте понятия constructor и copy constructor, это вещи разные
Roman
ну вот да. все под мьютекс
тоже никак не спасёт, копия всё-равно небезопасная, без спец метода сейчас в Go это никак не решается
Roman
если лень его делать, есть reflect
Roman
если лень его делать, есть reflect
а reflect чем ему поможет?
Pawel
== лучше javascript в интерфейсах еще ничего не придумали ахаха))
Roman
если лень его делать, есть reflect
reflect никогда не вариант (почти никогда), и в этом случае он никак не поможет... мне кажется вы не поняли проблему, совсем не поняли
Roman
поможет скопировать толерантно к изменению полей структуры
Roman
чтобы не переделеывать функцию Copy каждый раз
Roman
да все я понял, не только у тебя бывает :)
Roman
тебе хочется держать структуру, а вней атомарные поля чтобы быстро и параллельно, но и еще все кучей это быстро копировать в любой момент
Roman
это называется параллельный доступ к данным, вражеский путь
Roman
// Copy implements the transparent copy constructor func (t *T) Copy() T { deepCopy := deepCopyPointer(t.children) return T{ atomicField: atomic.LoadUint32(&t.atomicField), children: deepCopy, } } // calls the copy constructor c := t
Roman
дело не в скорости, дело в стиле кода cp := t вместо cp := t.Copy() а сейчас вариаций много, каждый делает как ему взбредит: t.Clone() t.CreateCopy() t.Duplicate() t.C() t.Dup() var cp T; copyT(t, &cp) etc.
Roman
ну, если дефолтное поведение - shallow copy, а тут, неожиданно, будет не shallow, будет странно же?
да нет, почему? мы всегда можем глянуть в реализацию copy constructor'а той или иной структуры, потому-что она стандартизована если её нет то будет простой shallow copy
Илья
ээ, вообще, как и перегрузка операторов, это тот еще адок
Roman
ээ, вообще, как и перегрузка операторов, это тот еще адок
не стоит сравнивать это с перегрузкой операторов, вещи таки немного разные мне кажется адок у нас именно сейчас, ибо можно наломать дров просто скопировав структурку... а оборачивать всё в интерфейсы это относительно дорого однако в этом есть некая магия, хоть и небольшая, что тоже нехорошо
Илья
когда ты видишь t.Copy(), ты явно можешь перейти к реализации, когда в коде ты видишь cp := t, как понять, перегружен копи конструктор или нет?
Roman
скрытая магия
Roman
когда маг добрый и мудрый - всё окей когда маг - мудак и в копи-констракторе запускает HTTP запрос - вот тогда беда
Roman
а Go создавался с учётом армии магов мудаков, так-что да.. решение правильное, но нам добрым и мудрым страдать 😃
Pawel
дело не в скорости, дело в стиле кода cp := t вместо cp := t.Copy() а сейчас вариаций много, каждый делает как ему взбредит: t.Clone() t.CreateCopy() t.Duplicate() t.C() t.Dup() var cp T; copyT(t, &cp) etc.
апатамушта нет универсального способа копировать объекты. А для каждой структуры свой прописывать, который потом компилтор не явно вызывает - увольте, мы этого в плюсах наелись по горлышко
Pawel
не работает =)
Pawel
если в структуре есть интерфейсы например
Roman
апатамушта нет универсального способа копировать объекты. А для каждой структуры свой прописывать, который потом компилтор не явно вызывает - увольте, мы этого в плюсах наелись по горлышко
в неявности есть как минус так и плюс минус: он не явен)) надо искать есть ли реализация или нет плюс: сделать ошибку сделав shallow copy очень легко
Илья
а Go создавался с учётом армии магов мудаков, так-что да.. решение правильное, но нам добрым и мудрым страдать 😃
это потому, что люди не умеют признаваться, что они не добрые и мудрые, а вполне себе мудаки
Roman
это потому, что люди не умеют признаваться, что они не добрые и мудрые, а вполне себе мудаки
вернее "дурак - не знает, что он дурак, в его суб́ъективном мировоззрении он умнее объективного умного"
Pawel
в неявности есть как минус так и плюс минус: он не явен)) надо искать есть ли реализация или нет плюс: сделать ошибку сделав shallow copy очень легко
это не просто минус, это трындец. Имхо для авторов всех вот этих вот имплицитов, темплейтов и перегрузок операторов отдельный котёл с перцем предусмотрен
Roman
чем именно он отличается?
а вообще эта тема - долгая, не хочу её сейчас начинать
Илья
чем? такой же implicit кусок кода, на который не наложены никакие ограничения
Илья
только вызывается в других условиях, по безопасности, примерно равен перегрузке оператора ++
Илья
эээ, тогда заем ты начал эту тему обсуждать?
Roman
очень кратко: они делают код невероятно нечитабельным
Roman
copy constructor тоже, но чуть менее опасно
Илья
в чем менее опасность?
Roman
эээ, тогда заем ты начал эту тему обсуждать?
я про copy constructor, не про operator overloading, и мешать их не стоит, вещи немного разные
Илья
менее опасен
так в чем меньшая опасность?
Илья
ок, слив засчитан
Илья
Не стоит вскрывать эту тему
Roman
ок, слив засчитан
считай это моим субъективным мнением, у меня сейчас нет желания эту тему раскрывать, она по времени дорогая, поэтому не надо
Roman
а теперь я понял, тебе лень писать .Copy()? в этом дело?
Roman
7 символов
Roman
в обмен на это надо замутить целую историю в компиляторе?
Roman
а теперь я понял, тебе лень писать .Copy()? в этом дело?
нет, не понял, пожалуйста, читай внимательнее
Roman
а теперь я понял, тебе лень писать .Copy()? в этом дело?
повторюсь: можно просто напросто забыть вызвать .Copy и мы получим неочевидный баг при shallow copy
Roman
вообще то очевидный, race
Roman
вообще то очевидный, race
не очевидный, если не знаешь внутреннего устройства типа
Roman
a Go у нас "язык для дураков" если выражаться очень грубо, а если более вежливо то: "для армии junior'ов Google свеже-испечённых студентов". которые могут вполне себе и забыть вызвать специальный метод копирования где-то в недрах
Roman
ну и ладно
Roman
одно дело: type T struct { flag Atomic<uint32> } совсем другое: type T struct { atomicFlag uint32 } а третье так вообще коварное: type T struct { flag uint32 }
Roman
забудут и забудут
Илья
повторюсь: можно просто напросто забыть вызвать .Copy и мы получим неочевидный баг при shallow copy
а если в том месте (допустим range), где хочется иметь shallow, окажется deep copy + еще время потрачено будет не это, и тоже будет баг
Roman
поэтому на каждом заборе написано - 1. экспортируемые из пакета мапы и структуры защищай mutex-ом (альтернатива - atomic.Value) 2. если надо что передать между горутинами - используй каналы
Roman
поэтому на каждом заборе написано - 1. экспортируемые из пакета мапы и структуры защищай mutex-ом (альтернатива - atomic.Value) 2. если надо что передать между горутинами - используй каналы
ты опять не понял... экспортируй - не экспортируй, защищай мутексом - не защищай, толку нет! cp := t так или иначе shallow copy, игнорует все атомики, мутексы, указатели и условия
Roman
нет, он создает ссылку на тот же объект, потому что у тебя cp и t будут ссылками
Roman
для создания копии делаешь cp:=NewObj(), затем cp.Assign(t)