Понадобилось использовать файл мэппинг для работы. Ни разу раньше не пользовался. А вот "с налету" не получилось..  
И так, есть класс


Нужно его передать другому процессу



на выходе п другом процессе



Ну и естествено все даные неправильные ,короче лабуда. Одна.. Где протупил?

Добавлено @ 13:19 
Да, забыл сказать, до этого передавал просто строку.. тренировался. Все работало. А  с классом не получается.. 

Вот самое простое, что приходит на ум:



В одном процессе данные указатели абсолютно корректны и указывают на выделенный
участок памяти. Когда Вы передаёте класс другому процессу, данные указатели теряют
свой смысл, так как в контексте второго процесса указывают на абсолютно непонятную область памяти.
Если объявить эти же переменные как 
WCHAR variable_name[1024], всё должно работать правильно, так как в этом случае 
другому процессу будет полностью передан этот блок памяти.

Это сообщение отредактировал(а) Pulse69 - 22.3.2007, 15:30

Pulse69, 

Это был самый первый вариант. Я просто подумал, что стоит оперировать с указателями. Страно. Но только что все переделал, снова под 


Теперь работает.. Ничего не пойму.. Но это уже мои проблемы.. Где-то что-то когда-то потерял..  В любому случае спасибо 

Добавлено @ 15:42 
Интересно, а если понадобится работа с указателями (ну там память выделить нужно будет), как тогда быть? Разыименование?

Просто поймите что именно Вы делали своим первым кодом.

1.    Создаёте указатель на данные (пусть будет m_pData).

2.    Выделяете память m_pData = new WCHAR[1024]. Т.е. в куче ПЕРВОГО процесса был 
выделен 1кБ памяти.

3.    Передаёте УКАЗАТЕЛЬ ВТОРОМУ процессу. То есть Вы физически передали 4 байта - sizeof(m_pData) 
второму процессу. m_pData указывает на адрес в виртуальном пространстве ПЕРВОГО процесса. По этому
адресу у ВТОРОГО процесса может располагаться всё что угодно. Сами же данные остались в первом
процессе, где они, естественно, имеют смысл. 

В втором же случае (статические массивы) Вы физически передаёте из 1го процесса 2му 1кБ данных
(текст), поэтому 2й процесс их может спокойно использовать.

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

Надеюсь, теперь всё ясно


Это сообщение отредактировал(а) Pulse69 - 22.3.2007, 15:50

 Уже не вспомню, но вроде как делал так 


т.е. передавал ссылку на обьект,без выделения памяти. Вроде поэтому не работало с
  WCHAR NewNameFile [1024] ;
  WCHAR OldFileName [1024];
  WCHAR FileName [1024] ;

Добавлено @ 15:54 

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

Это сообщение отредактировал(а) Coocky - 22.3.2007, 15:50

кстати, можно было бы попробовать такой вариант:
все объекты хранить в области памяти, занятой оторбажаемым файлом
ну и при передаче все указатели преобразовывать, чтобы сохранялась разница указателя на данные и указателя на начало памяти файла

А смысл? Или я что -то не понял..  Можно немного пдробней. Я всего час юзаю этот мапфайл  

я его вообще ни разу не использовал 

смысл в том, что map file позволяет иметь в двух процессах общую область
адреса её начала для каждого процесса чаще всего будут разными, но если какая-то ячейка для одного процесса стоит через 10 байт после начала области map файла, то и в другом процессе эта разница сохранится

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

единственная проблема, которую я вижу - классы с виртуальными методами:
1. сами виртуальные таблицы и методами вряд ли удастся расположиться в map file (это вообще страшно как-то)
2. мы не контролируем тип указателя на таблицу виртуальных методов, он вседа абсолютный

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

Мне лично кажется, что это всё будет какое-то шаманство. 
Лучше не разделять экземпляр класса между процессами,
а написать класс, который внутри будет использовать 
Mapped file во внутренней реализации, а все данные получать из 
него с помощью методов класса. Тогда каждый процесс будет иметь свой
экземпляр объекта и не будет таких проблем с относительными
указателями, виртуальными методами и статическими переменными класса.

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

Pulse69 прав: не надо путать суп с мухами. Через маппинг можно передать данные - просто сериализовать. Но тоже самое можно сделать с помощью WM_COPYDATA, а также другими способами.
Я использую файл-маппинг в двух случаях: когда надо читать большие файлы сложной структуры (возможно даже с произвольным доступом) - отображение в память позволяет обойтись без всяких fseek и прочая - память она и  есть память. Особенно, если все влезает в один View.
Второй случай - при работе с очень большими данными - когда несчасного 1 гб может не хватить -например, при развертывании в памяти очень больших растров.

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