From this I can only assume that Delphi has an internal table that the
pointer points to, this in turn points to the memory allocated against that
pointer. A kind of Microsoft VTable.

Its all so I can exactly understand what is being passed for examples such
as the READ method of a TMemoryStream (takes an untyped var).  Knowledge is
Power!

Thanks - MarkM

var
  x: Pointer;
  y: array[1..1000] of Byte;
begin
  GetMem(x, 1000);
  ...ReadBuffer(x^, 1000);
  ...ReadBuffer(y, 1000);

IOW, pointers in Delphi are like pointers in every other decent
programming language.

--
Stefan Hoffmeister    (http://www.econos.de/)
No private email, please, unless expressly invited.

If I do the following

pPointer : Pointer;
pCharacter : PChar;

pCharacter := StrAlloc(100);
StrPCopy(pCharacter, '0123456789');
pPointer := Addr(pCharacter);

and I evalute them using CTRL+F7, I find the following

The pPointer points to the actual data.  The pCharacter holds an address
somewhere else.  If I get the Address of the [0] element, this is the same
address as the pPointer, if they are both pointers then Delphi obviously
treats TYPE POINTERS differently, it is this that I don't understand.

The READ method of memory stream takes a 'var Buffer'. If I pass a character
array address (not the first element address), it screws up the array.  This
is how the whole thing started.

I'm confuse, please help!

MarkM

 Hi "Mark Mamone" <mark.mam...@syntegra.bt.co.uk>;

 This is a public reply to your message posted:
 From group: comp.lang.pascal.delphi.misc;  on Tue, 2 Feb 1999 09:15:12 -0000
 Concerning "Re: Pointers, Delphi's Internal Approach";

 I am just an interested observer, with one question and one suggestion.

~ > What is happening here then
~ >
~ > If I do the following
~ >
~ > pPointer : Pointer;
~ > pCharacter : PChar;
~ >
~ > pCharacter := StrAlloc(100);
~ > StrPCopy(pCharacter, '0123456789');
~ > pPointer := Addr(pCharacter);
~ >
~ > and I evalute them using CTRL+F7, I find the following
~ >
~ >
~ > The pPointer points to the actual data.  The pCharacter holds an address
~ > somewhere else.  If I get the Address of the [0] element, this is the same
~ > address as the pPointer, if they are both pointers then Delphi obviously
~ > treats TYPE POINTERS differently, it is this that I don't understand.

    Does the address that pCharacter points to, contain the address of
    the [0] element?

~ > The READ method of memory stream takes a 'var Buffer'. If I pass a character
~ > array address (not the first element address), it screws up the array.  This
~ > is how the whole thing started.
~ >
~ > I'm confuse, please help!

  As I understand it (and maybe I don't), 'var Buffer' takes the
  dereferenced contents of an address and treats it like a pointer to
  the contents.  So you need to send the dereferenced contents to the
  var variable.  Personally I think this is absolutely insane ...

  Cordially;

--
 Friar Broccoli
 Robert Keith Elias  (Quebec, Qc, Canada)   Address: kel...@CLIC.NET
 Best programmer's & all purpose text editor: http://www.semware.com

 --------- I consider ALL arguments in support of my views ---------

procedure DoStuffVar(var buffer);

...

procedure DoStuffAddr(buffer:pointer);

the difference is in how you use them.

var
  buffer:array[0..100] of char;
begin
  DoStuffVar(buffer);
  DoStuffAddr(@buffer);
end;

If you're using D4 dynamic arrays, they too are automatically
dereferenced.  In general, I think you're over analyzing the problem.
There ARE a lot of idiosyncracies lurking below the surface on what is a
pointer and what is not, but all the hidden pointer stuff is always
derefenced as needed so that they *behave* as if they weren't pointers.

Bob Lee

I believe that you and Mark are making this way too complex, essentially
because you know too much.  Forget about addresses and memory. One of
the strengths of Pascal is that you don't have to wade around in this
goop.  If you're using a lot of pointers (especially for characters or
arrays) then you're probably writing C code in pascal rather than pascal
code.    Think in terms of data and variables.

As for var params.

procedure One(var a:integer);

is equivalent to:

procedure Two(const a:^integer);

the difference is that within the routines you get to use 'a' rather
than 'a^' to fool with the value, and on calling the routine you can
pass 'a' rather than '@a'.  Thus, using var parameters reduces the
amount of referencing/dereferencing you have to do and so reduces the
clutter of the code.

Bob Lee

pPointer := pCharacter;

-----------== Posted via Deja News, The Discussion Network ==----------
http://www.dejanews.com/       Search, Read, Discuss, or Start Your Own    

Im Artikel <36c5e93f.590892...@news.proaxis.com>, n...@junk.mail (Ray Lischner)
schreibt:

IMO both the original requestor and me know about pointers in C and on machine
level, but that knowledge doesn't help to find out, where and how pointers are
used in Delphi standard functions and data types. Just the buffers in I/O
functions need some explanations for Delphi novices.

DoDi

I'd like to thank everybody for there help in me understanding this, and I
know it looks as though I'm making it WAY to complex BUT, I enjoy (call me
sad) looking at the internals of how the things works - I appreciate the
product more.  SO.....

I do come from a C++ background and to be honest the lack of thorough
understanding hasn't caused me any problems because I don't really passed
pointers to stuff around that much and when I do I let Delphis "Auto
Dereferencing" handling it for me, but..

How does Delphi handle the PCHAR, Array of bytes, Pointers etc INTERNALLY,
it must store information somewhere and this must incur an overhead.  Is
there information on this ?

MarkM

Bob Lee

--
Stefan Hoffmeister    (http://www.econos.de/)
No private email, please, unless expressly invited.

Most of the problems Delphi users have with pointers are because they
want Delphi to behave like C or C++. For those of you who are not
familiar with C and C++, these languages use pointers to implements
arrays, strings, and VAR arguments. (C++ has references, but that's a
minor point.) Thus, any serious C and C++ programs uses pointers
heavily, and C and C++ programmers come to rely on pointers as the
solution to almost any programming problem.

That isn't true with Delphi.

Pascal in general and Delphi in particular avoid pointers in favor of
more controlled and more controllable approaches to programming. For
example, Pascal has real arrays. Delphi has real strings.

In C or C++, the ReadBuffer procedure would use a pointer argument, so
naive C and C++ programmers assume that Delphi uses a pointer argument.
It doesn't. Instead, Delphi uses an untyped VAR argument, which helps
prevent problems of invalid or nil pointers. Untyped VAR arguments--if
used correctly--are safer than pointer arguments.
--
Ray Lischner  (http://www.bardware.com)
co-author (with John Doyle) of Shakespeare for Dummies