PureBasic Forums - English

even if you define the procedure parameter as pointer, it is handled as linkedlist, thus you can't use it as pointer.

freak wrote: pcfreak:
I think you misunderstand this: *Test.TestStruct() defines a linkedlist OF pointers.
So the elements in the list are pointers, not the list itself.

When you call AddElement() on such a list, you get a new empty pointer, just like when defining a variable *Pointer.
You have to assign some memory location to it in order to work with it.

Kaeru Gaman wrote:hi.

if you want to post quicklinks (without URL-tags) you have to leave spaces around them.
( http://www.purebasic.fr/english/viewtop ... inked+list )


I don't get the point really... not your's but the code's
there seem to be some problems, but where is it exactly....?
my main problem is, that I never used pointer notations to reserve elements.

the memory usage seems to be clear for me.
you add 10000 elements that need 10008 bytes each and surely get them.
if you alter the pointer afterwards to some new allocated memory,
of course the memory usage should double.

but I don't get the point why the pointer to the old allocated mem should be NULL....

maybe the mem is allocated but the pointer to it isn't connected correctly?

It's what I think!

additionally just for interest:
what is the advantage in this pointer-notation for using AddElement anyways?

I use it in recursive code, who a linked list is created in each entry call, and i use the pointer on the linked list to work with it.

I would use a normal call of AddElement, you can use a pointer access after that in every case....

it's just that...
if the basic idea to use AddElement with a pointer was wrong,
then it's not a bug of PB but a bug in this form of programming....

freak wrote:Of course the memory usage grows. You call AllocateMemory() 10000 times, but not one FreeMemory()

pcfreak:
I think you misunderstand this: *Test.TestStruct() defines a linkedlist OF pointers.
So the elements in the list are pointers, not the list itself.

When you call AddElement() on such a list, you get a new empty pointer, just like when defining a variable *Pointer.
You have to assign some memory location to it in order to work with it.

btw, linkedlists as procedure parameters are always passed by reference.

Demivec wrote:@JJ
This is how you should be performing the actions you needed:

Code: Select all

Structure TestStruct
  Text.b[10000]
EndStructure

Procedure SetStructList(val, Test.TestStruct())
  AddElement(Test())
  ; Uncomment the following line(s) to see memory reserved twiced (use the task manager to see the trouble)
  ; 100 MB reserved when the next line is commented, and it seems normal
  ; 200 MB reserved when the next line is uncomment, it's the problem
  ; *Test() = AllocateMemory(SizeOf(TestStruct))
  ; UnCommented lines produce "Pointer is null." error since PB v4.02, if the previous line is commented
  Test()\Text[0]=val
EndProcedure

Procedure Test()
  NewList toto.TestStruct()
  
  CallDebugger
  For I=1 To 10000
    SetStructList(I%$FF, toto.TestStruct())
  Next
  
  CallDebugger
  ClearList(toto())
EndProcedure

;- Main
Test()
End 

Your procedure SetStructList() is passed a linked list by reference which is not the same as passing a pointer to it. This means the procedure should declare the variable as a linked list type. It should address it the same as a linked list.

The only change necessary to make the correction is to remove the "*" from your variable so that it is not confused with a pointer to a structure (not a linked list as you desired), see comment below. All the comments in SetStructList() are now irrelevant.

In the code you presented it seems the compiler can't tell if it should treat the variable *Test().TestStruct() as a pointer to a linked list, or a generic pointer, or perhaps a pointer to a structure (who knows, maybe Fred?:)). This is evident from the code you first presented. I don't quite understand it but, if you checked the value of the pointer while in the procedure it points to a structure of TestStruct. It can access it but, it seems to treat every element of the structure as a pointer also. The two interpretations run into conflict. For instance, it can't acess things in the structure that have a value of zero and says they have a null pointer. Also, when you reserve memory space for a structure and assign it to the pointer with

Code: Select all

*Test() = AllocateMemory(SizeOf(TestStruct))

it assigns the value of the memory pointer (a Long) to the location pointed to by the structure. I think there is a bug or undesirable feature in the way this value is assigned. It ignores the "structure" format and simply stores the 32 bit value starting at the first memory location. By viewing the value of the structure after this assignment it is shows that the first four entries in the array of bytes were changed. THIS is what I would think is unexpected and an issue to be resolved or avoided.

As stated earlier though, YOUR problem is the misuse of variable types. If you got away with it in the past your luck seems to have run out.