не могу получить указатель на строку

Глупо не могу получить указатель на строку из функции wStr.
Пишу в этот раздел, потому что "глупо". Вопрос кажеться элементарным.

Мне нужен указатель
dim w as wstring ptr

У меня есть обычная строчка,
dim s as string
s = "test string"

Я её хочу перегнать в wstring

print wstr(s)
срабатывает.

А указатель не могу получить!
w = @wstr(s)


Причём вот так:
w = @wstr("test string")
всё нормально.

В примере конвертируеться строчка zstring, у меня работает.
Но в мануале zstring не описан вообще.


Либо это я уже допился, либо это глюк в fb.

Сейчас придумал вот такой вариант

Код:


dim ws as wstring ptr
ws = allocate( len(k) * len(wstring) )
*ws = wstr(k)


А дальше указатель передаёться в другую функцию. Хотел малой кровью, в одну строчку. А вышла вот такая бяка.

Может быть кто-нибудь подскажет, где можно найти исходники функций. А вдруг повезёт и я пойму в чём ошибка и даже исправлю её!?

Код:

#include "windows.bi"
dim w as wstring*20
dim q as wstring ptr
dim s as string
s = "test string"
w=wstr(s)
q=@w
MessageBox(0, *q, "hi", MB_OK)

пардон, времени нет объяснить, работой загружают((

Прости, но ты темы не просёк. Мой обходной вариант и то лучше. У тебя жестко 20 байт, а у меня входная строка неизвестной длины.

Но юморто даже не в этом, а в том, что

Код:


dim s as string
s = "my testing string"
print *@wstr(s)


Неработает!

wstr() должна возвращать wstring, но когда передаёшь ей string, она возвращает какую-то хрень.

Вот это работает:

Код:

dim s as string        ' строка которую хотим конвертировать
dim x as wstring ptr ' указатель  на переконвертированную строку   
s = "my testing string"
x= Allocate( Len(s) * Len(WString) )  ' создаем память для хранения строки
*x = wstr(s)                    ' сохраняем переконвертированную строку S по адресу X
print *x                          ' Выводим строку хранящуюся по адресу X
sleep

На мой взгляд, с wstr() все впорядке

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


В другую функцию нужно передать указатель wstring ptr.

Код:


create( @"hello" ) ' работает

create( @wstr("hello") ) ' тоже работает, и так делать правильно.

dim s as string
s = "hello"
create( @wstr(s)) ' не работает, хотя должна!


Чего я не понимаю!

Код:

 ' вот такая у меня примерно функция create
function create( byVal k as wstring ptr ) as integer
print *k
return 1
end function


ну привет.
а вот какой код будет работать

declare function create(k as wstring ptr) as integer
dim s as string
s="hello"
create wstr(s)
sleep

function create(byval k as wstring ptr) as integer
print *k
function = 1
end function

почему строка
create wstr(s)
без собаки-
да видимо когда мы передаем в функцию другую функцию, в данном случае в
create(wstr(s)
wstr возвращает нашей функции указатель на уже переконвертированную строку.
и вообще, старайтесь отходить от этих майкросовтовских штук типа string, лучше пользоваться zString, это тип данных, как в си, строка с завершающимся нулем,
просто с указателями намучаетесь.
да конечно zString, не позволяет сделать динамичную строку, но вот следующий
код у начинающих не сработает
dim test as string
dim testPtr as zstring ptr
test="как всё красиво"
testPtr=@test
print *testPtr

дело в том, что во FreeBasic, нельзя вот так прямо через @, узнать указатель на
строку. есть функция strptr, вот с помощью нее, следующий код будет работать.

dim test as string
dim testPtr as zstring ptr
test="как всё красиво"
testPtr=strptr(test)
print *testPtr

ну а вот как с помощью zString можно обойтись без лишнего кода типа StrPtr

dim as zString * 16 test
dim testPtr as zstring ptr
test="как всё красиво"
testPtr=@test
print *testPtr

там где не нужны строки с нефиксированной длиной, пользуйтесь Zstring, например если у вас есть куча заранее написанных сообщений, зачем им выделять непонятно сколько памяти, конкретно, сообщение HelloWorld занимает 10 байт, выделяем Zstring 11 байт.
почему 11 байт? строки типа Zstring, завершаются нулем, и для него тоже нужен байт, хотя я точно не мудрил, может можно и 10 байт, возможно компилятор сам подставляет нуль, пусть начинающие сами помудрят.

Интересно! Спасибо, я попробую.


Что такое zstring и как его пользовать мы конечно же знаем. А вот то что при вызове функции не нужна собачка, это конечно интересно крайне.


Я тут например заметил, что моя функция, create просит wstring ptr, а можно спокойно передать строку так:
create "hello, pipls!"

Без собачки, и без явной конвертации. Компилятор сам поймёт что к чему.

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

История ещё не закончилась. Я продолжаю тупить! На этот раз вункция mid().

Код:



[
' создаю строчку
dim text as wstring * 20
text = "hello., world!"
print text
' работает, просто проверка

' создаю указатель
dim ws as wstring ptr
ws = @text
print *ws
' указатель работает нормально

' хочу выдрать слово "hello"
ws = @mid( @text, 1, 5)
print ws
print len(*ws)
print *ws
sleep


А что ты хочешь получить операцией "@mid()"? Адрес размещения функции?
Думаю, что подразумевается адрес выделенной подстроки... Ну так её же ещё нет - что бы она стала объектом памяти (адрес которого можно получить операцией @) вначале её надо разместить в переменной. Т.е. вместо "@mid" над написать:

Код:

dim s as wString * 20
s = mid (text, 1, 5)
ws = strptr (s)

Кроме этого, зачем ты в первом аргументе функции mid передаёшь УКАЗАТЕЛЬ ("@text")? Должно быть просто "text"

Я хотел получить указатель на подстроку.
Это конечно вопрос относительный. В смысле, что именно возвращает mid. Но как я решил, она формирует в памяти строчку, указатель на которую я собственно и жажду. А копировать ещё раз меня не катит, так как бессмысленно тратяться ресурсы.
Ну да ладно, именно этот вопрос я решил, воспользовался альтернативным вариантом.
Но уже чисто ради интереса хотелосьбы знать, возможно ли получить указатель?

Собачек же я тыкал во всюда. Все 4 варианта перебрал. И кстати перед "text" официально символ "@" нужен, т.к. text это wstring, а mid требует wstring ptr.


С этими указателями вообще всё странно и непонятно.
Я пока не могу усвоить, когда нужно делать новую строчку, а когда старой хватит.
У меня в программе многочисленные строковые преобразования. Ну и хочеться их оптимизировать. Но чтобы это не приводило к краху.

Вот например, когда нужно высвобождать память?

Код:


dim ws as wstring ptr
ws = allocate(10)
*ws = "12345"

' а теперь я хочу поменять значение
ws = allocate(20)
*ws = "abcdefghij"


Я веть должен в этом случае высвобождать строку, перед новой?
[code
deallocate(ws)
[/code]

Кстати, странно, указатель всё ещё работает, после deallocate, и указывает на строчку. Я так понимаю, теперь она есть, но может быть затёрта?

Вообще freebasic автоматически что-нибудь затирает или это полностью моя обязанность?

Вот например строка из функции

Код:


function myfun()
dim dat as wstring *20
dat = "hello, world!"
return @dat
end function


Функция возвращает указатель на строчку. Но по идеи эта строчка должна быть затёрта, так как переменная dat локальна и должна быть уничтожена!
На практике же такое не происходит. Или строка всё же высвобождаеться, а указатель просто содержит адрес на мусор?

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

Я хотел получить указатель на подстроку.
Это конечно вопрос относительный. В смысле, что именно возвращает mid. Но как я решил, она формирует в памяти строчку, указатель на которую я собственно и жажду. А копировать ещё раз меня не катит, так как бессмысленно тратяться ресурсы.
Ну да ладно, именно этот вопрос я решил, воспользовался альтернативным вариантом.
Но уже чисто ради интереса хотелосьбы знать, возможно ли получить указатель?

Собачек же я тыкал во всюда. Все 4 варианта перебрал. И кстати перед "text" официально символ "@" нужен, т.к. text это wstring, а mid требует wstring ptr.


С этими указателями вообще всё странно и непонятно.
Я пока не могу усвоить, когда нужно делать новую строчку, а когда старой хватит.
У меня в программе многочисленные строковые преобразования. Ну и хочеться их оптимизировать. Но чтобы это не приводило к краху.

Вот например, когда нужно высвобождать память?

Код:


dim ws as wstring ptr
ws = allocate(10)
*ws = "12345"

' а теперь я хочу поменять значение
ws = allocate(20)
*ws = "abcdefghij"


Я веть должен в этом случае высвобождать строку, перед новой?
[code
deallocate(ws)
[/code]

Кстати, странно, указатель всё ещё работает, после deallocate, и указывает на строчку. Я так понимаю, теперь она есть, но может быть затёрта?

Вообще freebasic автоматически что-нибудь затирает или это полностью моя обязанность?

Вот например строка из функции

Код:


function myfun()
dim dat as wstring *20
dat = "hello, world!"
return @dat
end function


Функция возвращает указатель на строчку. Но по идеи эта строчка должна быть затёрта, так как переменная dat локальна и должна быть уничтожена!
На практике же такое не происходит. Или строка всё же высвобождаеться, а указатель просто содержит адрес на мусор?

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

Eric-S пишет:Я хотел получить указатель на подстроку.
И кстати перед "text" официально символ "@" нужен, т.к. text это wstring, а mid требует wstring ptr.

Это ты где вычитал? Вот что пишет о mid официальный хэлп:

MID[$](text, start[, length])

Description
MID returns a string containing the characters from the text string, starting at start, length characters long.

Eric-S пишет:
С этими указателями вообще всё странно и непонятно.

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

Eric-S пишет:
Вот например, когда нужно высвобождать память?

Код:


dim ws as wstring ptr
ws = allocate(10)
*ws = "12345"

' а теперь я хочу поменять значение
ws = allocate(20)
*ws = "abcdefghij"


Я ведь должен в этом случае высвобождать строку, перед новой?

В данном коде ты не меняешь содержимое строки, а создаёшь новую строку - поэтому в памяти у тебя обе.
Для замены тебе надо было не вызывать повторно allocate (), а просто поместить новую строку по старому указателю . Либо перед вторым вызовом allocate () вызвать deallocate (ws) - тогда с некоторой вероятностью компилятор действительно разместит новую строку на адресах, ранее занимаемых старой.

Вообще freebasic автоматически что-нибудь затирает или это полностью моя обязанность?

Нет, не затирает. deallocate (ptr) всего лишь говорит компилятору, что обоасть памяти, на которую. ссылается ptr, теперь ненужна программе и её можно использовать при следующем вызове allocate ()

Вот например строка из функции

Код:


function myfun()
dim dat as wstring *20
dat = "hello, world!"
return @dat
end function


Функция возвращает указатель на строчку. Но по идеи эта строчка должна быть затёрта, так как переменная dat локальна и должна быть уничтожена!
На практике же такое не происходит. Или строка всё же высвобождаеться, а указатель просто содержит адрес на мусор?

У меня print myfunc () распечатал таки мусор...

justar пишет:
Это ты где вычитал? Вот что пишет о mid официальный хэлп:

MID[$](text, start[, length])

Description
MID returns a string containing the characters from the text string, starting at start, length characters long.

Тамже в мануале, тока немного выше:

Declare Function Mid ( ByVal
str as WString Ptr, ByVal
start as integer, ByVal n as integer ) as WString

justar пишет:
В данном коде ты не меняешь содержимое строки, а создаёшь новую строку - поэтому в памяти у тебя обе.
Для замены тебе надо было не вызывать повторно allocate (), а просто поместить новую строку по старому указателю . Либо перед вторым вызовом allocate ()
вызвать deallocate (ws) - тогда с некоторой вероятностью компилятор действительно разместит новую строку на адресах, ранее занимаемых старой.

Я воспользовался именно allocate, поскольку строки могут быть разных длин. Если вторая меньше, то простая замена прокатит, а если больше, то она просто не влезет. Но если вторая строка в сотни тысяч раз короче первой, то думаю, что высвободить память тоже будет верно.
А вот куда там оно всё разместиться, меня не очень-то колышет, ведь allocate возвращает мне указатель на свободный фрагмент. Т.е. в моём случае указатель измениться.

И кстати что делает realocate?

justar пишет:
У меня print myfunc () распечатал таки мусор...

Ага! А как тогда правильно сформировать строку и вернуть на неё указатель? С помощью allocate, чтобы мусора небыло?

привет. процедура deallocate- это не процедура компилятора, а реальная процедура в бинарнике. приведу пример:
компилируем: fbc.exe -R test.bas
FreeBasic
dim as zstring ptr test
test=allocate(12)
*test="space world"
deallocate test
sleep
ассемблер
mov dword ptr [ebp-8], 0 'указатель test
push 12 'длина строки
call _malloc 'выделяем память. в eax, функция возвратит указатель на выделенный блок
add esp, 4
mov dword ptr [ebp-8], eax 'запишем указатель iз eax в ebp-8
push 0
push 12'длина строки
push offset _Lt_0003 'тут лежит наша строка, тоесть текст
push 0
push dword ptr [ebp-8] 'сохраним указатель
call _fb_StrAssign@20 'добавляем текст в нашу выделенную оьбласть
push dword ptr [ebp-8] 'сохраним указатель
call _free 'вот она deallocate
add esp, 4
push -1
call _fb_Sleep@4

ну а теперь по поводу mid,left,right
если у нас есть заранее отведенная память, нафиг ненужны эти функции, у нас есть указатели, которые работают по любому быстрее. если мы используем строки с нефиксированной длиной, может понадобится только right. самая страшная ошибка, это с помощью этих функций, писать какой-нибудь алгоритм связанный с переносом строк. я сам по глупости раньше так делал. и думал, почему так медленно. новичкам совет: старайтесь избегать функций left,mid, и т.д. покрайней мере, если вы надумали писать текстовый редактор. не забывайте про указатели! если вы задумали написать простую текстовую игрушку, где длина текста ограничена экраном, ну там и leftами побаловатся можно.

Электрик! Да это понятно!
allocate и deallocate конечно же реальные функции.

А если не используя mid, как быстро получить указатель на подстроку?

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

А без понимания всех этих внутренних механизмов, можно вообще всё развалить.


Например мне пришлось тут сделать лишнее копирование строк, потому, что с указателями я потерял несколько фрагментов, взамен получив мусор.
И что такого плохого в mid? Операция примитивная! А если везде использовать свои функции, то не проще ли язык свой использовать?

новичкам совет: старайтесь избегать функций left,mid, и т.д.

Не думаю, что это правильно, особенно для новичков

А кстати, чем тогда новичкам пользоваться?


Я вот сейчас написал функцию копирования подстроки, и по моему она работает медленнее, чем mid. Извращаться же с ассемблером не собираюсь!

Eric-S пишет:Электрик! Да это понятно!
А если не используя mid, как быстро получить указатель на подстроку?

Строго говоря, с помощью mid () ты его как раз и не получишь. C её помощью можно только создать новую строку, содержащую искомую подстроку, и уже на неё получить указатель. А это не совсем то, что ты формулируешь в условии задачи.

А вот как получить искомый тобой указатель:

Код:

Dim s As ZString * 10
Dim pStr As zString Ptr
pStr = StrPtr (s)    ' указатель на начало строки                             
pStr = pStr + 3    ' указатель на её подстроку, начинающуюся с третьего символа
Print *pStr


И что такого плохого в mid? Операция примитивная! А если везде использовать свои функции, то не проще ли язык свой использовать?

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

ShenZN пишет:Не думаю, что это правильно, особенно для новичков

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

justar, прошу прощенья. Постараюсь лучше формулировать вопросы.

Мне именно нужно создать подстроку, имея указатель большой строки s,
начало b и длину подстроки l.
А потом получить указатель на эту новую строку r.
Сейчас я делаю так

Код:


dim r as wstring ptr
r = allocate( l * len(wstring) )
*r = mid( *s, b, l )


А можно и посимвольно скопировать эту подстроку, но как я понимаю, это займёт больше времени.

Код:


dim r as wstring ptr
r = allocate( l * len(wstring )

dim i as integer
for i = 0 to l - 1
*(r + i) = *(s + b + i - 1)
next
*(r + l) = 0


Вот примерно так. И какой вариант будет быстрее? Или можно ещё как-то оптимизировать?

Да, кстати, переносимость весьма немаловажный фактор.

Что мне ненравиться в моём первом варианте, а то, что приходиться ещё раз запрашивать память и копировать в неё подстроку.
И ещё мне непонятно, что дальше будет с той подстрокой, которую вернула mid.
Она будет освобождена или так и останеться висеть в памяти?

Eric-S пишет: А можно и посимвольно скопировать эту подстроку, но как я понимаю, это займёт больше времени.

Код:


dim r as wstring ptr
r = allocate( l * len(wstring )

dim i as integer
for i = 0 to l - 1
*(r + i) = *(s + b + i - 1)
next
*(r + l) = 0


Это должно работать быстре. Уже хоья бы потому, что отсуствует операция вызова подпрограммы.
А если посмотреть, как устроена функция fb_str_mid ().. становится ещё интереснее. Во-первых, она написана на Си. И вот её ключевое место (до него ещё довольно много кода. проверяющего правильность аргументов, а после него идёт код формитрования выходной строки):

Код:

 if (dst != NULL) {
      FB _MEMCPY (dst->data, src->data+start, len)
      dst->data[len] = '\0'}


Функция же FB_MEMCPY устроена вот как:

Код:


FBCALL void FB_MEMCPY( unsigned char *dst, unsigned char *src, int bytes )
{
   int i;
   
   if( (dst == NULL) || (src == NULL) || (bytes <= 0) )
      return;

   FB_LOCK();
   
   for( i = 0; i < (bytes & 3); i++ )
      *dst++ = *src++;
         
   FB_UNLOCK();
}


Т.е. внутри себя mid () делает примерно тоже самое, чтоты написал, плюс к этому пердшесвует куча проверок и два внутренних вызова функции (FB_LOCK () и FB_UNLOCK ()). Так что быстрее твоего примера mid () работать ни как не может - она должна работать существенно медленнее. Впрочем, это можно проверить примерно таким кодом:

Код:

dim as single t1, t2
dim as wstring s
dim as string ptr r
t1 = TIMER
r = allocate( l * len(wstring) )
*r = mid( *s, b, l )

t2 = TIMER
print t2-t1 ' мы получили время работы mid ()

t1 = TIMER
myfunc (r, s, b)  ' вызываем твою функцию копирования строки (можешь просто подставить свой код)
t2 = TIMER
print t2-t1 ' теперь мы получили время работы твоего копирования


И сравни выведенные цифры - сразу увидишь, что быстрее...

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

12 | segmentation violation signal |  

( Т.е. err вернула код 12, а я его так интерпретировал.)

Причём оба раза в allocate передаёться переменная integer с числом 10.
Впервые столкнулся с этим, и просто не знаю что делать.

привет. eric, я не за allocate, тем более коггда мне не нужен большой объем памяти проще использовать dim. ну а поповоду твоей проблемы с allocate, попробуй reallocate, переопределяет существующую выделенную память. синтакс:
результат = reallocate(указатель на выделенную память, длина)
результат- указатель куда поместится адрес на переопределенную область,
указатель на выделенную память- указатель полученный allocate,
длина- длина выделяемого блока.

попробуй заранее подготовить массивы, чем после каждого вызова функции, их переопределять. к тому же, если ты собираешься перелопачивать библиотеку, старайся как можно меньше делать всяких определений. у нас сейчас память у всех стоит большая, не кто нам не мешает создать массив 10 мегабайт и в нем крутиться. это будет быстрее, чем постоянно определять массивы, причем разной длины, покрайней мере allocate.
с dim все понятно, там все просто, регистр esp, указывает на вершину стека, а регистр ebp, указывает с какого места мы начинаем вносить или забирать из стека информацию. единственное, переменные, созданные в не функций, процедур, забиваются нулями, а переменные созданные в нутри функций, процедур- нет.

Массивы меня связывают.
Хотя какой-то резон в этом всё же есть.
Но вот в данном случае, мне нужно распарсить строчку, в которой может быть 0 слов или до х*я! А назначать верхний потолок меня не катит.
Переопределять же массивы в классах нельзя.

reallocate, спасибо за объяснение, но в данном случае это неподходит.

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

Код:


dim r as wstring ptr
r = allocate ( len(*s) * len(wstring) )
*r = *s


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