1) Как получить ячейку памяти? 2)...

[Lord_Satan]

1)
Как получить адрес ячейки памяти где хранится адрес переменной?

dim ggg&
dim p&

p=varptr(ggg) ' p=1000000

а где хранится это число 1000000,

2)
Объясните плз зачем нужны Get и PutMem? они же медленные
быстрее использовать обычное присвоение a(0)=b(0)
Вернее где их можно применить, так что бы остаться в выигрыше?

[GSerg]

1. VarPtr(p)
2. Работа, блин, с указателями, где же ещё. Скажи мне более быстрый способ записать число по указанному адресу на VB.

[Lord_Satan]

Не нефига, ты не понял,

1. VarPtr(p)

dim ggg& 'varptr(ggg)=1000000

|999999|1000000|1000001|1000002|1000003|1000004|

где то же хранится что переменная ggg ссылается именно на 1000000
вот как узнать адрес этого "где то"?

2. Работа, блин, с указателями, где же ещё. Скажи мне более быстрый способ записать число по указанному адресу на VB.

dim data&(255), p&
dim c&, pp&
p=varptr(data(0))
pp=varptr(c)

Копируем
GetMem byval p, byval pp 'или GetMem byval p, с
но ведь обычное присвоение
data(0)=c
работает в 3 раза быстрее

[GSerg]

Это ты не понял!

Никто (и я в первую очередь) не призывает работать с обычными переменными через указатели. Это очень удобно с API.
А VarPtr - не lvalue. Точка.

[Lord_Satan]

А VarPtr - не lvalue.

ты про это?
|999999|1000000|1000001|1000002|1000003|1000004|


GSerg
Раскажи как получит адрес ячейки, где хранится адрес переменной

[GSerg]

Никак, блин!
Если бы это было возможно, то VarPtr был бы lvalue!

[Ennor]

...
Раскажи как получит адрес ячейки, где хранится адрес переменной
...

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

[Lord_Satan]

Никак, блин!
Если бы это было возможно, то VarPtr был бы lvalue!

Объясни пожалуйста что такой lvalue.
И не может такого быть чтобы нельзя было получить
адрес адреса переменной, в VB нельзя,
но неужели с помощью ASM или Cpp этого не сделать?!?!

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

Да не, нафига мне адрес второй переменной,
смысл в том чтобы получить адрес адреса переменной,
а уж в него можно копирнуть другой адрес,
и это сделать можно, просто я не знаю как,
но всяко есть кто то, кто сможет сделать на ASM или Cpp
процедурку возвращающую такой адрес на адрес

[Ennor]

Ты сможешь это сделать только в том случае, если внутренняя реализация конкретного типа в VB использует схему двойного указателя. Наск. я помню, такая схема используется только в массивах. Может быть, еще в структурах, но я не уверен. Давным-давно (примерно так VB4) использовалась для строк. Во всех остальных случаях второй ступени указывания просто нет. Если ты, конечно, руками ее не сделаешь, но ему это как корове седло, извини...
По поводу lValue - RTFM по С++.
По поводу копирования адресов - CopyMemory().

[TEH3OP]

Тыкс, у нас тут два челобрека и один из них ТУПОЙ.

Если это не я, то:
Месир Lord_Satan, адрес ячейки памяти нигде не хранится, вернее он храниться в самой переменной, а ещё вернее, переменная -- это есть адрес в памяти. А уж сам язык програмирования, заботится о о том, чтобы обращаясь к переменной, вы с её содержимым работали. А для компа это адрес, а записывается он в стек. А стек это область памяти, а проще ещё (но не правильней) -- это массив 32-х разрядных чисел. А вааще, могу посоветовать вам, месир, почитать Дэна Эпплмана "Win32 API и Visual Basic".

[GSerg]

Ну зачем же сразу "тупой"...

Комп, разумеется, знает, кто у него где. Только эта табличка с переменными (или как там это реализовано) является частью IDE, а не частью процесса. Для процесса начальный пункт - адрес переменной, VarPtr. Когда делается exe, искомый тобой, Lord_Satan, адрес записывается в виде абсолютного числа в этот самый экзешник. Чтобы его найти, ты толжен всё дизассемблировать, а чтобы использовать... Ну это вообще.

А lvalue - это выражение, которое может стоять в левой части оператора присваивания. То есть это нечто, что можно изменить. VarPtr - не lvalue.

[Lord_Satan]

Тыкс, у нас тут два челобрека и один из них ТУПОЙ.
Если это не я, то: Месир Lord_Satan, адрес ячейки памяти нигде не хранится, вернее он храниться в самой переменной, а ещё вернее, переменная -- это есть адрес в памяти. А уж сам язык програмирования, заботится о о том, чтобы обращаясь к переменной, вы с её содержимым работали. А для компа это адрес, а записывается он в стек. А стек это область памяти, а проще ещё (но не правильней) -- это массив 32-х разрядных чисел. А вааще, могу посоветовать вам, месир, почитать "Win32 API и Visual Basic".

Поясню, что бы вы не заблуждались, насчёт своей "просвещённости"
то что я хотел нашлось, мой коллега оказалось в ASM рубит как папа Карло, он мне dll навоял, возвращающую адрес адреса,
но токо записать в него я немогу, IDE вылетает,
пишет что то типа "ошибка "адрес такой то", "адрес адреса" Нельзя в него "write""
мне же говорили что нельзя его ваще получить, нефига

PS Не в обиду любителям Дэна Эпплмана
но книга полное дер...ще, плагиат, я у других авторов в инете все это читал, до её выхода

2GSerg
Как говорил выше всё нашлось, только я искал в куске памяти моего приложения, (пару раз даже нашёл 1)оказалась предыдущая переменная 2)адрес отладочной строки), а оказалось что он чёрте где, и записать туда нельзя,
(хотя я под win98 не проверял)
спасибо за помощь

Эх это была моя последняя надежда, на хоть какое то подобие указателя

)))))))))))))))))))))))))
Создаем заместо массива кучу переменных
в SAFEARRAY.pvData передаём адрес последней переменной
дальше Массив(0)=100
sa.pvData=sa.pvData + 4
Массив(0)=200
sa.pvData=sa.pvData + 4
и т.д.
пользуйтесь на здоровье

[ANDLL]

Дорогой Вы мой! Не знаю чего написал Ваш друг, но приведу простой пример, А ВЫ МНЕ СКАЖИТЕ, ЧТО ЕЩЕ ЗА АДРЕС АДРЕСА?

Код на VB:

Private Sub Form_Click()
Dim a As Long
Dim b As Long
a = 100
b = 200
End Sub

Примерно то, что будет порисходить:

#Private Sub Form_Click()
#Dim a As Long
Помещаем в стек(push) 4 нуля
Dim b As Long
Помещаем в стек(push) 4 нуля
Теперь внимание! я точно не знаю, но где-то по-видимому хранится адрес "кончика" стека, который изменяется в следствии команд push и pop
#a = 100
Вычитаем из адреса "кончика" 8 байт(число 8 прошито в исходном коде - компилятор всегда знает, сколько байт будет отделять локальную переменную от "кончика" стека), и в эту ячейку копируем 00000064
#b = 200
Вычитаем из адреса "кончика" 4 байта, и в эту ячейку копируем 000000C8
#End Sub
pop'ируем 8 байт из стека(плюс еще конечно всякие служебные данные,типа информации об exceptions и прочее)

А теперь скажи мне, в каком месте хранится адрес переменной? Да не в каком! Все локольные переменные связаны, ну а если поменять адрес "кончика", то вообще не бог весть что случится.

[GSerg]

Наверное, функция имела вид

Код: Выделить всё

int* addressofasddress(int a) {return &a ;}

или

Код: Выделить всё

int** addressofasddress(int* a) {return &a ;}

Абсолютный бред в обоих случаях...

[ToT]

Так-с... Попробую объяснить человеку еще раз.
То что ты(Lord_Satan) называешь адрес адреса на самом деле не существует. Ты видешь в коде ggg, а компилятор види что-то типа 400B34, для него это как-бы настоящее имя переменной, и конструкции вроде "ggg=5" он заменяет на "mov 400B34, 05h".
Это значение(400B34) жестко прописывается в экзешнике при компиляции, и это будет то место в памяти, где будет храниться значение переменной ggg. Проанализаровав дизассемблерный листинг можно узнать это число(400B34), но это тебе ничего не даст, т.к. придется править его во всем коде экзешника да еще и не нарушить его, а делать это в рантайме... Наверное чуть легче, чем написать безглючный Windows. В общем узнать "адрес адреса" это что-то типа узнать имя переменной, в которой ты будешь хранить значение 5, а теперь вдумайся в тупость(это не в твой адрес) этого вопроса
Не знаю, что там наваял твой друг, но скорее всего это не то что надо, ведь даже в ассемблере не используется то что ты имеешь в виду, там тоже просто определяется переменная, а компилятор ей сам присваивает адрес в памяти. В общем, или ты нам что-то неправильно объяснил, или сам запутался с этими указателями.

[ANDLL]

Это значение(400B34) жестко прописывается в экзешнике при компиляции

Нет! Если переменная локальная, то ее адрес меняется, более того, одна переменная может одновременно иметь несколько значаений(вспомним рекурсию).
См. два поста назад. В экзешнике прописывается именно расстояние от кончитка, а не сам адрес переменной. А жесткие адреса есть только у глобальных переменных. И то не у Всех.
______
Извиняюсь за резкий тон, но истину надо установить!

[GSerg]

Да, меняется.
И что?
Даже если ты каким-то чудом узнаешь stack offset, как ты им воспользуешься, скажи мне?

[Lord_Satan]

dll которую мне сделали работает в Cpp 6.0(хотя там она мне не нужна)
в ВБ нет

Спасибо всем, я много чего нового для себя узнал

[GSerg]

Исходник оной я бы посмотрел...

[Lord_Satan]

Исходник оной я бы посмотрел...

я асемблера не знаю, но что то вроде оператора &

[BP]

Не, люди, ИМХО по поводу локальных переменных вы ошибаетесь. Локальные переменные находятся там же где и параметры процедуры.
Допустим
Call MyFunc(Arg1 as Long)

Собственно MyFunc
Sub MyFunc (Arg1 as Long)
MOV EAX,[EBP+8] - так получается первый параметр
DIM A As Long
A=5
Это записывается так:
MOV [EBP-4],5
А [EBP-4] не что иное как [EBP+FF-4] (FF при imm8 и FFFF при imm32).
End Sub

[ANDLL]

ИМХО, сами Вы ошибаетесь! Параметры процедуры хранятся в стеке. Там же, где и переменные. Так что, если ты не знаешь, что такое стек, то думаю

[BP]

Без коментариев.

[Approximator]

Мда... надо же так глумиться... адрес адреса... это здорово. Вне зависимости от того где что хранится (случаи действительно могут быть разными), адрес (а если называть вещи своими именами дескриптор) адресом и остаётся. Единственное, что Вы можете в зависимости от обстоятельств получать лишь часть десктиптора, или же (разумеется, бывает и такое) "относительный адрес". Однако, менять ни относительный, ни реальный адреса нельзя. Типа: "где находится ул. такая-то, дом такой-то?" Естественно, по тому адресу, который Вы (Лорд...) вопрашаете. Другой вопрос, если Вы не знаете, как туда попасть. То есть, в Вашем случае необходимо изменить вопрос. Зачем менять адрес переменной на какой-то иной? Что за дурь? Когда ПРОЩЕ переписать значение из этой области памяти в то место, которое Вам нужно (то есть, по новому адресу). Не надо "переименовывать улицы"... дорогого будет стоить.



У меня вопрос к GSerg'у по поводу его стати про Ассемблер в VB.
Сначала, спасибо, очень интересная тема.
Я посмотрел Ваш пример. Однако, вся штука в том, что Вы всего лишь оптимизируете работу цикла (естественно, в VB тело цикла по причине сложноустроенности "раздуто", вследствие чего при итерации задержка накапливается). К чему я клоню? К тому, что при возрастании сложности тела цикла разница во времени между Asm'овским приложением и (даже!) VB реализацией будет стираться. И ещё, неплохо было бы, если весь Asm блок можно было бы генерить динамически (у Вас идёт сначала создание Asm'овской процедуры и по сути затем Вы её юзаете, просто не очень обычным способом, другое дело динамическая генерация произвольного). Или я не доконца понял Ваш пример?

[GSerg]

2 Approximator
Мы тут на форуме обычно на ты, это не обижает, а объединяет. Хотя и готовы выслушать субъективные возражения, буде таковые имеются. Но пока, если ты не против...

Суть примера вовсе не в оптимизации способа суммирования элементов массива.
Изначально у меня был некий cFuncCall, от которого сейчас довольно мало осталось. Это был пример вызова функции из динамически загружаемой библиотеки. Реализовано было через Variant ParamArray. Медленно, всё-таки, на мой взгляд. Я немного усовершенствовал (как мне кажется) работу цикла, передачу параметров и вообще... Но первоочередная задача была всё та же: дать возможность осуществлять вызов функции по указателю. И всё. Правда, это очень многое даёт. Динамически генерируемая ассемблерная вставка у меня в коде делает единственную вещь: push для всех параметров, call и ret. Ну нет в VB встроенной возможности вызывать функции по указателю. Поэтому так. Как юзер воспользуется данной новоприобретённой фичей - это уже вопрос, выходящий за рамки данного модуля класса. Если нужно вызывать динамически генерируемый код - на здоровье. Отводим память, генерируем его там, а адрес начала передаём в CallFunction. Потому что это всего лишь базовый кирпичик, дающий доступ к хорошим вещам aka "вызов по указателю". А асм-компилятор я, может, и собирался замутить, но это уже отдельная история, не про этот пример. Я просто упомянул в этом примере, что и это возможно, и даже готовая асм-функция там есть, но это, опять же, лишь для демонстрации ещё одной возможности использования вызова по указателю, а именно хранения исполняемого кода в ресурсах.
Просто удобно это, по указателю вызывать. "Чтобы было", как говорится.

2 BP & ANDLL
Параметры функции хранятся там же, где и локальные переменные. Отличие не качественное, а количественное. При вызове функции, перед выполнением самой первой её команды, стек имеет вид

адрес возврата
параметр 1
параметр 2
параметр 3

Если в процедуре есть локальные переменные, то выполняется sub esp, imm8, и стек начинает выглядеть так:

переменная 3
переменная 2
переменная 1
адрес возврата
параметр 1
параметр 2
параметр 3

[Approximator]

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

Уговорил.

Суть примера вовсе не в оптимизации способа суммирования элементов массива. Изначально у меня...

Это, как раз понтно. Я высказал своё мнение относительно того, что получилось. Просто пример считает тики и это, вроде бы, должно было что-то доказывать/показывать/подтверждать. Вот именно эту сторону я и охарактеризовал.

Я немного усовершенствовал (как мне кажется) работу цикла, передачу параметров и вообще... Но первоочередная задача была всё та же: дать возможность осуществлять вызов функции по указателю. И всё. Правда, это очень многое даёт.

Ни в коем разе не пытался это оспорить.

Динамически генерируемая ассемблерная вставка у меня в коде делает единственную вещь: push для всех параметров, call и ret. Ну нет в VB встроенной возможности вызывать функции по указателю. Поэтому так. Как юзер воспользуется данной новоприобретённой фичей - это уже вопрос, выходящий за рамки данного модуля класса...

Понятно, умному должно было хватить. Мне не хватило. Ты пойми, я не критикую идею. Идея, спору нет, замечательная. Просто, не всё ясно.
Скажем так замечательные функции работы с указателями, позволяют легко преобразовывать "строковые" байты в "числовые" байты:

Код: Выделить всё

Public Declare Function GetMem4_ Lib "msvbvm60" Alias "GetMem4" (ByVal pSrc As Long, ByRef pDst As Long) As Long

Public Sub StrBytesToLongSh(ByRef vStr As String, ByRef vLng As Long)
  'Сюда необхдимо посылать строку "правильной" (не меньше) длины и уже после StrConv(Str, vbFromUnicode)
  GetMem4_ StrPtr(vStr), vLng
End Sub

Public Sub StrBytesToLongEx(ByRef vStr As String, ByRef vLng As Long)
  Dim lStr As String * 4, lAL As Byte
  lAL = Len(vStr)
  If lAL > 4 Then lAL = 4
  lStr = StrConv(Left(vStr, lAL) & String(4 - lAL, Chr(0)), vbFromUnicode)
  GetMem4_ StrPtr(lStr), vLng
End Sub


Однако, мне непонятно, как "числовые" байты пихать обратно в строки (GetMemStr явно не подходит - IDE рушится). Насколько вообще можно "достукиваться" до кладовых памяти этими функциями или, например, CopyMemory, FillMemory, MoveMemory etc?
Можно ли напрямую пихать байты из "страницы" где хранится изображение в строку (и обратно)? Был бы весьма признателен, если бы ты не пожалел времени и рассказал насколько это возможно подробно.

[GSerg]

Да на здоровье.

Код: Выделить всё

Option Explicit

Private Sub Form_Load()
  Dim a As String, b() As Byte
 
  Me.AutoRedraw = True
 
  a = "проверка"
  b = a
  Me.Print "Строка a содержит " & Len(a) & " символов."
  Me.Print "Массив b содержит " & UBound(b) - LBound(b) + 1 & " байт. Потому что Юникод."
 
  Me.Print
 
  a = "проверка"
  b = StrConv(a, vbFromUnicode)
  Me.Print "Строка a содержит " & Len(a) & " символов."
  Me.Print "Массив b содержит " & UBound(b) - LBound(b) + 1 & " байт. Потому что Анси."
 
  On Error GoTo oops
  a = b
  b = a
  On Error GoTo 0
 
  Me.Print "И присвоение работает без ошибок."
  Exit Sub
oops:
  Me.Print "Присвоение не удалось!"
End Sub

Так уж сложилось, что String и Byte() - assignment-compatible

При присваивании создаётся копия. Если нужно создать массив, ссылающийся на уже существующую строку, то это через методику, описанную в статье про SAFEARRAY

[Approximator]

Спасибо. Как обычно вопрос. А если у меня "страница" это CompatibleDc к форме (или PictureBox'у), как в этом случае? Нет ли пути "прямее" ?

[GSerg]

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

[Approximator]

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

А чем это может помешать? То что должны быть какие-то простые методы несмотря на всякю закрытость это очевидно, так как иначе такие процессы, как сохранение "страниц" на винте были бы долгими и, по-твоему, непредсказуемыми... Мне кааца, что должно здесь быть какое-то решение. Вполне допускаю, что это возможно. Если огрублять проблему, то можно сказать, что по сути "всего лишь" необходим такой DC, который был бы compatible со строкой.


И ещё, возвращаясь к вопросу о строках и числах. А как быстро скопировать байты произвольного числа (Long, Double, Decimal etc) в строку? С массивом байтов несколько неудобно.