Как применить ref и out для ссылок на объекты

Помогите пожалуйста разобраться новичку. Читаю шилдта, никак не могу въехать.... С применением Ref & out для переменных типа значений все предельно ясно. А вот при для объектов не могу понять...
Как вижу все это я:
Типы значений: при передаче методу параметр получает копию значения аргумента. Соответственно, любые изменения в методе приводят к изменению копии аргумента, а значит, сам аргумент не изменяется. Все это исправляется при использования ref&out.
Ссылочный тип: при передаче методу параметр получает копию ссылки на объект. Т.е. сама ссылка передается по значению. Получается, наш объект теперь имеет "псевдонимы", и его можно изменять из метода.
Но что происходит при использовании ref с объектом???
Шилдт приводит пример с методом Swap, в котором изменяются ссылки на объекты.... (с 228)
Кто бы мне объяснил весь процесс по пунктам... а то никак не могу понять, что вообще там происходит.
Фраза: если модификаторы ref или out указывают на ссылку, то сама ссылка передается по ссылке - убила наповал)))
Спасибо заранее

0

Сообщение от Vasyan То почему мы не можем за-Null"ить объект,имея копию ссылки на сам объект?

Вы опять путаете переменую и объект

null — это значение переменной, а не объекта, следовательно занулить можно только переменную.
Объект либо существует, либо не существует. На него может быть ссылка, хранящаяся в переменной. Это может быть ссылка на существующий объект или ссылка "в никуда", то есть null.
Сам объект по желанию вы удалять не можете — это область ответственности сборщика мусора.

1

Сообщение от kolorotur null — это значение переменной, а не объекта, следовательно занулить можно только переменную

все,теперь понятнее.
Но не соглашусь с вами(с терминологией),все таки в данном контексте не корректно говорить "переменная".
К примеру :
И соответственно в совокупности этого механизма,мы говорим что с это объект типа MyClass,но не переменная типа MyClass .

А теперь обратно к моему примеру(коду с коллекцией),получается так :
если мы устанавливаем значение Null, то наша копия ссылки на объект(поле List),с которой происходит какие то действия внутри метода,теряет с ним(с полем) же связь(т.е. в памяти стека(!) больше не содержит в себе адрес самого объекта(объект List),а новое значение в виде Null и поэтому имеем такое же поведение,как и при создании нового объекта в контексте метода).

Сообщение от bax_tang физически - выделяется новая область памяти, содержащая адрес объекта в куче

Так оно и есть,только правильнее сказать,что выделяется новая область памяти в стеке(для указателя копии,который работает с адресом оригинального объекта,расположенного в куче).
А вопрос мой был связан с тем,что до конца не было понятно какое будет поведение,если придать значение Null внутри контекста метода .

0

Сообщение от Vasyan все таки в данном контексте не корректно говорить "переменная".

Неправда ваша

Сообщение от Vasyan C# 1 MyClass c = new MyClass(); // с - это объект типа MyClass.

Нет.
с — это переменная типа MyClass, значением которой является ссылка на объект типа MyClass.
Именно так правильно говорить с точки зрения терминологии.

Сообщение от Vasyan Но на уровне памяти,получается что "с"(это указатель)

с — это переменная, значение которой — ссылка на объект . Указатель — это совсем другое.

Сообщение от Vasyan расположен в стеке

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

Сообщение от Vasyan мы говорим что с это объект типа MyClass

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

Сообщение от Vasyan но не переменная типа MyClass

Именно переменная типа MyClass.
Если MyClass — ссылочный тип, то значением переменной является либо ссылка на экземпляр типа MyClass или его наследников, либо null.
Если MyClass — значимый тип, то значением переменной является сам экземпляр.

Сообщение от Vasyan т.е. в памяти стека(!)

Не обязательно(!) в памяти стека.

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

Не сочтите за оскорбление, но единственное, что верно в этой фразе — это то, что выделяется новая область памяти.

Сообщение от Vasyan до конца не было понятно какое будет поведение,если придать значение Null внутри контекста метода .

Для начала давайте немного разберемся в терминологи:

1. Переменная — это место для хранения информации
2. Переменные есть двух типов: ссылочные и значимые
3. Значеним переменной ссылочного типа является ссылка на экземпляр тпа, хранящийся где-то в другом месте, или null
4. Значением переменной значимого типа является сам экземпляр типа.
5. Переменная, объявленная в методе или вложенной области видимости, называется локальной.
6. Переменная, объявленная в теле класса, называется полем класса.
7. Переменная, объявленная в сигнатуре метода, называется параметром метода (значение, которое передается в метод в момент вызова называется аргументом).
8. При присваивании, передаче в метод и возврате из метода создается копия значения переменной.
9. При передаче в метод с параметрами ref/out передается сама переменная, но с другим именем.
10. Из восьмого пункта следует, что при присваивании, передаче в метод или возврате из метода переменной ссылочного типа создается копия ссылки на тот же самый экземпляр.
11. Из восьмого же пункта следует, что при присваивании, передаче в метод или возврате из метода переменной значимого типа создается копия экземпляра.

Если хорошо усвоить вышеприведенные пункты, то все непонятные моменты должны исчезнуть.

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

1

Сообщение от kolorotur Нет. с — это переменная типа MyClass, значением которой является ссылка на объект типа MyClass. Именно так правильно говорить с точки зрения терминологии.

Не знаю,но даже сам Рихтер утверждает обратное.

Сообщение от kolorotur с — это переменная, значение которой — ссылка на объект . Указатель — это совсем другое.

Понял,благодарю.
Тогда вопрос остается открытым. Что такое указатель и что такое ссылка в контексте управляемой памяти языка C#?

Сообщение от kolorotur Местонахождение переменной — деталь реализации рантайма, она может находиться где угодно в зависимости от времени ее жизни: в стеке, в куче или в регистре. Из одной строчки кода невозможно сказать, где именно она будет расположена. Конкретно в Майкрософтовской реализации шарпа в стеке хранятся только несоптимизированные и незахваченные локальные переменные, которые не находятся в блоке-итераторе или асинхронном методе. Во всех остальных случаях переменная хранится в куче. Другие реализации шарпа имеют полное право хранить переменные где угодно — спецификация языка это разрешает.

Вот тут если можно по подробнее?
Я в последнее время углубляюсь по теме "как CLR управляет\распределяется памятью".
Даже если взять ваши сообщение из этой темы(которые датируются 2012ом годом),или к примеру Рихтера,или кучу других в статьей,то можно увидеть одну закономерность(и иллюстрации в виде картинок),а именно:
ссылки ссылочного типа размещаются в стеке(!).

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

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

Зачем тогда сделали такую подмену понятий?

Сообщение от kolorotur Именно переменная типа MyClass. Если MyClass — ссылочный тип, то значением переменной является либо ссылка на экземпляр типа MyClass или его наследников, либо null. Если MyClass — значимый тип, то значением переменной является сам экземпляр.

Это понятно,и тут вопросов не возникает.

Относительно переменной,получается что каждый раз нам нужно тянуть тонну слов(см. комментарий к коду ):
Как то не особо звучит

Сообщение от kolorotur Не обязательно(!) в памяти стека.

Кому верить тогда?
И стоит ли вообще на этом заострять свое внимание?

Сообщение от kolorotur Не сочтите за оскорбление, но единственное, что верно в этой фразе — это то, что выделяется новая область памяти.

Ну я не знаю даже...Замените слово "указатель" на "ссылку",и вместо "работает с адресом" на "хранит в себе адрес оригинального объекта <КакойТоСсылочныйТип> расположенного в куче".
Т.е. перефразирую для вас

Сообщение от Vasyan Правильнее сказать,что выделяется новая область памяти в стеке или куче(это уже решит CLR) для ссылки копии(которую мы передаем как параметр в метод),которая хранит в себе адрес оригинального объекта поля List(а он в свою очередь,из за своего ссылочного типа,явно расположен в управляемой куче).

Сообщение от kolorotur Для начала давайте немного разберемся в терминологи: Переменная — это место для хранения информации Переменные есть двух типов: ссылочные и значимые Значеним переменной ссылочного типа является ссылка на экземпляр тпа, хранящийся где-то в другом месте, или null Значением переменной значимого типа является сам экземпляр типа. Переменная, объявленная в методе или вложенной области видимости, называется локальной. Переменная, объявленная в теле класса, называется полем класса. Переменная, объявленная в сигнатуре метода, называется параметром метода (значение, которое передается в метод в момент вызова называется аргументом). При присваивании, передаче в метод и возврате из метода создается копия значения переменной. При передаче в метод с параметрами ref/out передается сама переменная, но с другим именем. Из восьмого пункта следует, что при присваивании, передаче в метод или возврате из метода переменной ссылочного типа создается копия ссылки на тот же самый экземпляр. Из восьмого же пункта следует, что при присваивании, передаче в метод или возврате из метода переменной значимого типа создается копия экземпляра.

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

0

Сообщение от Vasyan даже сам Рихтер утверждает обратное.

Книжку в оригинале читаете? Как там написано?

Сообщение от Vasyan Что такое указатель и что такое ссылка в контексте управляемой памяти языка C#?

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

Сообщение от Vasyan ссылки ссылочного типа размещаются в стеке(!)

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

Сообщение от Vasyan Зачем тогда сделали такую подмену понятий?

Жаргон. Одно слово вместо нескольких.
Люди, знакомые с языком, в общении друг с другом прекрасно понимают о чем идет речь, а количество звуков экономится.
Проблемы начинают возникать тогда, когда эти люди начинают жаргон использовать в общении с теми, кто язык только еще изучает. Или, того хуже, начинают писать статьи/руководства/книги с использованием "словечек".
Можно серьезно запутаться.

Сообщение от Vasyan получается что каждый раз нам нужно тянуть тонну слов

Собственно, потому и используют более короткие (хоть и неправильные) слова — для экономии

Сообщение от Vasyan Как то не особо звучит

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

Сообщение от Vasyan Кому верить тогда?

Не верьте никому!
Возьмите да протестируйте всё сами — это закаляет характер

Сообщение от Vasyan И стоит ли вообще на этом заострять свое внимание?

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

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

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

Сообщение от Vasyan Замените слово "указатель" на "ссылку",и вместо "работает с адресом" на "хранит в себе адрес оригинального объекта <КакойТоСсылочныйТип> расположенного в куче".

Указатель — это просто адрес виртуальной памяти процесса. Всё. Он может указывать в произвольное место в памяти.
Ссылка — это всегда либо валидный дескриптор объекта, либо null. Их важно различать, особенно в шарпе, т.к. там есть и сылки, и указатели.
То есть ссылка — это абстракция, некая сущность, с помощью которой получается доступ к объекту.
Скажу по секрету: в шарпе ссылки реализованы через обычные указатели, но с определенными жесткими ограничениями. Например, ссылка не может ссылаться на часть объекта.
Но то, что ссылки в шарпе реализованы через указатели — это опять же деталь реализации. Какой-нибудь Mono/Xamarin имеет полное право реализовать ссылки через самые настоящие дескрипторы.

Есть такое выражение, что если что-то выглядит как утка и крякает как утка, то это утка.
Вот это выражение можно перефразировать и для ссылок в шарпе: ссылкой называется сущность, которая имеет поведение и все свойства ссылки согласно спецификации языка. Я весь списк сходу не припомню, но два важных пункта — это всегда известен статический тип (даже для null) и если ссыла не null, то статический тип ссылки всегда совместим с фактическим типом объета, на который она ссылается.
Говоря проще, если ссылка имеет определенный тип, то и ссылаться она может только на этот же тип или его наследников. Это ограничение отсутствует для указателей.

Сообщение от Vasyan Ну вы совсем обижаете

Обижать цели не стояло. Если чем-то задел — приношу извинения.

Сообщение от Vasyan за исключением момента с трактовкой объекта,то бишь что то уж вы сильно обостряете внимание на этом.

В смысле?

1

Сообщение от kolorotur Книжку в оригинале читаете? Как там написано?

в переводе.

Сообщение от kolorotur Ссылка — это больше похоже на дескриптор, с помощью которого можно получить доступ к объекту.

Так ведь эта ссылка хранит в себе значение(адрес) объекта,на который ссылается то?(Или все таки нет)

Сообщение от kolorotur Не ссылки, а экземпляры, они же объекты. Ссылка — это значение переменной. Переменная может храниться где угодно.

нет,именно "ссылки" или как вы их называете "переменные",расположены в стеке,а сам объект и тип объекта в куче(про что я писал выше).

А вот и моя иллюстрация:
[image]https://www.cyberforum.ru/attachments/771016d1481149908[/image]

Сообщение от kolorotur Но только перед тем, как приводить статьи, прочитайте те абзацы по-внимательнее: возможно, речь там все-таки идет об экземплярах ссылочных типов, а не о ссылках на них.

Нет,именно ссылки(переменные) на ссылочные объекты(экземпляры типа reference type).

Статья 1
Статья 2
Статья 3
Статья 4
Ну и у Рихтера в 4 главе есть нечто подобное .

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

Значит ссылки хранят адрес на сам объект?(это определение верно?)

Миниатюры

 

0

Сообщение от Vasyan в переводе.

Рихтер — серьезный автор, потому либо вы что-то не так поняли, либо кривой перевод. Ну или очередное использование жаргонов.

Сообщение от Vasyan Так ведь эта ссылка хранит в себе значение(адрес) объекта,на который ссылается то?(Или все таки нет)

В майкросовтовской реализации компилятора и рантайма — да. Но в следующей версии фреймворка может всё поменяться — это свойство детали реализации.
Почему вам интересно, каким образом реализованы ссылки?

Сообщение от Vasyan именно "ссылки" или как вы их называете "переменные"

Я не называю ссыкли переменными
Ссылка — это значение, переменная — это хранилище.
Значение переменной ссылочного типа — ссылка.
Проводя аналогию, переменная — шкатулка, а ссылка — это листочек с указанем где найти то, что вам нужно, хранящийся в этой шкатулке.

Сообщение от Vasyan расположены в стеке,а сам объект и тип объекта в куче

Это неверно.
Особенно если учесть, что поле класса — это тоже переменная.

Сообщение от Vasyan Статья 1

Все типы значений являются производными от типа System.ValueType и размещают свое значение в стеке.

Это неправда.

Сообщение от Vasyan Статья 2

Здесь автор более аккуратен:

Value Types and Pointers always go where they were declared. [...]Now, Value Types are also sometimes placed on the Heap.

Хотя тоже дает не полную картину.

Сообщение от Vasyan Статья 3

Ближе к истине, если в первой строчке заменить always на sometimes:

The stack is always used to store the following two things: The reference portion of reference-typed local variables and parameters (such as the myTextBox reference) Value-typed local variables and method parameters (structs, as well as integers, bools, chars, DateTimes, etc.) The following data is stored on the heap: The content of reference-type objects. Anything structured inside a reference-type object.

Сообщение от Vasyan Статья 4

Автор рубит с плеча:

Reference Type variables are stored in the heap while Value Type variables are stored in the stack.

Хотелось бы поинтересоваться у автора: как быть с переменными значимых типов, объявленными в методе-итераторе или в асинхронном методе? В каком именно стеке они хранятся и каким образом? Особенно интересно узнать про асинхронные методы: в стеке какого именно потока они хранятся?

Ну и, конечно же, никто почему-то ничего не сказал про регистры, будто их вообще не существует.

Сообщение от Vasyan у Рихтера в 4 главе есть нечто подобное

CLR via C#?

Value type instances are usually allocated on a thread’s stack (although they can also be embedded as a field in a reference type object).

Ключевое слово — usually.

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

Обращаю внимание: речь идет о переменных, а не об экземплярах типа.
Экземпляры ссылочных типов всегда создаются в куче (в М-й реализации языка). Экземпляры значимых типов — там, где создается сама переменная, т.к. экземпляр хранится в переменной.

Сообщение от Vasyan Значит ссылки хранят адрес на сам объект? это определение верно?

То, каким способом реализованы ссылки — compiler-specific, то есть спецификацией языка не определено и каждый компилятор/рантайм может реализовывать их как угодно.
Потому ответом на этот вопрос может быть только встречный вопрос: о каком компиляторе какой версии идет речь?

1

Сообщение от kolorotur Рихтер — серьезный автор, потому либо вы что-то не так поняли, либо кривой перевод. Ну или очередное использование жаргонов.

Возможно. Но в 4ой главе показан пример(с картинками),который мы обсуждаем. И откровенно говоря,я не замечал,чтобы автор(Рихтер) писал что то вроде : иногда переменные ссылочного типа хранятся в куче.
Отсюда и конфуз у меня .

Сообщение от kolorotur В майкросовтовской реализации компилятора и рантайма — да. Но в следующей версии фреймворка может всё поменяться — это свойство детали реализации. Почему вам интересно, каким образом реализованы ссылки?

Потому что многие(те же статьи) об этом пишут,и хочется иметь правильное представление.

Сообщение от kolorotur Я не называю ссыкли переменными Ссылка — это значение, переменная — это хранилище. Значение переменной ссылочного типа — ссылка.

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

Сообщение от kolorotur Проводя аналогию, переменная — шкатулка, а ссылка — это листочек с указанем где найти то, что вам нужно, хранящийся в этой шкатулке.

Может все таки шкатулка это объект,а переменная это листочек,на котором указана дорога(ссылка,то бишь значение,то бишь адрес) к шкатулке(экземпляру объекта) ?

Сообщение от kolorotur Особенно если учесть, что поле класса — это тоже переменная.

Поля Value Type объявленные в классе,на сколько мне известно аллоцириуются в Heap'e.

Сообщение от kolorotur Это неправда.

Ну здесь автор просто не договорил. System.ValueType неявно унаследован от System.Object, благодаря чему у пользовательских структур,есть методы Equals(),ToString(),GetHashCode() - которые так же можно переопределить(это исключение сделанное для структур,ибо полиморфизм для них запрещен).

Сообщение от kolorotur Хотя тоже дает не полную картину.

Да,но мы то с вами говорим исключительно об типе reference type.

Сообщение от kolorotur CLR via C#?

Он самый (.NET 4.5 C# 5.0, 2013ый год)

Сообщение от kolorotur Ключевое слово — usually

Да,но опять же,речь только об Reference Type.

Сообщение от kolorotur В шарпе есть два типа памяти: долговременная и кратковременная. Долговременная — это куча, управляемая и неуправляемая

Да,про это слышал про Small Object Heap / Large Object Heap, вот хорошая статья на хабре

Сообщение от kolorotur То, каким способом реализованы ссылки — compiler-specific, то есть спецификацией языка не определено и каждый компилятор/рантайм может реализовывать их как угодно. Потому ответом на этот вопрос может быть только встречный вопрос: о каком компиляторе какой версии идет речь?

Я понял вас,благодарю за эту информацию.

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

0

Сообщение от Vasyan Может все таки

Нет, именно так, как я написал.
Переменная — это просто хранилище информации, в котором может лежать какое-нибудь значение.
Одно из возможных значений — ссылка на экземпляр объекта.

Сообщение от Vasyan Поля Value Type объявленные в классе,на сколько мне известно аллоцириуются в Heap'e.

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

Сообщение от Vasyan System.ValueType неявно унаследован от System.Object, благодаря чему у пользовательских структур,есть методы Equals(),ToString(),GetHashCode() - которые так же можно переопределить(это исключение сделанное для структур,ибо полиморфизм для них запрещен).

Верно, только как это относится к обсуждаемой теме?

Сообщение от Vasyan мы то с вами говорим исключительно об типа reference type.

А я думал мы говорим о переменных, неважно какого типа
Ведь ref/out — это про переменные, а не про экземпляры.

Сообщение от Vasyan Он самый (.NET 4.5 C# 5.0, 2013ый год)

У меня старенькая версия, но с тех пор ничего не поменялось, разве что асинхронные методы добавились.

Сообщение от Vasyan опять же,речь только об Reference Type.

Простите, я не понимаю.
У вас же вопросы возникли по поводу ref/out, так?

Сообщение от Vasyan Small Object Heap / Large Object Heap

Они обе входят в категорию управляемой памяти.

Сообщение от Vasyan Я понял вас

Я это лишь к тому, что то, как реализованы ссылки — настолько дремучая деталь реализации, что толку от этого знания мало.
Если все-таки интересно, то в майкрософтовской версии шарпа объекты ссылочных типов реализованы как блоки памяти, первые байты которых, т.н. заголовки, хранят определенные метаданные об экземпляре (ссылку на тип, блок синхронизации и т.д.).
Ссылка на такой объект реализована как указатель на этот заголовок.

0

Сообщение от kolorotur Потому ответом на этот вопрос может быть только встречный вопрос: о каком компиляторе какой версии идет речь?

К примеру RyuJIT

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

О чем речь?
Разве я утверждал,что ValueType хранятся всегда и только всегда в стеке?

Я вам даже больше скажу,в каких именно случаях ValueType хранится в Хипе:
1. Если ValueType упакован(boxed) - хранится в хипе
2. Если ValueType являются полем класса - хранится в хипе
3. В случае замыкания с анонимными методами(а мы ведь знаем,что при Closure,компилятор ретранслирует код в доп. класс,где переменная становится полем,отсюда по логике пункт №2) - хранится в хипе
4. Если находится в блоке итератора(yield,который разворачивает класс с интерфейсом IEnumerable) - хранится в хипе

Сообщение от kolorotur Верно, только как это относится к обсуждаемой теме?

Это к слову.

Сообщение от kolorotur А я думал мы говорим о переменных, неважно какого типа Ведь ref/out — это про переменные, а не про экземпляры.

Нет конечно!
Речь шла исключительно только об ReferenceType , т.к. не было понятно мне,какое поведение получает ReferenceType в контексте метода,если придать значение Null.
Заметьте,я ведь ни слова не говорил об ValueType в моих сообщениях.

Сообщение от kolorotur Простите, я не понимаю. У вас же вопросы возникли по поводу ref/out, так?

ReferenceType и только,ибо поведение ValueType(и где они хранятся),мне ясно.

Сообщение от kolorotur Если все-таки интересно, то в майкрософтовской версии шарпа объекты ссылочных типов реализованы как блоки памяти, первые байты которых, т.н. заголовки, хранят определенные метаданные об экземпляре (ссылку на тип, блок синхронизации и т.д.).

и получается что ValueType,которые хранятся в хипе,имеют такие же заголовки,в виде блока синхронизации и тд,как и ReferenceType

0

Сообщение от Vasyan К примеру RyuJIT

Не знаком — ничего сказать не могу

Сообщение от Vasyan Разве я утверждал,что ValueType хранятся всегда и только всегда в стеке?

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

Сообщение от Vasyan Я вам даже больше скажу,в каких именно случаях ValueType хранится в Хипе:

Я же выше об этом писал.
Добавьте еще асинхронные методы пятым пунктом.

Сообщение от Vasyan Речь шла исключительно только об ReferenceType , т.к. не было понятно мне,какое поведение получает ReferenceType в контексте метода,если придать значение Null.

Так именно для понимания того, что происходит в этом контексте, я и написал выше как работают переменные. А вы в ответ обиделись.

Сообщение от Vasyan получается что ValueType,которые хранятся в хипе,имеют такие же заголовки,в виде блока синхронизации и тд,как и ReferenceType

Нет конечно. Заголовок имеет объект, полем которого является ValueType.

1

Сообщение от kolorotur ак именно для понимания того, что происходит в этом контексте, я и написал выше как работают переменные. А вы в ответ обиделись.

Я не обиделся,все в порядке , видимо мы друг друга не поняли,и обсуждали "более" глобально. Но опять же,вопрос стоял о ReferenceType.

Сообщение от kolorotur Нет конечно. Заголовок имеет объект, полем которого является ValueType.

Вы правы,тут я глупость ляпнул.

Сообщение от kolorotur Добавьте еще асинхронные методы пятым пунктом.

это по сути и есть пункт по типу с замыканием(Closure).

В общем благодарю за быстрые ответы.

1

Добрый день, я сторонний наблюдатель, тему прочитал целиком.

Сообщение от kolorotur ссылки в шарпе реализованы через указатели

Я лично вообще всегда считал, экземпляр класса - это указатель на класс и только поэтому мы можем можем присвоить ссылочному типу null, по аналогии с nullptr (или какое там значение советуют присваивать в C++ указателю, который больше не будет использоваться).

И, соответственно, я считал, что при передаче (из main, например) в метод ссылочного типа создаётся копия указателя на экземпляр класса.
Соответственно, мы можем изменять этот указатель, чтобы он указывал на что-нибудь другое, а исходный указатель и то, на что он указывает остаются без изменений, верно?

Вопрос небольшой, с Вашего позволения, kolorotur, ответьте, пожалуйста:

Если при передаче ValueType (ref int index) с модификатором ref у нас должна передаваться ссылка на область памяти, содержащая нашу переменную index, то при каждой передаче этой ссылки (ref int index) в метод, будет ли у нас будет создаваться дополнительный указатель, содержащий значение этой области памяти или же в метод будет передаваться лишь сама ссылка? Другими словами, является ли на низком уровне передача значимого типа по ссылке передачей по ссылке или по сути является передачей с созданием нового указателя?

(Меня это интересует в контексте затрат памяти на указатели при передаче значимого типа по ссылке множество раз во вложенные вызовы различных методов)

0

Сообщение от Enflamed является ли на низком уровне передача значимого типа по ссылке передачей по ссылке или по сути является передачей с созданием нового указателя?

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

Сообщение от Enflamed Меня это интересует в контексте затрат памяти на указатели при передаче значимого типа по ссылке множество раз во вложенные вызовы различных методов

Да бросьте, какие там затраты — один указатель? Это 32/64 бита, чепуха.
Единственная "проблема", которую может создать дополнительный указатель — это взорванный стек при длинной цепочке вызовов, но если у вас столько вызовов, что стек взрывается из-за локальной переменной в 32/64 бита, то проблема кроется уже не в наличии указателя, а в наличии такой глубины вызовов.

0

Заранее, извиняюсь за оффтоп (Если мой вопрос можно счесть оффтопом)

Сообщение от kolorotur Да бросьте, какие там затраты — один указатель? Это 32/64 бита, чепуха.

У меня просто сейчас есть проект по созданию структуры (дерева) рекурсивно из строки символов (парсер) -> я в каждый конструктор элемента дерева передаю значение индекса последнего пропаршенного символа...

Просто интересно, будет ли выделяться каждый раз память под этот указатель (или ссылку) "ref"?

(Если в случае с C++ мы точно знаем, что для параметра (&index) лишних операций по выделению памяти не происходит)

0

Сообщение от Enflamed интересно, будет ли выделяться каждый раз память под этот указатель (или ссылку) "ref"?

Зависит целиком от компилятора. Спецификация языка определяет только поведение, которое должно наблюдаться при использовании определенных языковых конструкций. Как это поведение реализовано — полностью отдается на откуп компилятору и среде выполнения.
Конкретно в майкрософтовской реализации компилятора под настольную версию Windows просто создается параметр-адрес, как в плюсах.
Было:
Стало:
Другие компиляторы могут это реализовать как-то иначе. Например, создавая указатель.

Сообщение от Enflamed я в каждый конструктор элемента дерева передаю значение индекса последнего пропаршенного символа

И добавляете параметру ref только для того, чтобы избежать выделения дополнительной памяти под локальную переменную?
Лучше так не делайте, поскольку ключевое слово ref ничего не говорит об используемой памяти, у него ровно одно семантическое значение: передача переменной по ссылке.
Лучше все-таки не строить логику приложения, опираясь на детали реализации компилятора или среды выполнения — в истории огромная масса примеров, когда написанное подобным образом приложение просто переставало работать при выходе очередного обновления или при переходе на новую версию ОС. А виновата, как всегда, "тупая винда"

0

Сообщение от kolorotur Лучше все-таки не строить логику приложения, опираясь на детали реализации компилятора или среды выполнения

Да, действительно, я уже всё пределал, просто вынес параметр во внешнюю переменную, не знаю какой индус мне в голову залез когда я продумывал логику

0