Pointer - Revision history

Sandman: /* Concept */

Sandman — Thu, 22 May 2008 23:08:10 GMT

Concept

←Older revision		Revision as of 23:08, 22 May 2008
Line 15:		Line 15:
	=== Concept ===		=== Concept ===
	'''Pointer'''s, are used to point to a location in [[memory]]. It uses 32 [[bit]]s (4 [[byte]]s) so it can map 4GB of memory into bytes. '''Pointer'''s can point to any [[datatype]]: [[int]]s, [[short]]s, [[string]]s or even usermade datatypes.		'''Pointer'''s, are used to point to a location in [[memory]]. It uses 32 [[bit]]s (4 [[byte]]s) so it can map 4GB of memory into bytes. '''Pointer'''s can point to any [[datatype]]: [[int]]s, [[short]]s, [[string]]s or even usermade datatypes.
-	However, using a <code>struct pointer my_pointer</code> is pointless, because the compiler has no knowledge of the elements inside the struct pointing to, since it doesn't know which struct is meant. <code>MyStruct pointer my_pointer</code>, where MyStruct is an existing struct, is also not valid, because MyStruct is not a datatype. The only way to have something like a <code>struct pointer my_pointer</code> is to use [[Type]] as seen in the example.	+	However, using a <code>struct pointer my_pointer</code> is pointless, because the compiler has no knowledge of the elements inside the struct pointing to, since it doesn't know which struct is meant, so this is invalid. <code>MyStruct pointer my_pointer</code>, where MyStruct is an existing struct, is also not valid, because MyStruct is not a datatype. The only way to have something like a <code>struct pointer my_pointer</code> is to use [[Type]] as seen in the example.

	== Example ==		== Example ==

Sandman at 14:06, 19 May 2008

Sandman — Mon, 19 May 2008 14:06:45 GMT

←Older revision		Revision as of 14:06, 19 May 2008
Line 14:		Line 14:

	=== Concept ===		=== Concept ===
-	'''Pointer'''s, are used to point to a location in [[memory]]. It uses 32 [[bit]]s (4 [[byte]]s) so it can map 4GB of memory into bytes. '''Pointer'''s can point to any ~~strong~~ [[datatype]]: [[int]]s, [[short]]s, [[string]]s or even usermade datatypes. ~~In order to point to a weak datatype like~~ a struct, the struct ~~would have~~ to ~~encapsulated in~~ a ~~user defined~~ datatype.	+	'''Pointer'''s, are used to point to a location in [[memory]]. It uses 32 [[bit]]s (4 [[byte]]s) so it can map 4GB of memory into bytes. '''Pointer'''s can point to any [[datatype]]: [[int]]s, [[short]]s, [[string]]s or even usermade datatypes.
		+	However, using a <code>struct pointer my_pointer</code> is pointless, because the compiler has no knowledge of the elements inside the struct pointing to, since it doesn't know which struct is meant. <code>MyStruct pointer my_pointer</code>, where MyStruct is an existing struct, is also not valid, because MyStruct is not a datatype. The only way to have something like a <code>struct pointer my_pointer</code> is to use [[Type]] as seen in the example.

	== Example ==		== Example ==
	<pre>		<pre>
-	~~Program pointers~~;	+
		+	Type _point
		+	int x;
		+	int y;
		+	End
		+
		+	Type _person
		+	string name;
		+	int age;
		+	End
		+
		+	Global
		+	_person Person;
		+	End
		+
		+	Process Main()
	Private		Private
	int my_int;		int my_int;
-	int ~~pointer~~ my_int_pointer;	+	int* my_int_pointer;
		+	_point myPoint;
		+	_person* personPointer; // possible, because _person is infact a datatype
		+	//Person* personPointer; // not possible, because Person is not a datatype
	Begin		Begin

Line 33:		Line 52:
	say(my_int);		say(my_int);
	say(*my_int_pointer);		say(*my_int_pointer);
		+
		+	setXY(&myPoint);
		+	say(myPoint.x);
		+	say(myPoint.y);
		+
		+	personPointer = &Person;
		+	personPointer.name = "Mies";
		+	say(Person.name);
		+	say(personPointer.name);

	Repeat		Repeat
Line 38:		Line 66:
	Until(key(_esc))		Until(key(_esc))

		+	End
		+
		+	Function int setXY(_point* p)
		+	Begin
		+	p.x = 3; // this is actually (*p).x = 3, but . can be used like this
		+	p.y = 5; // this is actually (*p).y = 5, but . can be used like this
		+	return 0;
	End		End
	</pre>		</pre>
-	The & (offset) operator, when used with pointers, returns a [[void]] pointer to a variable. In the example it returns an int pointer to the variable my_int. The * (pointer) operator, when used with pointers, makes it so the pointer variable is not accessed, but the variable it's pointing to. In the example it changes access from my_int_pointer to my_int.	+	Used in example: [[say]](), [[key]](), [[Type]], [[Global]], [[Private]], [[point]]
		+
		+	The & (offset) operator, when used with pointers, returns a [[void]] pointer to a variable. In the example it returns an [[int]] pointer to the variable my_int. The * (pointer) operator, when used with pointers, makes it so the pointer variable is not accessed, but the variable it's pointing to. In the example it changes access from my_int_pointer to my_int.

85.144.194.29: /* Concept */ Pointers can only point to strong datatypes, info about how to go about a struct pointer.

85.144.194.29 — Sat, 17 May 2008 18:48:54 GMT

Concept - Pointers can only point to strong datatypes, info about how to go about a struct pointer.

←Older revision		Revision as of 18:48, 17 May 2008
Line 14:		Line 14:

	=== Concept ===		=== Concept ===
-	'''Pointer'''s, are used to point to a location in [[memory]]. It uses 32 [[bit]]s (4 [[byte]]s) so it can map 4GB of memory into bytes. '''Pointer'''s can point to any [[datatype]]: [[int]]s, [[short]]s, [[string]]s or even usermade datatypes.	+	'''Pointer'''s, are used to point to a location in [[memory]]. It uses 32 [[bit]]s (4 [[byte]]s) so it can map 4GB of memory into bytes. '''Pointer'''s can point to any strong [[datatype]]: [[int]]s, [[short]]s, [[string]]s or even usermade datatypes. In order to point to a weak datatype like a struct, the struct would have to encapsulated in a user defined datatype.

	== Example ==		== Example ==

Sandman at 22:37, 29 May 2007

Sandman — Tue, 29 May 2007 22:37:41 GMT

←Older revision		Revision as of 22:37, 29 May 2007
Line 40:		Line 40:
	End		End
	</pre>		</pre>
-	The & ([[offset]]) operator, when used with pointers, returns a [[void]] pointer to a variable. In the example it returns an int pointer to the variable my_int. The * (pointer) operator, when used with pointers, makes it so the pointer variable is not accessed, but the variable it's pointing to. In the example it changes access from my_int_pointer to my_int.	+	The & (offset) operator, when used with pointers, returns a [[void]] pointer to a variable. In the example it returns an int pointer to the variable my_int. The * (pointer) operator, when used with pointers, makes it so the pointer variable is not accessed, but the variable it's pointing to. In the example it changes access from my_int_pointer to my_int.

Sandman at 22:36, 29 May 2007

Sandman — Tue, 29 May 2007 22:36:48 GMT

←Older revision		Revision as of 22:36, 29 May 2007
Line 4:		Line 4:

	== Definition ==		== Definition ==
-	~~'''~~POINTER~~'''~~	+	=== Statement ===
		+	Declaration of a pointer:<br>
		+	<datatype> POINTER <pointername><br>
		+	<datatype> * <pointername>

-	'''Pointer'''s, are used to point to a location in [[memory]]. It uses 32 [[bit]]s (4 [[byte]]s) so it can map 4GB of memory into bytes. '''Pointer'''s can point to any datatype: [[int]]s, [[short]]s, [[string]]s ~~and~~ even usermade datatypes.	+	Assignment of a value to the location pointed to:<br>
		+	POINTER <pointername> = <value>;<br>
		+	<nowiki>*</nowiki> <pointername> = <value>;
		+
		+	=== Concept ===
		+	'''Pointer'''s, are used to point to a location in [[memory]]. It uses 32 [[bit]]s (4 [[byte]]s) so it can map 4GB of memory into bytes. '''Pointer'''s can point to any [[datatype]]: [[int]]s, [[short]]s, [[string]]s or even usermade datatypes.

	== Example ==		== Example ==
Line 26:		Line 34:
	say(*my_int_pointer);		say(*my_int_pointer);

-	~~Loop~~	+	Repeat
	frame;		frame;
-	~~End~~	+	Until(key(_esc))
		+
	End		End
	</pre>		</pre>
-	The & (offset) operator, when used with pointers, returns a [[void]] pointer to a variable. In the example it returns an int pointer to the variable my_int. The * (pointer) operator, when used with pointers, makes it so the pointer variable is not accessed, but the variable it's pointing to. In the example it changes access from my_int_pointer to my_int.	+	The & ([[offset]]) operator, when used with pointers, returns a [[void]] pointer to a variable. In the example it returns an int pointer to the variable my_int. The * (pointer) operator, when used with pointers, makes it so the pointer variable is not accessed, but the variable it's pointing to. In the example it changes access from my_int_pointer to my_int.

Sandman at 02:39, 13 May 2007

Sandman — Sun, 13 May 2007 02:39:45 GMT

←Older revision		Revision as of 02:39, 13 May 2007
Line 1:		Line 1:
	[[Category:language]]		[[Category:language]]
	[[Category:datatypes]]		[[Category:datatypes]]
		+	[[Category:operators]]

	== Definition ==		== Definition ==

Sandman at 02:38, 13 May 2007

Sandman — Sun, 13 May 2007 02:38:34 GMT

New page

[[Category:language]]
[[Category:datatypes]]

== Definition ==
'''POINTER'''

'''Pointer'''s, are used to point to a location in [[memory]]. It uses 32 [[bit]]s (4 [[byte]]s) so it can map 4GB of memory into bytes. '''Pointer'''s can point to any datatype: [[int]]s, [[short]]s, [[string]]s and even usermade datatypes.

== Example ==
<pre>
Program pointers;
Private
int my_int;
int pointer my_int_pointer;
Begin

my_int_pointer = &my_int;

my_int = 3;
say(my_int);
say(*my_int_pointer);

*my_int_pointer = 4;
say(my_int);
say(*my_int_pointer);

Loop
frame;
End
End
</pre>
The & (offset) operator, when used with pointers, returns a [[void]] pointer to a variable. In the example it returns an int pointer to the variable my_int. The * (pointer) operator, when used with pointers, makes it so the pointer variable is not accessed, but the variable it's pointing to. In the example it changes access from my_int_pointer to my_int.