Robert Meek wrote:
Okay everybody...let's play nice! <g> It's very often that weYou cannot say that you had never used pointers. If you had deal with Delphi objects before, it means you used pointers. Because all the Delphi class variables are the pointers. When you create a new object "MyObject := TMyObject.Create" Delphi allocate some space on the memory for this object, and returns a pointer to this memory location. MyObject is the pointer which is referencing to your object. Because the pointer holds the address of another variable.
misunderstand what someone really means in a thread of this sort and that's
because we tend to write about such topics based upon our own past
observations. And these are quite subjective in nature. I also didn't understand what you, Oktay, were trying to say and so
had assumed that you were making a very broad statement about pointers and
the effect their general use has on a program's performance. Now of course
I realize that this is not what your intention was.
Still though, it would be very helpful, and I for one would be
grateful, if you could continue this thread by adding a code example or two
which will show how, when, why, and where using pointers to handle a
particular task will result in better performance than if you were to simply
employ OOP and the rest of the Delphi paradigm as needed. I doubt that it
is your use of pointers that provides better performance, but the more
efficient code that you write when using them as opposed to not. And this
may in turn be so simply because you Grok pointers to a greater degree than
the alternatives. I've seen a lot of that kind of thing over the last couple years
when reading other's code...especially when the programmer was from the "old
school"! I myself, am completely self taught except for the patient
expertise of Stephen Posey and others here on the list(s) who devote so much
of their time answering my dumb questions, and as a result, I'd have to take
three steps back, a deep breath, and probably spend an hour or so reviewing
material on this topic were ever I was asked to write even the simplest code
using pointers! Why? Because when you have to learn on your own, and by
doing, you can't always take time out to fully embrace certain methods
unless and until you come up against an actually need for them! And so far,
in all these years and with better than 30 applications of mine in use by
small businesses, I have NEVER yet needed to use them! <g> It's just like a
If you mean the classical way of using pointers, yes you might never need to use them. But you really need to use them when you are working on memory stuff and API calls. If you dont use pointers and never like to use them, this will not make you a newbie programmer. Please notice that i had never said that you should use all the variables as a pointer !! I just mean that you might choose to use them whenever it needs. Sometimes you can improve your application's performance with these kinds of critical decisions. I would suggest you to not to use the pointers till you feel comfortable with it. Because as much as the advantages of the pointers, there is a lots of disadvantages and the most serious one is, when you are using pointers, your program might be hard to debug. It's easy to make mistakes when you are using them. For example when the times you forgot to use "^" symbol or when you forget to allocate a part of memory before to use them. In these conditions, after you run your application, all you'll get will be an AV error which is so hard to debug!!
When you create a record like this :
var TestRec: TMyRecord; begin TestRec.DoSomething; // .. end;
This is a local allocation of object. It means the memory provided from the program's stack. That was a big problem in 16 bit programming because the stack size was so little. Pointers were using to fix this limitations. Charlie Calvert's "Delphi Unleashed" book has some chapters about it.
var pTestRec: PMyRecord; begin New(pTestRec); try pTestRec^.DoSoemthing; finally Dispose(pTestRec); end; end;
This is the dynamic allocation of object. It means the memory provided from the heap. Heap is not limited. I mean you can allocate large amounts of data from the heap. Because the heap = your RAM + your free hard disk space :)
That is means that the first one, i mean the one which is allocated from the stack is faster, because it's allocated from the local stack. Also there is some conditions that you'll find, using pointers are faster. For example when you need to make a couple of variable be the same. It's much more faster with pointers because all you need to do is to assign one pointer to an another and only 4 bytes of informantion will move. Both will point out the same memory location. So finally you'll have the same data.
After you feel comfortable with pointers, i would recommend to use them whenever it needs. But keep in your mind that using pointers might make your program harder to debug. Also remember that pointers are not hell.
Kind Regards,
Oktay Sancak
_______________________________________________ Delphi mailing list -> [email protected] http://www.elists.org/mailman/listinfo/delphi
