4404:. Each pointer has a type it points to, but one can freely cast between pointer types (but not between a function pointer and an object pointer). A special pointer type called the “void pointer” allows pointing to any (non-function) object, but is limited by the fact that it cannot be dereferenced directly (it shall be cast). The address itself can often be directly manipulated by casting a pointer to and from an integral type of sufficient size, though the results are implementation-defined and may indeed cause undefined behavior; while earlier C standards did not have an integral type that was guaranteed to be large enough,
43:
6839:
6858:
162:
391:"or inventing the pointer variable and introducing this concept into PL/I, thus providing for the first time, the capability to flexibly treat linked lists in a general-purpose high-level language". His seminal paper on the concepts appeared in the June 1967 issue of CACM entitled: PL/I List Processing. According to the
4478:. For example, adding 1 to a pointer to 4-byte integer values will increment the pointer's pointed-to byte-address by 4. This has the effect of incrementing the pointer to point at the next element in a contiguous array of integers—which is often the intended result. Pointer arithmetic cannot be performed on
749:
and deallocate dynamic variables and arrays in memory. Since a variable will often become redundant after it has served its purpose, it is a waste of memory to keep it, and therefore it is good practice to deallocate it (using the original pointer reference) when it is no longer needed. Failure to do
468:
contiguous in memory and that are viewed collectively as one datum (for instance, an aggregate could be 3 logically contiguous bytes, the values of which represent the 3 coordinates of a point in space). When an aggregate is entirely composed of the same type of primitive, the aggregate may be called
4215:
for the
Windows platform had support for STRPTR() to return the address of a string, and for VARPTR() to return the address of a variable. Visual Basic 5 also had support for OBJPTR() to return the address of an object interface, and for an ADDRESSOF operator to return the address of a function. The
3432:
is a pointer whose value is interpreted as an offset from the address of the pointer itself; thus, if a data structure has an autorelative pointer member that points to some portion of the data structure itself, then the data structure may be relocated in memory without having to update the value of
2999:
In languages that allow pointer arithmetic, arithmetic on pointers takes into account the size of the type. For example, adding an integer number to a pointer produces another pointer that points to an address that is higher by that number times the size of the type. This allows us to easily compute
3138:
by deallocating the memory region it points into. This type of pointer is dangerous and subtle because a deallocated memory region may contain the same data as it did before it was deallocated but may be then reallocated and overwritten by unrelated code, unknown to the earlier code. Languages with
3058:
is implementation-defined and the comparison it provides does not provide any more insight as to whether the two pointers are interchangeable. In addition, further conversion to bytes and arithmetic will throw off optimizers trying to keep track the use of pointers, a problem still being elucidated
3410:
The consequences are usually unpredictable and the error may present itself in several different ways depending upon whether or not the pointer is a "valid" address and whether or not there is (coincidentally) a valid instruction (opcode) at that address. The detection of a wild branch can present
6336:
only allows pointers to reference dynamically created variables that are anonymous and does not allow them to reference standard static or local variables. It does not have pointer arithmetic. Pointers also must have an associated type and a pointer to one type is not compatible with a pointer to
2790:
to be executed, based on certain conditions defined in the same table entry. The pointers can however be simply indexes to other separate, but associated, tables comprising an array of the actual addresses or the addresses themselves (depending upon the programming language constructs available).
6244:
has pointers. Its declaration syntax is equivalent to that of C, but written the other way around, ending with the type. Unlike C, Go has garbage collection, and disallows pointer arithmetic. Reference types, like in C++, do not exist. Some built-in types, like maps and channels, are boxed (i.e.
601:
In the usual case, a pointer is large enough to hold more addresses than there are units of memory in the system. This introduces the possibility that a program may attempt to access an address which corresponds to no unit of memory, either because not enough memory is installed (i.e. beyond the
486:
Pointers are commonly used in programming languages that support direct memory manipulation, such as C and C++. They allow programmers to work with memory directly, enabling efficient memory management and more complex data structures. By using pointers, you can access and modify data located in
232:
the pointer. As an analogy, a page number in a book's index could be considered a pointer to the corresponding page; dereferencing such a pointer would be done by flipping to the page with the given page number and reading the text found on that page. The actual format and content of a pointer
3550:
has to be changed to point to the new element. Since C arguments are always passed by value, using double indirection allows the insertion to be implemented correctly, and has the desirable side-effect of eliminating special case code to deal with insertions at the front of the list:
3000:
the address of elements of an array of a given type, as was shown in the C arrays example above. When a pointer of one type is cast to another type of a different size, the programmer should expect that pointer arithmetic will be calculated differently. In C, for example, if the
6380:— a pointer is allowed to reference standard static or local variables and can be cast from one pointer type to another. Moreover, pointer arithmetic is unrestricted: adding or subtracting from a pointer moves it by that number of bytes in either direction, but using the
482:
A pointer is a programming concept used in computer science to reference or point to a memory location that stores a value or an object. It is essentially a variable that stores the memory address of another variable or data structure rather than storing the data itself.
3158:
to help track allocation of dynamic memory in addition to acting as a reference. In the absence of reference cycles, where an object refers to itself indirectly through a sequence of smart pointers, these eliminate the possibility of dangling pointers and memory leaks.
6000:
introduced a strongly typed pointer capability. Fortran pointers contain more than just a simple memory address. They also encapsulate the lower and upper bounds of array dimensions, strides (for example, to support arbitrary array sections), and other metadata. An
3473:
In some languages, a pointer can reference another pointer, requiring multiple dereference operations to get to the original value. While each level of indirection may add a performance cost, it is sometimes necessary in order to provide correct behavior for complex
4470:, that is, the ability to modify a pointer's target address with arithmetic operations (as well as magnitude comparisons), is restricted by the language standard to remain within the bounds of a single array object (or just after it), and will otherwise invoke
714:
means for building and processing data—for example, by recursively accessing the head and tail elements of lists of lists; e.g. "taking the car of the cdr of the cdr". By contrast, memory management based on pointer dereferencing in some approximation of an
527:
References serve as a level of indirection: A pointer's value determines which memory address (that is, which datum) is to be used in a calculation. Because indirection is a fundamental aspect of algorithms, pointers are often expressed as a fundamental
3071:. However, the usefulness of pointers is so great that it can be difficult to perform programming tasks without them. Consequently, many languages have created constructs designed to provide some of the useful features of pointers without some of their
1257:—by 1, 2 or 3 bits—in order to adjust the offset by a factor of 2, 4 or 8, before its addition to the base address). Generally, though, such schemes are a lot of trouble, and for convenience to the programmer absolute addresses (and underlying that, a
5200:
These pointer declarations cover most variants of pointer declarations. Of course it is possible to have triple pointers, but the main principles behind a triple pointer already exist in a double pointer. The naming used here is what the expression
2097:
for allocating memory blocks from the heap. It takes the size of an object to allocate as a parameter and returns a pointer to a newly allocated block of memory suitable for storing the object, or it returns a null pointer if the allocation failed.
4561:, forcing them into different contexts: an expression can be an ordinary arithmetic one or a pointer arithmetic one, and sometimes it is easy to mistake one for the other. In response to this, many modern high-level computer languages (for example
5988:
employs value and reference semantics without pointer arithmetic. Nevertheless, pointer classes are provided. They offer pointer arithmetic, typecasting, explicit memory management, interfacing with non-Eiffel software, and other features.
5825:
of a program are inherently pointer-based, where the only memory allocated within the program is space for the address of the data item (typically a single memory word). In program source code, these data items are used just like any other
741:
Pointers are used to pass parameters by reference. This is useful if the programmer wants a function's modifications to a parameter to be visible to the function's caller. This is also useful for returning multiple values from a function.
642:
processor, which, though supporting only 16 MB of physical memory, could access up to 1 GB of virtual memory, but the combination of 16-bit address and segment registers made accessing more than 64 KB in one data structure cumbersome.
3050:, the rule is interpreted to mean that "just because two pointers point to the same address, does not mean they are equal in the sense that they can be used interchangeably", the difference between the pointers referred to as their
629:
is employed to use different parts of the memory at different times. The last incarnations of the x86 architecture support up to 36 bits of physical memory addresses, which were mapped to the 32-bit linear address space through the
3411:
one of the most difficult and frustrating debugging exercises since much of the evidence may already have been destroyed beforehand or by execution of one or more inappropriate instructions at the branch location. If available, an
2069:, where variables usually are stored (although variables can also be stored in the CPU registers). Dynamic memory allocation can only be made through pointers, and names – like with common variables – cannot be given.
5918:. PL/I was quite a leap forward compared to the programming languages of its time. PL/I pointers are untyped, and therefore no casting is required for pointer dereferencing or assignment. The declaration syntax for a pointer is
3095:
One major problem with pointers is that as long as they can be directly manipulated as a number, they can be made to point to unused addresses or to data which is being used for other purposes. Many languages, including most
1298:. Thus in C, arrays can be thought of as pointers to consecutive areas of memory (with no gaps), and the syntax for accessing arrays is identical for that which can be used to dereference pointers. For example, an array
382:
that made possible indirect addressing and addresses of the highest rank – analogous to pointers. This language was widely used on the Soviet Union computers. However, it was unknown outside the Soviet Union and usually
3119:. Any attempt to use such uninitialized pointers can cause unexpected behavior, either because the initial value is not a valid address, or because using it may damage other parts of the program. The result is often a
4501:
Pointer arithmetic provides the programmer with a single way of dealing with different types: adding and subtracting the number of elements required instead of the actual offset in bytes. (Pointer arithmetic with
6337:
another type (e.g. a pointer to a char is not compatible with a pointer to an integer). This helps eliminate the type security issues inherent with other pointer implementations, particularly those used for
4199:. Ada 83 did not permit arithmetic on access types (although many compiler vendors provided for it as a non-standard feature), but Ada 95 supports “safe” arithmetic on access types via the package
706:, which can be thought of as specialised pointers to the first and second components of a cons-cell. This gives rise to some of the idiomatic "flavour" of functional programming. By structuring data in such
654:
of other devices in the computer. There are analogous concepts such as file offsets, array indices, and remote object references that serve some of the same purposes as addresses for other types of objects.
6733:
If an invalid value has been assigned to the pointer, the behavior of the unary * operator is undefined... Among the invalid values for dereferencing a pointer by the unary * operator are a null pointer...
4720:
to other pointer types, even in assignments. This was a design decision to avoid careless and even unintended casts, though most compilers only output warnings, not errors, when encountering other casts.
4156:
code can initially be loaded into contiguous bytes of the array for the simulator to "read", interpret and action entirely within the memory contained of the same array. If necessary, to completely avoid
6277:. The language does not provide any explicit pointer manipulation operators. It is still possible for code to attempt to dereference a null reference (null pointer), however, which results in a run-time
614:, where pointers are 64 bit long and addresses only extend to 48 bits. Pointers must conform to certain rules (canonical addresses), so if a non-canonical pointer is dereferenced, the processor raises a
4102:
in assembly language (that points to the individual bytes but whose actual value is relative to the start of the array, not its absolute address in memory). Assuming the array is, say, a contiguous 16
5934:), where xxx is a based variable, which may be an element variable, a structure, or an array, and ppp is the default pointer). Such a variable can be address without an explicit pointer reference (
3460:
is a pointer whose value is an offset from the value of another pointer. This can be used to store and load blocks of data, assigning the address of the beginning of the block to the base pointer.
3852:
will store the address of a function to be invoked. While this facility can be used to call functions dynamically, it is often a favorite technique of virus and other malicious software writers.
6415:
supports pointers, although rarely used, in the form of the pack and unpack functions. These are intended only for simple interactions with compiled OS libraries. In all other cases, Perl uses
2932:
A 2005 draft of the C standard requires that casting a pointer derived from one type to one of another type should maintain the alignment correctness for both types (6.3.2.3 Pointers, par. 7):
6837:, Steiner, Robert C. (Broomfield, CO), "Pointers that are relative to their own present locations", issued 2003-09-23, assigned to Avaya Technology Corp. (Basking Ridge, NJ)
1270:
value of a character (e.g. X'29') can be used to point to an alternative integer value (or index) in an array (e.g., X'01'). In this way, characters can be very efficiently translated from '
318:, support some type of pointer, although some have more restrictions on their use than others. While "pointer" has been used to refer to references in general, it more properly applies to
358:, pointers are considered a separate type parameterized by the type of data they point to, even if the underlying representation is an integer. Other measures may also be taken (such as
4079:, a back pointer held on an element 'points back' to the item referring to the current element. These are useful for navigation and manipulation, at the expense of greater memory use.
4593:
can store the address of any object (not function), and, in C, is implicitly converted to any other object pointer type on assignment, but it must be explicitly cast if dereferenced.
2795:
or "early" exit from a loop). For this latter purpose, the "pointer" may simply be the table entry number itself and can be transformed into an actual address by simple arithmetic.
4454:) which can be used in some situations as a safer alternative to primitive C pointers. C++ also supports another form of reference, quite different from a pointer, called simply a
524:. The feature that separates pointers from other kinds of reference is that a pointer's value is meant to be interpreted as a memory address, which is a rather low-level concept.
1861:
The definition with references, however, is type-checked and does not use potentially confusing signal values. For this reason, data structures in C are usually dealt with via
3447:
to mean a pointer containing its own address, which can be useful for reconstructing in any arbitrary region of memory a collection of data structures that point to each other.
490:
In simpler terms, you can think of a pointer as an arrow that points to a specific spot in a computer's memory, allowing you to interact with the data stored at that location.
1641:
Represented here are five integers: 2, 4, 3, 1, and 5. These five integers occupy 32 bits (4 bytes) each with the least-significant byte stored first (this is a little-endian
1210:
and trees, it is necessary to have pointers to help manage how the structure is implemented and controlled. Typical examples of pointers are start pointers, end pointers, and
813:
Because the C language does not specify an implicit initialization for objects of automatic storage duration, care should often be taken to ensure that the address to which
6253:) operator has been dropped: the dot operator on a pointer refers to the field or method of the dereferenced object. This, however, only works with 1 level of indirection.
4122:
example shown above). Pointer arithmetic can be simulated by adding or subtracting from the index, with minimal additional overhead compared to genuine pointer arithmetic.
268:
structures). In particular, it is often much cheaper in time and space to copy and dereference pointers than it is to copy and access the data to which the pointers point.
4098:
can be thought of and processed as if it were the entire memory range (within the scope of the particular array) and any index to it can be thought of as equivalent to a
976:
at 0x8134; also assume this is a 32-bit machine such that an int is 32-bits wide. The following is what would be in memory after the following code snippet is executed:
4430:
fully supports C pointers and C typecasting. It also supports a new group of typecasting operators to help catch some unintended dangerous casts at compile-time. Since
3035:
which can be used to confirm that these dangerous casts are valid at runtime. Other languages merely accept a conservative approximation of safe casts, or none at all.
1245:, and share many of its advantages and disadvantages. A two-byte offset, containing a 16-bit, unsigned integer, can be used to provide relative addressing for up to 64
366:), to verify that the pointer variable contains a value that is both a valid memory address and within the numerical range that the processor is capable of addressing.
7149:
2076:
blocks of memory. Such blocks are used to store data objects or arrays of objects. Most structured and object-oriented languages provide an area of memory, called the
2715:
code in the low byte, and a colour in the high byte. Thus, to put the letter 'A' at row 5, column 2 in bright white on blue, one would write code like the following:
1238:
from an absolute start address ("base") that typically uses fewer bits than a full address, but will usually require one additional arithmetic operation to resolve).
6021:
statement may also be used to associate a pointer to a block of memory. For example, the following code might be used to define and create a linked list structure:
3218:
has a value reserved for indicating that the pointer does not refer to a valid object. Null pointers are routinely used to represent conditions such as the end of a
7153:
6856:, Nagy, Michael (Tampa, FL), "System and method for database save and restore using self-pointers", issued 2000-09-05, assigned to IBM (Armonk, NY)
60:
6330:
2489:
The code below illustrates how memory objects are dynamically deallocated, i.e., returned to the heap or free store. The standard C library provides the function
3546:
This implementation uses a pointer to the first element in the list as a surrogate for the entire list. If a new value is added to the beginning of the list,
3112:, which can only be used to refer to objects and not manipulated as numbers, preventing this type of error. Array indexing is handled as a special case.
7304:
594:. The system would then also provide an operation to retrieve the value stored in the memory unit at a given address (usually utilizing the machine's
634:
paging mechanism. Thus, only 1/16 of the possible total memory may be accessed at a time. Another example in the same computer family was the 16-bit
7726:
4181:
is a strongly typed language where all pointers are typed and only safe type conversions are permitted. All pointers are by default initialized to
7675:
7309:
6665:
2886:
were declared with different types. To suppress the compiler warning, it must be made explicit that you do indeed wish to make the assignment by
2786:
usually make extensive use of pointers. The pointers, usually embedded in a table entry, may, for instance, be used to hold the entry points to
756:(where available free memory gradually, or in severe cases rapidly, diminishes because of an accumulation of numerous redundant memory blocks).
7299:
7294:
7001:
6767:
6282:
5650:
3187:
3140:
346:, there are risks associated with using them, particularly in the latter case. Primitive pointers are often stored in a format similar to an
7282:
7183:
6565:
107:
4862:(pointer to void), because references behave like aliases to the variables they point to, and there can never be a variable whose type is
698:
In functional programming languages that rely heavily on lists, data references are managed abstractly by using primitive constructs like
79:
5809:. Most such methods have the same security permission requirements as unmanaged code, since they can affect arbitrary places in memory.
359:
7094:
602:
range of available memory) or the architecture does not support such addresses. The first case may, in certain platforms such as the
6970:
6640:
350:; however, attempting to dereference or "look up" such a pointer whose value is not a valid memory address could cause a program to
323:
126:
86:
5653:
from moving the pointed object as part of memory management while the pointer is in scope, thus keeping the pointer address valid.
4114:
of contiguous bytes within the array) can be directly addressed and manipulated using the name of the array with a 31 bit unsigned
6529:
Some compilers allow storing the addresses of functions in void pointers. The C++ standard lists converting a function pointer to
1873:
Pointers can be used to pass variables by their address, allowing their value to be changed. For example, consider the following
3067:
As a pointer allows a program to attempt to access an object that may not be defined, pointers can be the origin of a variety of
621:
On the other hand, some systems have more units of memory than there are addresses. In this case, a more complex scheme such as
7433:
6533:
as a conditionally supported feature and the C standard says such conversions are "common extensions". This is required by the
3415:
can usually not only detect a wild branch before it takes effect, but also provide a complete or partial trace of its history.
3097:
2791:
They can also be used to point to earlier table entries (as in loop processing) or forward to skip some table entries (as in a
375:
245:
6301:
is even more strongly typed than Pascal, with fewer ways to escape the type system. Some of the variants of Modula-2 (such as
854:, which could be catastrophic. However, most implementations simply halt execution of the program in question, usually with a
93:
7550:
7287:
7249:
5637:
assembly provisions for pointer access. The syntax is essentially the same as in C++, and the address pointed can be either
5622:
1793:
765:
557:
407:
379:
315:
64:
1249:(2 bytes) of a data structure. This can easily be extended to 128, 256 or 512 KiB if the address pointed to is forced to be
3020:
would point to 0x2001. Other risks of casting include loss of data when "wide" data is written to "narrow" locations (e.g.
2856:
would be a char pointer. The following would yield a compiler warning of "assignment from incompatible pointer type" under
1290:
In C, array indexing is formally defined in terms of pointer arithmetic; that is, the language specification requires that
6333:
6314:
5985:
3253:
3160:
487:
memory, pass data efficiently between functions, and create dynamic data structures like linked lists, trees, and graphs.
295:
142:
387:
is credited with the invention, in 1964, of the pointer. In 2000, Lawson was presented the
Computer Pioneer Award by the
75:
7736:
7450:
7380:
7228:
6982:
6484:
6416:
6274:
4566:
1436:, which acts as a pointer to the block. Another common use of pointers is to point to dynamically allocated memory from
711:
688:
579:
513:
449:
423:
307:
6419:, which are typed and do not allow any form of pointer arithmetic. They are used to construct complex data structures.
3143:
prevent this type of error because deallocation is performed automatically when there are no more references in scope.
2811:; the language will then attempt to prevent the programmer from pointing it to objects which are not integers, such as
2061:
may enter. In such cases the programmer needs to allocate memory dynamically. This is done by allocating memory at the
7705:
7107:
A terse list of minimum length source codes that dereference a null pointer in several different programming languages
6504:
6266:
6262:
4562:
4145:
3848:
In some languages, a pointer can reference executable code, i.e., it can point to a function, method, or procedure. A
3105:
676:
284:
3252:
is a pointer that does not point to a valid object and consequently may make a program crash or behave oddly. In the
2703:
to access the video capabilities of PCs was slow. Applications that were display-intensive typically used to access
7460:
7328:
6233:
feature, Fortran-2003 supports intrinsic functions for converting C-style pointers into
Fortran pointers and back.
4594:
4178:
1211:
1207:
631:
5821:
programming language supports pointers to variables. Primitive or group (record) data objects declared within the
734:
which involves constructing a pointer to the desired data element in the array. In other data structures, such as
53:
7638:
7590:
7502:
7480:
7475:
7403:
7269:
6241:
5838:
4126:
4111:
3412:
3167:
3032:
2073:
1235:
392:
339:
202:
7731:
7512:
7176:
6774:
An array type does not contain additional holes because all other types pack tightly when composed into arrays
6358:
6342:
5973:
4570:
4393:
4099:
3257:
1874:
1250:
668:
615:
595:
31:
3043:
In C and C++, even if two pointers compare as equal that doesn't mean they are equivalent. In these languages
2651:
On some computing architectures, pointers can be used to directly manipulate memory or memory-mapped devices.
3031:
Although it is impossible in general to determine at compile-time which casts are safe, some languages store
1440:
which returns a consecutive block of memory of no less than the requested size that can be used as an array.
7665:
7580:
6489:
4487:
2857:
4435:
7408:
7264:
7223:
7218:
6580:
6313:
Much as with Modula-2, pointers are available. There are still fewer ways to evade the type system and so
2704:
720:
541:
276:
100:
7067:
5645:
memory. However, pointers to managed memory (any pointer to a managed object) must be declared using the
3407:" is said to have occurred. In other words, a wild branch is a function pointer that is wild (dangling).
2803:
In many languages, pointers have the additional restriction that the object they point to has a specific
2087:
The example C code below illustrates how structure objects are dynamically allocated and referenced. The
1792:
This pointer-recursive definition is essentially the same as the reference-recursive definition from the
7398:
7373:
5938:, or may be addressed with an explicit reference to the default locator (ppp), or to any other pointer (
5911:
4153:
4076:
2812:
561:
265:
234:
6669:
2711:
constant 0xB8000 to a pointer to an array of 80 unsigned 16-bit int values. Each value consisted of an
1143:(which is 0x8130), 'locate' that address, and assign 8 to that location yielding the following memory:
817:
points is valid; this is why it is sometimes suggested that a pointer be explicitly initialized to the
6853:
6834:
5945:
Pointer arithmetic is not part of the PL/I standard, but many compilers allow expressions of the form
3222:
of unknown length or the failure to perform some action; this use of null pointers can be compared to
3079:. In this context, pointers that directly address memory (as used in this article) are referred to as
864:
In any case, once a pointer has been declared, the next logical step is for it to point at something:
7200:
6509:
6412:
6270:
3444:
to mean an offset from the address of a structure rather than from the address of the pointer itself;
3400:
3101:
1675:. Considering the contents as a memory address (0x1000), look up the value at that location (0x0002);
1275:
716:
591:
571:
533:
470:
299:
280:
241:
206:
7110:
7031:
6585:
4216:
types of all of these are integers, but their values are equivalent to those held by pointer types.
7670:
7648:
7575:
7428:
7420:
7340:
7169:
6364:
However, in some commercial and open source Pascal (or derivatives) compiler implementations —like
4087:
It is possible to simulate pointer behavior using an index to an (normally one-dimensional) array.
1242:
622:
5906:
language provides full support for pointers to all data types (including pointers to structures),
7653:
7633:
7585:
7560:
7345:
7314:
7130:
6952:
6598:
6377:
6317:
and its variants are still safer with respect to pointers than Modula-2 or its variants. As with
6278:
4471:
4190:
3384:
3260:, pointers that are not specifically initialized may point to unpredictable addresses in memory.
3155:
3120:
2088:
1259:
861:
However, initializing pointers unnecessarily could hinder program analysis, thereby hiding bugs.
855:
851:
607:
501:) is a primitive, the value of which is intended to be used as a memory address; it is said that
6632:
6606:
7116:
Joint
Technical Committee ISO/IEC JTC 1, Subcommittee SC 22, Working Group WG 14 (2007-09-08).
6998:
6820:
4456:
1882:/* a copy of the int n can be changed within the function without affecting the calling code */
7540:
7470:
7445:
7259:
7254:
6966:
6763:
6759:
6752:
6636:
6494:
6479:
6346:
6281:
being thrown. The space occupied by unreferenced memory objects is recovered automatically by
3124:
1254:
746:
684:
647:
351:
253:
221:
218:
7685:
7570:
7368:
7117:
7079:
6791:
6787:
6590:
6454:
6429:
5891:
4895:
3849:
3243:
3219:
3135:
2792:
1862:
1642:
1219:
1203:
935:
will be 0x8130 after the assignment. To dereference the pointer, an asterisk is used again:
719:
of memory addresses facilitates treating variables as slots into which data can be assigned
587:
419:
288:
194:
3108:, replace pointers with a more opaque type of reference, typically referred to as simply a
738:, pointers are used as references to explicitly tie one piece of the structure to another.
342:
which does not allow such. Because pointers allow both protected and unprotected access to
7690:
7555:
7507:
7440:
7142:
7098:
7091:
7017:
J. Welsh, W. J. Sneeringer, and C. A. R. Hoare, "Ambiguities and
Insecurities in Pascal,"
7005:
6439:
6434:
4162:
4158:
4144:
processor/language in another language that does not support pointers at all (for example
4095:
3475:
2887:
2655:
1223:
651:
583:
465:
438:
363:
319:
214:
7044:
6249:
function. In an approach to unified syntax between pointers and non-pointers, the arrow (
5625:, pointers are supported by either marking blocks of code that include pointers with the
4510:
is 1 by definition.) In particular, the C definition explicitly declares that the syntax
574:, is assigned to each unit of memory in the system, where the unit is typically either a
6872:
2495:
for deallocating a previously allocated memory block and returning it back to the heap.
1253:
on a half-word, word or double-word boundary (but, requiring an additional "shift left"
7643:
7465:
7455:
7363:
6805:
6625:
6499:
6469:
6459:
5774:
4125:
It is even theoretically possible, using the above technique, together with a suitable
4107:
3440:
to mean the same thing. However, the meaning of that term has been used in other ways:
1227:
1199:
692:
635:
566:
343:
249:
210:
7720:
7565:
6965:
Ulf
Bilting, Jan Skansholm, "Vägen till C" (the Road to C), third edition, page 169,
6747:
6602:
6373:
4439:
3821:
3395:
Where a pointer is used as the address of the entry point to a program or start of a
3223:
3151:
3089:
2779:
2658:. Below is a simple example declaring a pointer of type int and initialising it to a
384:
261:
182:
1921:/* a pointer m is passed instead. No copy of the value pointed to by m is created */
1182:
will yield the value of 8 because the previous instruction modified the contents of
7522:
7497:
6561:
6444:
6369:
6245:
internally they are pointers to mutable structures), and are initialized using the
5806:
5794:
5642:
5638:
4565:) do not permit direct access to memory using addresses. Also, the safe C dialect
4554:
4420:
4165:
can usually be actioned for the compiler (or if not, hand coded in the simulator).
4133:
3209:
3183:
3116:
3072:
3068:
2783:
1279:
818:
727:
537:
335:
292:
257:
150:
17:
6893:
228:
a location in memory, and obtaining the value stored at that location is known as
5872:
clauses. The values of such pointer variables are established and modified using
4474:. Adding or subtracting from a pointer moves it by a multiple of the size of its
7700:
7695:
7545:
7492:
7319:
6449:
6365:
5976:
is a derivative of C and C++ which fully supports C pointers and C typecasting.
4231:, have exhaustive pointer implementations, however. In FreeBASIC, arithmetic on
4195:
4072:
3482:
in terms of an element that contains a pointer to the next element of the list:
3479:
3404:
3231:
3179:
3128:
2708:
2659:
1728:
1526:
752:
735:
707:
703:
650:, which allows some addresses to refer to units of memory while others refer to
639:
545:
355:
272:
145:
and pointer variables to be among computer science's "most valuable treasures."
42:
5352:
The following declarations involving pointers-to-member are valid only in C++:
354:(or contain invalid data). To alleviate this potential problem, as a matter of
7605:
7600:
7517:
7485:
7390:
7333:
5915:
5842:
5830:
variable, but their contents are implicitly accessed indirectly through their
4558:
4149:
3396:
2787:
1522:
1443:
While most operators on arrays and pointers are equivalent, the result of the
961:(which is 0x8130), "locate" that address in memory and set its value to 8. If
6917:
6361:) means that the risk of dangling pointers has not been entirely eliminated.
7680:
7658:
7615:
7610:
7277:
7233:
7192:
6389:
5953:
to perform the arithmetic. Pointer arithmetic is always performed in bytes.
5907:
5848:
4874:
In C++ pointers to non-static members of a class can be defined. If a class
4483:
4224:
4137:
3836:
is a pointer to the 0th string (by convention the name of the program), and
3028:
values, and comparison problems, especially with signed vs unsigned values.
3025:
1246:
680:
529:
311:
6718:
NULL... which expands to an implementation-defined null pointer constant...
2014:// the value was changed inside the function, but x is still 3 from here on
548:
of a pointer determines the type of the datum to which the pointer points.
6594:
663:
Pointers are directly supported without restrictions in languages such as
7595:
6464:
6349:, but the ability to dynamically let go of referenced space by using the
6318:
6302:
6298:
4589:, is supported in ANSI C and C++ as a generic pointer type. A pointer to
4475:
4228:
4103:
2804:
1271:
1048:(The NULL pointer shown here is 0x00000000.) By assigning the address of
821:
value, which is traditionally specified in C with the standardized macro
610:(segfault). The second case is possible in the current implementation of
479:
primitive is an array of bytes, and some programs use words in this way.
305:
A pointer is a simple, more concrete implementation of the more abstract
6229:
Fortran-2003 adds support for procedure pointers. Also, as part of the
5862:
Extended versions of COBOL also provide pointer variables declared with
4486:
has no size, and thus the pointed address can not be added to, although
4431:
968:
This example may be clearer if memory is examined directly. Assume that
6474:
5997:
4413:
4115:
3134:
In systems with explicit memory allocation, it is possible to create a
2808:
2654:
Assigning addresses to pointers is an invaluable tool when programming
646:
In order to provide a consistent interface, some architectures provide
347:
7088:
Introduction to pointers – Stanford
Computer Science Education Library
6938:
4090:
Primarily for languages which do not support pointers explicitly but
3556:// Given a sorted list at *head, insert the element item at the first
3115:
A pointer which does not have any address assigned to it is called a
2490:
2092:
2035:// x was actually changed by the function and is now equal to 14 here
1445:
1437:
626:
611:
189:
for both pointers and non-pointers; this need should not be the case.
5926:
variables. A based variable can be declared with a default locator (
3832:
itself is a pointer to an array of strings (an array of arrays), so
326:
explicitly allows the pointer to be manipulated (arithmetically via
161:
7045:"// Making References (Perl References and nested data structures)"
5672:
assembly. This type is often returned when using methods from the
5555:/* function which returns pointer-to-member to an array of chars */
5206:
4427:
4397:
3147:
695:, as well as in passing data between different parts of a program.
672:
6534:
5818:
5597:/* an array of pointers-to-member-functions which return a char */
5534:/* pointer-to-member to pointer-to-member to pointer to char(s) */
5510:/* pointer-to-member to pointer-to-member to pointer to char(s) */
5210:
4220:
4212:
3887:// Function with two integer parameters returning an integer value
3559:// location where all earlier elements have lesser or equal value.
2712:
1718:
takes that memory address and dereferences it to access the value.
1267:
160:
7085:
6985:
6388:
standard procedures with it moves the pointer by the size of the
5681:// Get 16 bytes of memory from the process's unmanaged memory
271:
Pointers are also used to hold the addresses of entry points for
7213:
6806:"Pointers Are Complicated II, or: We need better language specs"
6792:
C – Approved standards: ISO/IEC 9899 – Programming languages – C
6409:
6396:
to point to. An untyped pointer is also provided under the name
6338:
5903:
5847:
statements or via embedded extended language constructs such as
4780:// this fails in C++: there is no implicit conversion from void*
4247:
pointers cannot be dereferenced, as in C. Also, casting between
3817:
3047:
2700:
2057:
In some programs, the required amount of memory depends on what
1847:
699:
664:
575:
443:
388:
7165:
5922:, which declares a pointer named "xxx". Pointers are used with
7208:
7082:
A beginner level guide describing pointers in a plain
English.
6321:, garbage collection is a part of the language specification.
5854:
4405:
4251:
and any other type's pointers will not generate any warnings.
3379:
may point to anywhere in memory, so performing the assignment
1525:
machine then memory will contain the following (values are in
603:
560:
on top of the addressing capabilities provided by most modern
36:
7161:
5257:/* pointer to pointer to char ("double pointer") */
4711:// when dereferencing inline, there is no implicit conversion
3399:
and is also either uninitialized or corrupted, if a call or
1521:
is located in memory starting at address 0x1000 on a 32-bit
1432:
This allocates a block of five integers and names the block
181:. In this diagram, the computing architecture uses the same
5347:/* an array of pointers to functions which return a char */
4660:// void* implicitly converted to int*: valid C, but not C++
1645:) and are stored consecutively starting at address 0x1000.
691:, which in turn are fundamental to constructing nearly all
590:– effectively transforming all of memory into a very large
5837:
Memory space for each pointed-to data object is typically
3980:// Function pointer which can point to a function like sum
3349:/* This is OK, assuming malloc() has not returned NULL. */
169:
pointing to the memory address associated with a variable
27:
Object which stores memory addresses in a computer program
6627:
Milestones in
Computer Science and Information Technology
5960:
PL/I compilers have a new form of typed pointer called a
5329:/* function which returns pointer to an array of chars */
4601:
for the “type-agnostic pointer” purpose (before ANSI C).
931:
is stored at memory location of 0x8130 then the value of
6293:
Pointers are implemented very much as in Pascal, as are
5486:/* function which returns a pointer-to-member to char */
2807:. For example, a pointer may be declared to point to an
509:
when the pointer's value is the datum's memory address.
7076:
A tool to convert pointer declarations to plain
English
4898:. They can be used on the right-hand side of operators
4494:
as a non-standard extension, treating it as if it were
4400:
pointers are variables that store addresses and can be
4118:
as the simulated pointer (this is quite similar to the
2072:
Pointers are used to store and manage the addresses of
518:
a pointer references a datum stored somewhere in memory
7104:
6329:
Unlike many languages that feature pointers, standard
4553:
While powerful, pointer arithmetic can be a source of
4546:
equally well to access the fourth element of an array
2557:/* Deallocate the name string saved within the Item */
2208:/* Allocate a block of memory for a new Item object */
791:
as the identifier of an object of the following type:
6353:
standard procedure (which has the same effect as the
5576:/* pointer-to-member-function which returns a char */
3263:
The following example code shows a dangling pointer:
2991:// UNDEFINED BEHAVIOUR if "the resulting pointer
7111:"The C book" – containing pointer examples in ANSI C
7073:
6997:
ISO 7185 Pascal Standard (unofficial copy), section
4490:
and other compilers will perform byte arithmetic on
3813:
is properly updated to the address of the new item.
1382:/* Arrays can be dereferenced with pointer syntax */
7624:
7533:
7419:
7389:
7354:
7242:
7199:
6261:There is no explicit representation of pointers in
5660:structure, which is a memory managed equivalent to
3383:can corrupt an unknown area of memory or trigger a
3131:(if used as a function pointer or branch address).
1661:means 0x1004: the "+ 1" means to add the size of 1
437:) is any datum that can be read from or written to
67:. Unsourced material may be challenged and removed.
6751:
6624:
1999:/* pass a copy of x's value as the argument */
1697:The last example is how to access the contents of
1302:can be declared and used in the following manner:
965:is later accessed again, its new value will be 8.
7101:A visual model for the beginners in C programming
6821:"Pointers Are Complicated, or: What's in a Byte?"
5293:/* function which returns a pointer to char(s) */
4526:, which is the content of the element pointed by
3316:/* (undefined) value of some place on the heap */
1468:Default values of an array can be declared like:
177:contains the memory address 1008 of the variable
6400:, which is compatible with other pointer types.
5656:However, an exception to this is from using the
5311:/* pointer to a function which returns a char */
4569:addresses many of the issues with pointers. See
3186:to eliminate pointer bugs, without resorting to
2084:, from which objects are dynamically allocated.
2157:/* Allocate and initialize a new Item object */
1865:, which are carefully checked for correctness.
1736:/* the empty linked list is represented by NULL
1352:/* Pointers can be indexed with array syntax */
213:. This can be that of another value located in
139:
7030:Free Pascal Language Reference guide, section
6754:ANSI and ISO Standard C Programmer's Reference
6566:"Structured Programming with go to Statements"
5789:class) which convert .NET types (for example,
4716:C++ does not allow the implicit conversion of
3478:. For example, in C it is typical to define a
441:using one memory access (for instance, both a
7177:
6742:
6740:
6265:. Instead, more complex data structures like
5886:Some extended versions of COBOL also provide
5429:/* pointer-to-member to pointer to char(s) */
4424:, but an implementation need not provide it.
3163:strings support reference counting natively.
2662:address in this example the constant 0x7FFF:
2355:/* Save a copy of the name in the new Item */
1708:is the memory location of the (i) element of
374:In 1955, Soviet Ukrainian computer scientist
155:Structured Programming, with go to Statements
8:
6731:, clause 6.5.3.2, paragraph 4, footnote 87:
5890:variables, which are capable of storing the
5468:/* pointer-to-member to array(s) of chars */
4058:// Calls function sum with arguments a and b
4031:// Calls function sum with arguments a and b
2265:/* Initialize the members of the new Item */
1784:/* next link; EMPTY_LIST if there is none */
730:operation typically involves a stage called
6986:Stanford Computer Science Education Library
4185:, and any attempt to access data through a
1266:A one byte offset, such as the hexadecimal
972:is located at address 0x8130 in memory and
850:Dereferencing a null pointer in C produces
802:This is usually stated more succinctly as "
687:. They are primarily used for constructing
582:– depending on whether the architecture is
244:for repetitive operations, like traversing
7184:
7170:
7162:
7152:) CS1 maint: numeric names: authors list (
5949:. IBM PL/I also has the builtin function
5914:, string handling, and extensive built-in
5447:/* pointer to pointer-to-member to char */
5205:equals for each of these types when using
2921:which says to cast the integer pointer of
2472:/* Return the newly created Item object */
2017:/* pass x's address as the argument */
1278:and then to an absolute address without a
7148:CS1 maint: multiple names: authors list (
6758:. Redmond, WA: Microsoft Press. pp.
6584:
5777:includes many classes and methods in the
5729:// Do something with the allocated memory
5408:/* array of pointers-to-member to char */
4193:to be raised. Pointers in Ada are called
3403:is nevertheless made to this address, a "
2720:#define VID ((unsigned short (*))0xB8000)
919:This assigns the value of the address of
795:pointer that points to an object of type
127:Learn how and when to remove this message
4169:Support in various programming languages
3840:is the 0th character of the 0th string.
1533:
1241:Relative addresses are a form of manual
1145:
1080:
1015:
233:variable is dependent on the underlying
7070:Paper from the June, 1967 issue of CACM
6553:
6522:
6345:. It also removes some risks caused by
2626:/* Deallocate the Item object itself */
1427:/* Subscript operator is commutative */
1214:pointers. These pointers can either be
1139:the computer will take the contents of
726:When dealing with arrays, the critical
512:More generally, a pointer is a kind of
334:) as a memory address, as opposed to a
186:
7138:
7128:
6631:. Greenwood Publishing Group. p.
3619:// p points to a pointer to an element
3397:function which doesn't return anything
3331:/* dangling (uninitialized) pointer */
240:Using pointers significantly improves
6668:. Awards.computer.org. Archived from
3824:, which is given in the prototype as
3367:/* This invokes undefined behavior */
3054:. Casting to an integer type such as
2770:
2707:video memory directly by casting the
2530:/* Check for a null object pointer */
1671:means to dereference the contents of
1412:/* Pointer addition is commutative */
7:
4906:to access the corresponding member.
4894:. This member can be an object or a
4506:pointers uses byte offsets, because
3436:The cited patent also uses the term
1727:Below is an example definition of a
1337:/* Arrays can be used as pointers */
1316:/* Declares 5 contiguous integers */
1078:yields the following memory values:
503:a pointer points to a memory address
464:) is a group of primitives that are
65:adding citations to reliable sources
7119:International Standard ISO/IEC 9899
7019:Software: Practice and Experience 7
6666:"IEEE Computer Society awards list"
5196:Pointer declaration syntax overview
3178:, and an optimisation based around
1648:The syntax for C with pointers is:
1449:operator differs. In this example,
544:) typed programming languages, the
76:"Pointer" computer programming
5278:/* pointer to array(s) of chars */
4858:(reference to void) to complement
1465:, the size of the pointer itself.
25:
5797:types and pointers (for example,
2994:// is not correctly aligned"
1739:* or some other sentinel value */
406:in a technical memorandum by the
5242:/* array of pointers to chars */
3998:// fp now points to function sum
3464:Kinds defined by use or datatype
3098:functional programming languages
3075:, also sometimes referred to as
2925:to a char pointer and assign to
2852:would be an integer pointer and
2774:
957:This means take the contents of
314:. Several languages, especially
41:
7727:Pointers (computer programming)
6297:parameters in procedure calls.
5986:Eiffel object-oriented language
5635:System.Runtime.CompilerServices
5390:/* pointer-to-member to char */
4083:Simulation using an array index
2500:/* Deallocate an Item object */
1854:with another link also of type
1457:(the size of the array), while
702:and the corresponding elements
52:needs additional citations for
6918:"Pointers to Member Functions"
6692:, clause 6.7.5.1, paragraph 1.
6305:) include garbage collection.
5805:) to allow communication with
5783:System.Runtime.InteropServices
5674:System.Runtime.InteropServices
5227:/* array of arrays of chars */
3828:—this is because the variable
3801:In this case, if the value of
1869:Pass-by-address using pointers
408:System Development Corporation
1:
7250:Arbitrary-precision or bignum
6939:"c++filt(1) - Linux man page"
6704:, clause 6.7.8, paragraph 10.
4557:. It tends to confuse novice
3154:, which use a simple form of
745:Pointers can also be used to
710:, these languages facilitate
564:. In the simplest scheme, an
402:first appeared in print as a
281:dynamic link libraries (DLLs)
6716:, clause 7.17, paragraph 3:
6485:Reference (computer science)
5892:addresses of executable code
5732:// Free the allocated memory
5649:keyword, which prevents the
5609:have a higher priority than
4239:) are treated as though the
4235:pointers (equivalent to C's
3822:main function in C (and C++)
1794:Haskell programming language
507:a pointer points to a datum
380:Address programming language
279:and for run-time linking to
217:, or in some cases, that of
6505:Variable (computer science)
6017:attribute. The Fortran-90
5664:, and does not require the
4886:is a pointer to the member
4538:, and one can write, e.g.,
3433:the auto relative pointer.
3024:), unexpected results when
3004:array starts at 0x2000 and
2815:, eliminating some errors.
475:; in a sense, a multi-byte
285:object-oriented programming
7753:
6728:
6713:
6701:
6689:
6357:library function found in
6013:to a variable which has a
4243:pointer was a byte width.
3816:A basic example is in the
3419:Kinds defined by structure
3241:
3207:
3016:will point to 0x2004, but
2799:Typed pointers and casting
2768:
2699:In the mid 80s, using the
2103:/* Parts inventory item */
606:architecture, be called a
522:to dereference the pointer
520:; to obtain that datum is
29:
7591:Strongly typed identifier
7092:Pointers in C programming
6623:Reilly, Edwin D. (2003).
4518:-th element of the array
4127:instruction set simulator
4110:, individual bytes (or a
3413:instruction set simulator
3194:Special kinds of pointers
3168:Rust programming language
3033:run-time type information
2782:that are used to control
2053:Dynamic memory allocation
1689:which is translated into
1274:' to a usable sequential
683:, and implicitly in most
596:general-purpose registers
556:Pointers are a very thin
422:, a pointer is a kind of
393:Oxford English Dictionary
6023:
5785:namespaces (such as the
5678:
5354:
5215:
4908:
4723:
4603:
4253:
4211:Several old versions of
4152:). To achieve this, the
4100:general-purpose register
3854:
3553:
3484:
3265:
2934:
2892:
2861:
2820:
2717:
2664:
2497:
2100:
1879:
1798:
1742:#define EMPTY_LIST NULL
1733:
1470:
1304:
1119:
1058:
978:
937:
866:
827:
770:
768:to define a pointer is:
616:general protection fault
32:Pointer (disambiguation)
7666:Parametric polymorphism
6490:Static program analysis
6009:is used to associate a
5928:DECLARE xxx BASED(ppp);
5623:C# programming language
4201:System.Storage_Elements
3258:C programming languages
2771:§ Function pointer
1842:is the empty list, and
1766:/* data of this link */
1529:, like the addresses):
505:. It is also said that
6750:; Brodie, Jim (1992).
6653:Harold Lawson pointer.
6273:are implemented using
5974:D programming language
4571:C programming language
3199:Kinds defined by value
3059:in academic research.
2813:floating-point numbers
2647:Memory-mapped hardware
2091:provides the function
1194:Use in data structures
1186:by way of the pointer
1113:Then by dereferencing
516:, and it is said that
277:procedural programming
190:
147:
6854:us patent 6115721
6835:us patent 6625718
6595:10.1145/356635.356640
5839:allocated dynamically
4573:for more discussion.
4530:. This implies that
4482:pointers because the
4136:or the intermediate (
3805:is less than that of
3438:self-relative pointer
3146:Some languages, like
3063:Making pointers safer
2765:Use in control tables
2074:dynamically allocated
1681:means element number
534:programming languages
300:virtual method tables
289:pointers to functions
235:computer architecture
207:programming languages
164:
143:assignment statements
7068:PL/I List Processing
7021:, pp. 685–696 (1977)
6875:. Msdn.microsoft.com
6510:Zero-based numbering
6413:programming language
6003:association operator
5947:ptr = ptr±expression
5920:DECLARE xxx POINTER;
4854:In C++, there is no
4436:C++ standard library
4094:support arrays, the
3775:// Caller does this:
3469:Multiple indirection
3430:autorelative pointer
3424:Autorelative pointer
3102:imperative languages
1701:. Breaking it down:
61:improve this article
30:For other uses, see
7737:American inventions
7671:Primitive data type
7576:Recursive data type
7429:Algebraic data type
7305:Quadruple precision
7086:Pointers and Memory
6999:6.4.4 Pointer-types
6898:cplusplus.github.io
6612:on August 24, 2009.
5793:) to and from many
5203:typeid(type).name()
4522:, is equivalent to
3092:or other variants.
3088:, by contrast with
3008:is 4 bytes whereas
2065:rather than on the
1665:, which is 4 bytes;
1243:memory segmentation
1178:Clearly, accessing
750:so may result in a
732:address calculation
623:memory segmentation
552:Architectural roots
376:Kateryna Yushchenko
316:low-level languages
18:Pointer (computing)
7634:Abstract data type
7315:Extended precision
7274:Reduced precision
7097:2019-06-09 at the
7047:. Perldoc.perl.org
7004:2017-04-24 at the
6988:, pp. 9–10 (2000).
6378:Embarcadero Delphi
6283:garbage collection
6231:C Interoperability
5932:DECLARE xxx BASED;
5058:// pointer to S::f
5016:// pointer to S::a
4472:undefined behavior
4468:Pointer arithmetic
4219:Newer dialects of
4189:pointer causes an
3385:segmentation fault
3188:garbage collection
3156:reference counting
3141:garbage collection
3121:segmentation fault
3069:programming errors
2949:"abcdef"
2818:For example, in C
2775:§ Wild branch
2089:standard C library
1712:, starting at i=0;
1260:flat address space
927:. For example, if
856:segmentation fault
852:undefined behavior
685:assembly languages
608:segmentation fault
414:Formal description
330:pointer arithmetic
191:
7714:
7713:
7446:Associative array
7310:Octuple precision
7043:Contact details.
6953:"Itanium C++ ABI"
6769:978-1-55615-359-4
6573:Computing Surveys
6495:Storage violation
6480:Pointer swizzling
6347:dangling pointers
5888:PROCEDURE-POINTER
5651:garbage collector
4870:Pointer-to-member
4534:is equivalent to
3176:pointer lifetimes
3125:storage violation
3039:Value of pointers
2151:/* Cost */
2139:/* Part name */
2124:/* Part number */
1863:wrapper functions
1637:
1636:
1461:will evaluate to
1453:will evaluate to
1294:be equivalent to
1255:bitwise operation
1176:
1175:
1111:
1110:
1046:
1045:
648:memory-mapped I/O
453:are primitives).
222:computer hardware
137:
136:
129:
111:
16:(Redirected from
7744:
7686:Type constructor
7571:Opaque data type
7503:Record or Struct
7300:Double precision
7295:Single precision
7186:
7179:
7172:
7163:
7157:
7146:
7140:
7136:
7134:
7126:
7124:
7056:
7055:
7053:
7052:
7040:
7034:
7028:
7022:
7015:
7009:
6995:
6989:
6979:
6973:
6963:
6957:
6956:
6949:
6943:
6942:
6935:
6929:
6928:
6926:
6925:
6914:
6908:
6907:
6905:
6904:
6890:
6884:
6883:
6881:
6880:
6873:"Based Pointers"
6869:
6863:
6862:
6861:
6857:
6850:
6844:
6843:
6842:
6838:
6831:
6825:
6824:
6816:
6810:
6809:
6801:
6795:
6785:
6779:
6778:
6757:
6744:
6735:
6726:
6720:
6711:
6705:
6699:
6693:
6687:
6681:
6680:
6678:
6677:
6662:
6656:
6655:
6650:
6649:
6630:
6620:
6614:
6613:
6611:
6605:. Archived from
6588:
6570:
6558:
6542:
6540:
6532:
6527:
6455:Function pointer
6430:Address constant
6399:
6387:
6383:
6356:
6352:
6296:
6252:
6248:
6225:
6222:
6219:
6216:
6213:
6210:
6207:
6204:
6201:
6198:
6195:
6192:
6189:
6186:
6183:
6180:
6177:
6174:
6171:
6168:
6165:
6162:
6159:
6156:
6153:
6150:
6147:
6144:
6141:
6138:
6135:
6132:
6129:
6126:
6123:
6120:
6117:
6114:
6111:
6108:
6105:
6102:
6099:
6096:
6093:
6090:
6087:
6084:
6081:
6078:
6075:
6072:
6069:
6066:
6063:
6060:
6057:
6054:
6051:
6048:
6045:
6042:
6039:
6036:
6033:
6030:
6027:
6020:
6016:
6012:
6008:
5963:
5952:
5948:
5941:
5937:
5933:
5929:
5925:
5921:
5889:
5882:
5879:
5875:
5871:
5868:
5865:
5857:
5851:
5845:
5833:
5829:
5824:
5804:
5800:
5792:
5788:
5784:
5780:
5769:
5766:
5763:
5760:
5757:
5754:
5751:
5748:
5745:
5742:
5739:
5736:
5733:
5730:
5727:
5724:
5721:
5718:
5715:
5712:
5709:
5706:
5703:
5700:
5697:
5694:
5691:
5688:
5685:
5682:
5675:
5671:
5670:CompilerServices
5668:keyword nor the
5667:
5663:
5659:
5648:
5636:
5632:
5628:
5612:
5608:
5605:
5598:
5595:
5592:
5589:
5586:
5583:
5580:
5577:
5574:
5571:
5568:
5565:
5562:
5559:
5556:
5553:
5550:
5547:
5544:
5541:
5538:
5535:
5532:
5529:
5526:
5523:
5520:
5517:
5514:
5511:
5508:
5505:
5502:
5499:
5496:
5493:
5490:
5487:
5484:
5481:
5478:
5475:
5472:
5469:
5466:
5463:
5460:
5457:
5454:
5451:
5448:
5445:
5442:
5439:
5436:
5433:
5430:
5427:
5424:
5421:
5418:
5415:
5412:
5409:
5406:
5403:
5400:
5397:
5394:
5391:
5388:
5385:
5382:
5379:
5376:
5373:
5370:
5367:
5364:
5361:
5358:
5348:
5345:
5342:
5339:
5336:
5333:
5330:
5327:
5324:
5321:
5318:
5315:
5312:
5309:
5306:
5303:
5300:
5297:
5294:
5291:
5288:
5285:
5282:
5279:
5276:
5273:
5270:
5267:
5264:
5261:
5258:
5255:
5252:
5249:
5246:
5243:
5240:
5237:
5234:
5231:
5228:
5225:
5222:
5219:
5204:
5191:
5188:
5185:
5182:
5179:
5176:
5173:
5170:
5167:
5164:
5161:
5158:
5155:
5152:
5149:
5146:
5143:
5140:
5137:
5134:
5131:
5128:
5125:
5122:
5119:
5116:
5113:
5110:
5107:
5104:
5101:
5098:
5095:
5092:
5089:
5086:
5083:
5080:
5077:
5074:
5071:
5068:
5065:
5062:
5059:
5056:
5053:
5050:
5047:
5044:
5041:
5038:
5035:
5032:
5029:
5026:
5023:
5020:
5017:
5014:
5011:
5008:
5005:
5002:
4999:
4996:
4993:
4990:
4987:
4984:
4981:
4978:
4975:
4972:
4969:
4966:
4963:
4960:
4957:
4954:
4951:
4948:
4945:
4942:
4939:
4936:
4933:
4930:
4927:
4924:
4921:
4918:
4915:
4912:
4905:
4901:
4893:
4889:
4885:
4881:
4877:
4865:
4861:
4857:
4850:
4847:
4844:
4841:
4838:
4835:
4832:
4829:
4828:reinterpret_cast
4826:
4823:
4820:
4817:
4814:
4811:
4808:
4805:
4802:
4799:
4796:
4793:
4790:
4787:
4784:
4781:
4778:
4775:
4772:
4769:
4766:
4763:
4760:
4757:
4754:
4751:
4748:
4745:
4742:
4739:
4736:
4733:
4730:
4727:
4719:
4712:
4709:
4706:
4703:
4700:
4697:
4694:
4691:
4688:
4685:
4682:
4679:
4676:
4673:
4670:
4667:
4664:
4661:
4658:
4655:
4652:
4649:
4646:
4643:
4640:
4637:
4634:
4631:
4628:
4625:
4622:
4619:
4616:
4613:
4610:
4607:
4600:
4592:
4587:
4580:
4549:
4545:
4541:
4537:
4533:
4529:
4525:
4521:
4517:
4513:
4509:
4505:
4497:
4493:
4481:
4453:
4449:
4445:
4423:
4421:<stdint.h>
4411:
4383:
4380:
4377:
4374:
4371:
4368:
4365:
4362:
4359:
4356:
4353:
4350:
4347:
4344:
4341:
4338:
4335:
4332:
4329:
4326:
4323:
4320:
4317:
4314:
4311:
4308:
4305:
4302:
4299:
4296:
4293:
4290:
4287:
4284:
4281:
4278:
4275:
4272:
4269:
4266:
4263:
4260:
4257:
4250:
4246:
4242:
4238:
4234:
4202:
4188:
4184:
4062:
4059:
4056:
4053:
4050:
4047:
4044:
4041:
4038:
4035:
4032:
4029:
4026:
4023:
4020:
4017:
4014:
4011:
4008:
4005:
4002:
3999:
3996:
3993:
3990:
3987:
3984:
3981:
3978:
3975:
3972:
3969:
3966:
3963:
3960:
3957:
3954:
3951:
3948:
3945:
3942:
3939:
3936:
3933:
3930:
3927:
3924:
3921:
3918:
3915:
3912:
3909:
3906:
3903:
3900:
3897:
3894:
3891:
3888:
3885:
3882:
3879:
3876:
3873:
3870:
3867:
3864:
3861:
3858:
3850:function pointer
3844:Function pointer
3839:
3835:
3831:
3827:
3820:argument to the
3812:
3808:
3804:
3797:
3794:
3791:
3788:
3785:
3782:
3779:
3776:
3773:
3770:
3767:
3764:
3761:
3758:
3755:
3752:
3749:
3746:
3743:
3740:
3737:
3734:
3731:
3728:
3725:
3722:
3719:
3716:
3713:
3710:
3707:
3704:
3701:
3698:
3695:
3692:
3689:
3686:
3683:
3680:
3677:
3674:
3671:
3668:
3665:
3662:
3659:
3656:
3653:
3650:
3647:
3644:
3641:
3638:
3635:
3632:
3629:
3626:
3623:
3620:
3617:
3614:
3611:
3608:
3605:
3602:
3599:
3596:
3593:
3590:
3587:
3584:
3581:
3578:
3575:
3572:
3569:
3566:
3563:
3560:
3557:
3549:
3542:
3539:
3536:
3533:
3530:
3527:
3524:
3521:
3518:
3515:
3512:
3509:
3506:
3503:
3500:
3497:
3494:
3491:
3488:
3382:
3378:
3371:
3368:
3365:
3362:
3359:
3356:
3353:
3350:
3347:
3344:
3341:
3338:
3335:
3332:
3329:
3326:
3323:
3320:
3317:
3314:
3311:
3308:
3305:
3302:
3299:
3296:
3293:
3290:
3287:
3284:
3281:
3278:
3275:
3272:
3269:
3250:dangling pointer
3244:Dangling pointer
3238:Dangling pointer
3136:dangling pointer
3085:
3084:
3057:
3023:
3019:
3015:
3012:is 1 byte, then
3011:
3007:
3003:
2995:
2992:
2989:
2986:
2983:
2980:
2977:
2974:
2971:
2968:
2965:
2962:
2959:
2956:
2953:
2950:
2947:
2944:
2941:
2938:
2928:
2924:
2917:
2914:
2911:
2908:
2905:
2902:
2899:
2896:
2885:
2881:
2874:
2871:
2868:
2865:
2855:
2851:
2845:
2842:
2839:
2836:
2833:
2830:
2827:
2824:
2760:
2757:
2754:
2751:
2748:
2745:
2742:
2739:
2736:
2733:
2730:
2727:
2724:
2721:
2695:
2692:
2689:
2686:
2683:
2680:
2677:
2674:
2673:hardware_address
2671:
2668:
2656:microcontrollers
2642:
2639:
2636:
2633:
2630:
2627:
2624:
2621:
2618:
2615:
2612:
2609:
2606:
2603:
2600:
2597:
2594:
2591:
2588:
2585:
2582:
2579:
2576:
2573:
2570:
2567:
2564:
2561:
2558:
2555:
2552:
2549:
2546:
2543:
2540:
2537:
2534:
2531:
2528:
2525:
2522:
2519:
2516:
2513:
2510:
2507:
2504:
2501:
2493:
2485:
2482:
2479:
2476:
2473:
2470:
2467:
2464:
2461:
2458:
2455:
2452:
2449:
2446:
2443:
2440:
2437:
2434:
2431:
2428:
2425:
2422:
2419:
2416:
2413:
2410:
2407:
2404:
2401:
2398:
2395:
2392:
2389:
2386:
2383:
2380:
2377:
2374:
2371:
2368:
2365:
2362:
2359:
2356:
2353:
2350:
2347:
2344:
2341:
2338:
2335:
2332:
2329:
2326:
2323:
2320:
2317:
2314:
2311:
2308:
2305:
2302:
2299:
2296:
2293:
2290:
2287:
2284:
2281:
2278:
2275:
2272:
2269:
2266:
2263:
2260:
2257:
2254:
2251:
2248:
2245:
2242:
2239:
2236:
2233:
2230:
2227:
2224:
2221:
2218:
2215:
2212:
2209:
2206:
2203:
2200:
2197:
2194:
2191:
2188:
2185:
2182:
2179:
2176:
2173:
2170:
2167:
2164:
2161:
2158:
2155:
2152:
2149:
2146:
2143:
2140:
2137:
2134:
2131:
2128:
2125:
2122:
2119:
2116:
2113:
2110:
2107:
2104:
2095:
2048:
2045:
2042:
2039:
2036:
2033:
2030:
2027:
2024:
2021:
2018:
2015:
2012:
2009:
2006:
2003:
2000:
1997:
1994:
1991:
1988:
1985:
1982:
1979:
1976:
1973:
1970:
1967:
1964:
1961:
1958:
1955:
1952:
1949:
1946:
1943:
1940:
1937:
1934:
1931:
1928:
1925:
1922:
1919:
1916:
1913:
1910:
1907:
1904:
1901:
1898:
1895:
1892:
1889:
1886:
1883:
1857:
1853:
1845:
1841:
1835:
1832:
1829:
1826:
1823:
1820:
1817:
1814:
1811:
1808:
1805:
1802:
1788:
1785:
1782:
1779:
1776:
1773:
1770:
1767:
1764:
1761:
1758:
1755:
1752:
1749:
1746:
1743:
1740:
1737:
1717:
1711:
1707:
1700:
1692:
1688:
1684:
1680:
1674:
1670:
1664:
1660:
1654:
1643:CPU architecture
1534:
1520:
1513:
1510:
1507:
1504:
1501:
1498:
1495:
1492:
1489:
1486:
1483:
1480:
1477:
1474:
1464:
1460:
1456:
1452:
1448:
1435:
1428:
1425:
1422:
1419:
1416:
1413:
1410:
1407:
1404:
1401:
1398:
1395:
1392:
1389:
1386:
1383:
1380:
1377:
1374:
1371:
1368:
1365:
1362:
1359:
1356:
1353:
1350:
1347:
1344:
1341:
1338:
1335:
1332:
1329:
1326:
1323:
1320:
1317:
1314:
1311:
1308:
1301:
1297:
1293:
1263:) is preferred.
1220:physical address
1198:When setting up
1189:
1185:
1181:
1146:
1142:
1135:
1132:
1129:
1126:
1123:
1116:
1081:
1074:
1071:
1068:
1065:
1062:
1055:
1051:
1016:
1012:
1009:
1006:
1003:
1000:
997:
994:
991:
988:
985:
982:
975:
971:
964:
960:
953:
950:
947:
944:
941:
934:
930:
926:
922:
915:
912:
909:
906:
903:
900:
897:
894:
891:
888:
885:
882:
879:
876:
873:
870:
846:
843:
840:
837:
834:
831:
824:
816:
809:
806:is a pointer to
805:
798:
790:
783:
780:
777:
774:
652:device registers
588:word-addressable
584:byte-addressable
420:computer science
344:memory addresses
332:
331:
195:computer science
157:
132:
125:
121:
118:
112:
110:
69:
45:
37:
21:
7752:
7751:
7747:
7746:
7745:
7743:
7742:
7741:
7732:Primitive types
7717:
7716:
7715:
7710:
7691:Type conversion
7626:
7620:
7556:Enumerated type
7529:
7415:
7409:null-terminated
7385:
7350:
7238:
7195:
7190:
7147:
7137:
7127:
7122:
7115:
7099:Wayback Machine
7064:
7059:
7050:
7048:
7042:
7041:
7037:
7029:
7025:
7016:
7012:
7008:and subsequent.
7006:Wayback Machine
6996:
6992:
6981:Nick Parlante,
6980:
6976:
6964:
6960:
6951:
6950:
6946:
6937:
6936:
6932:
6923:
6921:
6916:
6915:
6911:
6902:
6900:
6894:"CWG Issue 195"
6892:
6891:
6887:
6878:
6876:
6871:
6870:
6866:
6859:
6852:
6851:
6847:
6840:
6833:
6832:
6828:
6818:
6817:
6813:
6803:
6802:
6798:
6786:
6782:
6770:
6746:
6745:
6738:
6727:
6723:
6712:
6708:
6700:
6696:
6688:
6684:
6675:
6673:
6664:
6663:
6659:
6647:
6645:
6643:
6622:
6621:
6617:
6609:
6586:10.1.1.103.6084
6568:
6560:
6559:
6555:
6551:
6546:
6545:
6538:
6530:
6528:
6524:
6519:
6514:
6440:Buffer overflow
6435:Bounded pointer
6425:
6406:
6397:
6385:
6381:
6354:
6350:
6327:
6311:
6294:
6291:
6259:
6250:
6246:
6239:
6227:
6226:
6223:
6220:
6217:
6214:
6211:
6208:
6205:
6202:
6199:
6196:
6193:
6190:
6187:
6184:
6181:
6178:
6175:
6172:
6169:
6166:
6163:
6160:
6157:
6154:
6151:
6148:
6145:
6142:
6139:
6136:
6133:
6130:
6127:
6124:
6121:
6118:
6115:
6112:
6109:
6106:
6103:
6100:
6097:
6094:
6091:
6088:
6085:
6082:
6079:
6076:
6073:
6070:
6067:
6064:
6061:
6058:
6055:
6052:
6049:
6046:
6043:
6040:
6037:
6034:
6031:
6028:
6025:
6018:
6014:
6010:
6006:
5995:
5982:
5970:
5961:
5950:
5946:
5939:
5935:
5931:
5927:
5923:
5919:
5900:
5887:
5880:
5877:
5873:
5869:
5866:
5863:
5855:
5849:
5843:
5841:using external
5831:
5828:WORKING-STORAGE
5827:
5823:LINKAGE SECTION
5822:
5815:
5802:
5798:
5790:
5786:
5782:
5778:
5771:
5770:
5767:
5764:
5761:
5758:
5755:
5752:
5749:
5747:InteropServices
5746:
5743:
5740:
5737:
5734:
5731:
5728:
5725:
5722:
5719:
5716:
5713:
5710:
5707:
5705:InteropServices
5704:
5701:
5698:
5695:
5692:
5689:
5686:
5683:
5680:
5676:, for example:
5673:
5669:
5665:
5661:
5657:
5646:
5634:
5630:
5629:keyword, or by
5626:
5619:
5610:
5607:
5603:
5600:
5599:
5596:
5593:
5590:
5587:
5584:
5581:
5578:
5575:
5572:
5569:
5566:
5563:
5560:
5557:
5554:
5551:
5548:
5545:
5542:
5539:
5536:
5533:
5530:
5527:
5524:
5521:
5518:
5515:
5512:
5509:
5506:
5503:
5500:
5497:
5494:
5491:
5488:
5485:
5482:
5479:
5476:
5473:
5470:
5467:
5464:
5461:
5458:
5455:
5452:
5449:
5446:
5443:
5440:
5437:
5434:
5431:
5428:
5425:
5422:
5419:
5416:
5413:
5410:
5407:
5404:
5401:
5398:
5395:
5392:
5389:
5386:
5383:
5380:
5377:
5374:
5371:
5368:
5365:
5362:
5359:
5356:
5350:
5349:
5346:
5343:
5340:
5337:
5334:
5331:
5328:
5325:
5322:
5319:
5316:
5313:
5310:
5307:
5304:
5301:
5298:
5295:
5292:
5289:
5286:
5283:
5280:
5277:
5274:
5271:
5268:
5265:
5262:
5259:
5256:
5253:
5250:
5247:
5244:
5241:
5238:
5235:
5232:
5229:
5226:
5223:
5220:
5217:
5202:
5198:
5193:
5192:
5189:
5186:
5183:
5180:
5177:
5174:
5171:
5168:
5165:
5162:
5159:
5156:
5153:
5150:
5147:
5144:
5141:
5138:
5135:
5132:
5129:
5126:
5123:
5120:
5117:
5114:
5111:
5108:
5105:
5102:
5099:
5096:
5093:
5090:
5087:
5084:
5081:
5078:
5075:
5072:
5069:
5066:
5063:
5060:
5057:
5054:
5051:
5048:
5045:
5042:
5039:
5036:
5033:
5030:
5027:
5024:
5021:
5018:
5015:
5012:
5009:
5006:
5003:
5000:
4997:
4994:
4991:
4988:
4985:
4982:
4979:
4976:
4973:
4970:
4967:
4964:
4961:
4958:
4955:
4952:
4949:
4946:
4943:
4940:
4937:
4934:
4931:
4928:
4925:
4922:
4919:
4916:
4913:
4910:
4903:
4899:
4891:
4887:
4883:
4879:
4875:
4872:
4863:
4859:
4855:
4852:
4851:
4848:
4845:
4842:
4839:
4836:
4833:
4830:
4827:
4824:
4821:
4818:
4815:
4813:// C-style cast
4812:
4809:
4806:
4803:
4800:
4797:
4794:
4791:
4788:
4785:
4782:
4779:
4776:
4773:
4770:
4767:
4764:
4761:
4758:
4755:
4752:
4749:
4746:
4743:
4740:
4737:
4734:
4731:
4728:
4725:
4717:
4714:
4713:
4710:
4707:
4704:
4701:
4698:
4695:
4692:
4689:
4686:
4683:
4680:
4677:
4674:
4671:
4668:
4665:
4662:
4659:
4656:
4653:
4650:
4647:
4644:
4641:
4638:
4635:
4632:
4629:
4626:
4623:
4620:
4617:
4614:
4611:
4608:
4605:
4598:
4590:
4585:
4578:
4547:
4543:
4539:
4535:
4531:
4527:
4523:
4519:
4515:
4514:, which is the
4511:
4507:
4503:
4495:
4491:
4479:
4451:
4447:
4443:
4419:
4409:
4390:
4385:
4384:
4381:
4378:
4375:
4372:
4369:
4366:
4363:
4360:
4357:
4354:
4351:
4348:
4345:
4342:
4339:
4336:
4333:
4330:
4327:
4324:
4321:
4318:
4315:
4312:
4309:
4306:
4303:
4300:
4297:
4294:
4291:
4288:
4285:
4282:
4279:
4276:
4273:
4270:
4267:
4264:
4261:
4258:
4255:
4248:
4244:
4240:
4236:
4232:
4209:
4200:
4186:
4182:
4176:
4171:
4163:bounds checking
4159:buffer overflow
4085:
4077:tree structures
4069:
4064:
4063:
4060:
4057:
4054:
4051:
4048:
4045:
4042:
4039:
4036:
4033:
4030:
4027:
4024:
4021:
4018:
4015:
4012:
4009:
4006:
4003:
4000:
3997:
3994:
3991:
3988:
3985:
3982:
3979:
3976:
3973:
3970:
3967:
3964:
3961:
3958:
3955:
3952:
3949:
3946:
3943:
3940:
3937:
3934:
3931:
3928:
3925:
3922:
3919:
3916:
3913:
3910:
3907:
3904:
3901:
3898:
3895:
3892:
3889:
3886:
3883:
3880:
3877:
3874:
3871:
3868:
3865:
3862:
3859:
3856:
3846:
3837:
3833:
3829:
3825:
3810:
3809:, the caller's
3806:
3802:
3799:
3798:
3795:
3792:
3789:
3786:
3783:
3780:
3777:
3774:
3771:
3768:
3765:
3762:
3759:
3756:
3753:
3750:
3747:
3744:
3741:
3738:
3735:
3732:
3729:
3726:
3723:
3720:
3717:
3714:
3711:
3708:
3705:
3702:
3699:
3696:
3693:
3690:
3687:
3684:
3681:
3678:
3675:
3672:
3669:
3666:
3663:
3660:
3657:
3654:
3651:
3648:
3645:
3642:
3639:
3636:
3633:
3630:
3627:
3624:
3621:
3618:
3615:
3612:
3609:
3606:
3603:
3600:
3597:
3594:
3591:
3588:
3585:
3582:
3579:
3576:
3573:
3570:
3567:
3564:
3561:
3558:
3555:
3547:
3544:
3543:
3540:
3537:
3534:
3531:
3528:
3525:
3522:
3519:
3516:
3513:
3510:
3507:
3504:
3501:
3498:
3495:
3492:
3489:
3486:
3476:data structures
3471:
3466:
3454:
3426:
3421:
3393:
3380:
3376:
3373:
3372:
3369:
3366:
3363:
3360:
3357:
3354:
3351:
3348:
3345:
3342:
3339:
3336:
3333:
3330:
3327:
3324:
3321:
3318:
3315:
3312:
3309:
3306:
3303:
3300:
3297:
3294:
3291:
3288:
3285:
3282:
3279:
3276:
3273:
3270:
3267:
3246:
3240:
3212:
3206:
3201:
3196:
3082:
3081:
3077:pointer hazards
3065:
3055:
3041:
3021:
3017:
3013:
3009:
3005:
3001:
2997:
2996:
2993:
2990:
2987:
2985:external_buffer
2984:
2981:
2978:
2975:
2972:
2969:
2966:
2963:
2960:
2957:
2954:
2951:
2948:
2945:
2943:external_buffer
2942:
2939:
2936:
2926:
2922:
2919:
2918:
2915:
2912:
2909:
2906:
2903:
2900:
2897:
2894:
2883:
2879:
2876:
2875:
2872:
2869:
2866:
2863:
2853:
2849:
2847:
2846:
2843:
2840:
2837:
2834:
2831:
2828:
2825:
2822:
2801:
2777:
2767:
2762:
2761:
2758:
2755:
2752:
2749:
2746:
2743:
2740:
2737:
2734:
2731:
2728:
2725:
2722:
2719:
2697:
2696:
2693:
2690:
2687:
2684:
2681:
2678:
2675:
2672:
2669:
2666:
2649:
2644:
2643:
2640:
2637:
2634:
2631:
2628:
2625:
2622:
2619:
2616:
2613:
2610:
2607:
2604:
2601:
2598:
2595:
2592:
2589:
2586:
2583:
2580:
2577:
2574:
2571:
2568:
2565:
2562:
2559:
2556:
2553:
2550:
2547:
2544:
2541:
2538:
2535:
2532:
2529:
2526:
2523:
2520:
2517:
2514:
2511:
2508:
2505:
2502:
2499:
2491:
2487:
2486:
2483:
2480:
2477:
2474:
2471:
2468:
2465:
2462:
2459:
2456:
2453:
2450:
2447:
2444:
2441:
2438:
2435:
2432:
2429:
2426:
2423:
2420:
2417:
2414:
2411:
2408:
2405:
2402:
2399:
2396:
2393:
2390:
2387:
2384:
2381:
2378:
2375:
2372:
2369:
2366:
2363:
2360:
2357:
2354:
2351:
2348:
2345:
2342:
2339:
2336:
2333:
2330:
2327:
2324:
2321:
2318:
2315:
2312:
2309:
2306:
2303:
2300:
2297:
2294:
2291:
2288:
2285:
2282:
2279:
2276:
2273:
2270:
2267:
2264:
2261:
2258:
2255:
2252:
2249:
2246:
2243:
2240:
2237:
2234:
2231:
2228:
2225:
2222:
2219:
2216:
2213:
2210:
2207:
2204:
2201:
2198:
2195:
2192:
2189:
2186:
2183:
2180:
2177:
2174:
2171:
2168:
2165:
2162:
2159:
2156:
2153:
2150:
2147:
2144:
2141:
2138:
2135:
2132:
2129:
2126:
2123:
2120:
2117:
2114:
2111:
2108:
2105:
2102:
2093:
2055:
2050:
2049:
2046:
2043:
2040:
2037:
2034:
2031:
2028:
2025:
2022:
2019:
2016:
2013:
2010:
2007:
2004:
2001:
1998:
1995:
1992:
1989:
1986:
1983:
1980:
1977:
1974:
1971:
1968:
1965:
1962:
1959:
1956:
1953:
1950:
1947:
1944:
1941:
1938:
1935:
1932:
1929:
1926:
1923:
1920:
1917:
1914:
1911:
1908:
1905:
1902:
1899:
1896:
1893:
1890:
1887:
1884:
1881:
1871:
1855:
1851:
1844:Cons a (Link a)
1843:
1839:
1837:
1836:
1833:
1830:
1827:
1824:
1821:
1818:
1815:
1812:
1809:
1806:
1803:
1800:
1790:
1789:
1786:
1783:
1780:
1777:
1774:
1771:
1768:
1765:
1762:
1759:
1756:
1753:
1750:
1747:
1744:
1741:
1738:
1735:
1725:
1715:
1709:
1705:
1698:
1690:
1686:
1682:
1678:
1672:
1668:
1662:
1658:
1652:
1518:
1515:
1514:
1511:
1508:
1505:
1502:
1499:
1496:
1493:
1490:
1487:
1484:
1481:
1478:
1475:
1472:
1462:
1458:
1454:
1450:
1444:
1433:
1430:
1429:
1426:
1423:
1420:
1417:
1414:
1411:
1408:
1405:
1402:
1399:
1396:
1393:
1390:
1387:
1384:
1381:
1378:
1375:
1372:
1369:
1366:
1363:
1360:
1357:
1354:
1351:
1348:
1345:
1342:
1339:
1336:
1333:
1330:
1327:
1324:
1321:
1318:
1315:
1312:
1309:
1306:
1299:
1295:
1291:
1288:
1224:virtual address
1200:data structures
1196:
1187:
1183:
1179:
1140:
1137:
1136:
1133:
1130:
1127:
1124:
1121:
1114:
1076:
1075:
1072:
1069:
1066:
1063:
1060:
1053:
1049:
1014:
1013:
1010:
1007:
1004:
1001:
998:
995:
992:
989:
986:
983:
980:
973:
969:
962:
958:
955:
954:
951:
948:
945:
942:
939:
932:
928:
924:
920:
917:
916:
913:
910:
907:
904:
901:
898:
895:
892:
889:
886:
883:
880:
877:
874:
871:
868:
848:
847:
844:
841:
838:
835:
832:
829:
822:
814:
807:
803:
796:
788:
785:
784:
781:
778:
775:
772:
762:
693:data structures
661:
570:, or a numeric
554:
439:computer memory
416:
372:
364:bounds checking
329:
328:
320:data structures
275:subroutines in
215:computer memory
159:
149:
133:
122:
116:
113:
70:
68:
58:
46:
35:
28:
23:
22:
15:
12:
11:
5:
7750:
7748:
7740:
7739:
7734:
7729:
7719:
7718:
7712:
7711:
7709:
7708:
7703:
7698:
7693:
7688:
7683:
7678:
7673:
7668:
7663:
7662:
7661:
7651:
7646:
7644:Data structure
7641:
7636:
7630:
7628:
7622:
7621:
7619:
7618:
7613:
7608:
7603:
7598:
7593:
7588:
7583:
7578:
7573:
7568:
7563:
7558:
7553:
7548:
7543:
7537:
7535:
7531:
7530:
7528:
7527:
7526:
7525:
7515:
7510:
7505:
7500:
7495:
7490:
7489:
7488:
7478:
7473:
7468:
7463:
7458:
7453:
7448:
7443:
7438:
7437:
7436:
7425:
7423:
7417:
7416:
7414:
7413:
7412:
7411:
7401:
7395:
7393:
7387:
7386:
7384:
7383:
7378:
7377:
7376:
7371:
7360:
7358:
7352:
7351:
7349:
7348:
7343:
7338:
7337:
7336:
7326:
7325:
7324:
7323:
7322:
7312:
7307:
7302:
7297:
7292:
7291:
7290:
7285:
7283:Half precision
7280:
7270:Floating point
7267:
7262:
7257:
7252:
7246:
7244:
7240:
7239:
7237:
7236:
7231:
7226:
7221:
7216:
7211:
7205:
7203:
7197:
7196:
7191:
7189:
7188:
7181:
7174:
7166:
7160:
7159:
7113:
7108:
7102:
7089:
7083:
7077:
7071:
7063:
7062:External links
7060:
7058:
7057:
7035:
7023:
7010:
6990:
6974:
6958:
6944:
6930:
6909:
6885:
6864:
6845:
6826:
6811:
6796:
6780:
6768:
6736:
6721:
6706:
6694:
6682:
6657:
6641:
6615:
6579:(5): 261–301.
6552:
6550:
6547:
6544:
6543:
6521:
6520:
6518:
6515:
6513:
6512:
6507:
6502:
6500:Tagged pointer
6497:
6492:
6487:
6482:
6477:
6472:
6470:Opaque pointer
6467:
6462:
6460:Hazard pointer
6457:
6452:
6447:
6442:
6437:
6432:
6426:
6424:
6421:
6405:
6402:
6326:
6323:
6310:
6307:
6290:
6287:
6258:
6255:
6238:
6235:
6215:real_list_temp
6209:real_list_temp
6197:real_list_temp
6161:real_list_temp
6125:real_list_temp
6122:real_list_temp
6024:
5994:
5991:
5981:
5978:
5969:
5966:
5940:qqq->xxx=1;
5899:
5896:
5814:
5811:
5807:unmanaged code
5775:.NET framework
5679:
5618:
5615:
5355:
5216:
5197:
5194:
4909:
4871:
4868:
4724:
4604:
4462:reference type
4440:smart pointers
4438:also provides
4408:specifies the
4389:
4386:
4254:
4208:
4205:
4175:
4172:
4170:
4167:
4108:data structure
4084:
4081:
4068:
4065:
3855:
3845:
3842:
3554:
3485:
3470:
3467:
3465:
3462:
3453:
3450:
3449:
3448:
3445:
3425:
3422:
3420:
3417:
3392:
3389:
3266:
3242:Main article:
3239:
3236:
3224:nullable types
3208:Main article:
3205:
3202:
3200:
3197:
3195:
3192:
3172:borrow checker
3152:smart pointers
3090:smart pointers
3064:
3061:
3040:
3037:
2935:
2893:
2862:
2821:
2800:
2797:
2780:Control tables
2766:
2763:
2718:
2665:
2648:
2645:
2498:
2101:
2054:
2051:
1880:
1870:
1867:
1799:
1734:
1724:
1721:
1720:
1719:
1713:
1695:
1694:
1685:, 0-based, of
1676:
1666:
1656:
1639:
1638:
1635:
1634:
1631:
1628:
1625:
1622:
1618:
1617:
1614:
1611:
1608:
1605:
1601:
1600:
1597:
1594:
1591:
1588:
1584:
1583:
1580:
1577:
1574:
1571:
1567:
1566:
1563:
1560:
1557:
1554:
1550:
1549:
1546:
1543:
1540:
1537:
1471:
1305:
1287:
1284:
1228:virtual memory
1195:
1192:
1174:
1173:
1170:
1164:
1163:
1160:
1154:
1153:
1150:
1120:
1109:
1108:
1105:
1099:
1098:
1095:
1089:
1088:
1085:
1059:
1044:
1043:
1040:
1034:
1033:
1030:
1024:
1023:
1020:
979:
938:
867:
828:
800:
799:
787:This declares
771:
761:
758:
660:
657:
636:protected mode
553:
550:
495:memory pointer
458:data aggregate
431:data primitive
415:
412:
371:
368:
298:, often using
262:control tables
211:memory address
209:that stores a
187:data primitive
141:I do consider
138:
135:
134:
49:
47:
40:
26:
24:
14:
13:
10:
9:
6:
4:
3:
2:
7749:
7738:
7735:
7733:
7730:
7728:
7725:
7724:
7722:
7707:
7704:
7702:
7699:
7697:
7694:
7692:
7689:
7687:
7684:
7682:
7679:
7677:
7674:
7672:
7669:
7667:
7664:
7660:
7657:
7656:
7655:
7652:
7650:
7647:
7645:
7642:
7640:
7637:
7635:
7632:
7631:
7629:
7623:
7617:
7614:
7612:
7609:
7607:
7604:
7602:
7599:
7597:
7594:
7592:
7589:
7587:
7584:
7582:
7579:
7577:
7574:
7572:
7569:
7567:
7566:Function type
7564:
7562:
7559:
7557:
7554:
7552:
7549:
7547:
7544:
7542:
7539:
7538:
7536:
7532:
7524:
7521:
7520:
7519:
7516:
7514:
7511:
7509:
7506:
7504:
7501:
7499:
7496:
7494:
7491:
7487:
7484:
7483:
7482:
7479:
7477:
7474:
7472:
7469:
7467:
7464:
7462:
7459:
7457:
7454:
7452:
7449:
7447:
7444:
7442:
7439:
7435:
7432:
7431:
7430:
7427:
7426:
7424:
7422:
7418:
7410:
7407:
7406:
7405:
7402:
7400:
7397:
7396:
7394:
7392:
7388:
7382:
7379:
7375:
7372:
7370:
7367:
7366:
7365:
7362:
7361:
7359:
7357:
7353:
7347:
7344:
7342:
7339:
7335:
7332:
7331:
7330:
7327:
7321:
7318:
7317:
7316:
7313:
7311:
7308:
7306:
7303:
7301:
7298:
7296:
7293:
7289:
7286:
7284:
7281:
7279:
7276:
7275:
7273:
7272:
7271:
7268:
7266:
7263:
7261:
7258:
7256:
7253:
7251:
7248:
7247:
7245:
7241:
7235:
7232:
7230:
7227:
7225:
7222:
7220:
7217:
7215:
7212:
7210:
7207:
7206:
7204:
7202:
7201:Uninterpreted
7198:
7194:
7187:
7182:
7180:
7175:
7173:
7168:
7167:
7164:
7155:
7151:
7144:
7132:
7121:
7120:
7114:
7112:
7109:
7106:
7103:
7100:
7096:
7093:
7090:
7087:
7084:
7081:
7078:
7075:
7072:
7069:
7066:
7065:
7061:
7046:
7039:
7036:
7033:
7027:
7024:
7020:
7014:
7011:
7007:
7003:
7000:
6994:
6991:
6987:
6983:
6978:
6975:
6972:
6971:91-44-01468-6
6968:
6962:
6959:
6954:
6948:
6945:
6940:
6934:
6931:
6919:
6913:
6910:
6899:
6895:
6889:
6886:
6874:
6868:
6865:
6855:
6849:
6846:
6836:
6830:
6827:
6822:
6815:
6812:
6807:
6800:
6797:
6794:, 2005-05-06.
6793:
6789:
6784:
6781:
6777:
6776:
6771:
6765:
6761:
6756:
6755:
6749:
6743:
6741:
6737:
6734:
6730:
6725:
6722:
6719:
6715:
6710:
6707:
6703:
6698:
6695:
6691:
6686:
6683:
6672:on 2011-03-22
6671:
6667:
6661:
6658:
6654:
6644:
6642:9781573565219
6638:
6634:
6629:
6628:
6619:
6616:
6608:
6604:
6600:
6596:
6592:
6587:
6582:
6578:
6574:
6567:
6563:
6557:
6554:
6548:
6536:
6526:
6523:
6516:
6511:
6508:
6506:
6503:
6501:
6498:
6496:
6493:
6491:
6488:
6486:
6483:
6481:
6478:
6476:
6473:
6471:
6468:
6466:
6463:
6461:
6458:
6456:
6453:
6451:
6448:
6446:
6443:
6441:
6438:
6436:
6433:
6431:
6428:
6427:
6422:
6420:
6418:
6414:
6411:
6403:
6401:
6395:
6391:
6379:
6375:
6374:Object Pascal
6371:
6367:
6362:
6360:
6348:
6344:
6340:
6335:
6332:
6324:
6322:
6320:
6316:
6308:
6306:
6304:
6300:
6288:
6286:
6285:at run-time.
6284:
6280:
6276:
6272:
6268:
6264:
6256:
6254:
6243:
6236:
6234:
6232:
6022:
6004:
5999:
5992:
5990:
5987:
5979:
5977:
5975:
5967:
5965:
5959:
5954:
5943:
5917:
5913:
5909:
5905:
5897:
5895:
5893:
5884:
5860:
5858:
5852:
5846:
5840:
5835:
5820:
5812:
5810:
5808:
5796:
5791:System.String
5776:
5677:
5654:
5652:
5644:
5640:
5624:
5616:
5614:
5353:
5214:
5212:
5208:
5195:
4907:
4897:
4878:has a member
4869:
4867:
4722:
4602:
4596:
4588:
4582:
4574:
4572:
4568:
4564:
4560:
4556:
4555:computer bugs
4551:
4499:
4489:
4485:
4477:
4473:
4469:
4465:
4463:
4459:
4458:
4441:
4437:
4433:
4429:
4425:
4422:
4417:
4415:
4407:
4403:
4399:
4395:
4387:
4252:
4230:
4226:
4222:
4217:
4214:
4206:
4204:
4198:
4197:
4192:
4180:
4173:
4168:
4166:
4164:
4160:
4155:
4151:
4147:
4143:
4139:
4135:
4132:
4128:
4123:
4121:
4117:
4113:
4109:
4105:
4101:
4097:
4093:
4088:
4082:
4080:
4078:
4074:
4066:
3853:
3851:
3843:
3841:
3823:
3819:
3814:
3552:
3483:
3481:
3477:
3468:
3463:
3461:
3459:
3458:based pointer
3452:Based pointer
3451:
3446:
3443:
3442:
3441:
3439:
3434:
3431:
3423:
3418:
3416:
3414:
3408:
3406:
3402:
3398:
3390:
3388:
3386:
3264:
3261:
3259:
3255:
3251:
3245:
3237:
3235:
3233:
3229:
3225:
3221:
3217:
3211:
3203:
3198:
3193:
3191:
3189:
3185:
3184:null pointers
3181:
3177:
3173:
3170:introduces a
3169:
3164:
3162:
3157:
3153:
3149:
3144:
3142:
3137:
3132:
3130:
3126:
3122:
3118:
3113:
3111:
3107:
3103:
3099:
3093:
3091:
3087:
3078:
3074:
3070:
3062:
3060:
3053:
3049:
3046:
3038:
3036:
3034:
3029:
3027:
3022:bags = 65537;
2967:internal_data
2961:internal_data
2933:
2930:
2891:
2889:
2860:
2859:
2819:
2816:
2814:
2810:
2806:
2798:
2796:
2794:
2789:
2785:
2781:
2776:
2772:
2764:
2716:
2714:
2710:
2706:
2702:
2663:
2661:
2657:
2652:
2646:
2496:
2494:
2099:
2096:
2090:
2085:
2083:
2079:
2075:
2070:
2068:
2064:
2060:
2052:
2020:passByAddress
1927:passByAddress
1878:
1876:
1868:
1866:
1864:
1859:
1850:cell of type
1849:
1797:
1795:
1732:
1730:
1723:C linked list
1722:
1714:
1704:
1703:
1702:
1677:
1667:
1657:
1655:means 0x1000;
1651:
1650:
1649:
1646:
1644:
1632:
1629:
1626:
1623:
1620:
1619:
1615:
1612:
1609:
1606:
1603:
1602:
1598:
1595:
1592:
1589:
1586:
1585:
1581:
1578:
1575:
1572:
1569:
1568:
1564:
1561:
1558:
1555:
1552:
1551:
1547:
1544:
1541:
1538:
1536:
1535:
1532:
1531:
1530:
1528:
1524:
1523:little-endian
1469:
1466:
1455:5*sizeof(int)
1451:sizeof(array)
1447:
1441:
1439:
1303:
1285:
1283:
1281:
1277:
1273:
1269:
1264:
1262:
1261:
1256:
1252:
1248:
1244:
1239:
1237:
1233:
1229:
1225:
1221:
1217:
1213:
1209:
1205:
1201:
1193:
1191:
1171:
1169:
1166:
1165:
1161:
1159:
1156:
1155:
1151:
1148:
1147:
1144:
1118:
1106:
1104:
1101:
1100:
1096:
1094:
1091:
1090:
1086:
1083:
1082:
1079:
1057:
1041:
1039:
1036:
1035:
1031:
1029:
1026:
1025:
1021:
1018:
1017:
977:
966:
936:
865:
862:
859:
857:
853:
826:
820:
811:
794:
793:
792:
769:
767:
759:
757:
755:
754:
748:
743:
739:
737:
733:
729:
724:
722:
718:
713:
709:
705:
701:
696:
694:
690:
686:
682:
678:
674:
670:
666:
658:
656:
653:
649:
644:
641:
637:
633:
628:
624:
619:
617:
613:
609:
605:
599:
597:
593:
589:
585:
581:
577:
573:
569:
568:
563:
562:architectures
559:
551:
549:
547:
543:
539:
535:
531:
525:
523:
519:
515:
510:
508:
504:
500:
496:
491:
488:
484:
480:
478:
474:
473:
467:
463:
459:
454:
452:
451:
446:
445:
440:
436:
432:
427:
425:
421:
413:
411:
409:
405:
404:stack pointer
401:
398:
394:
390:
386:
385:Harold Lawson
381:
377:
369:
367:
365:
361:
357:
353:
349:
345:
341:
337:
333:
325:
321:
317:
313:
310:
309:
303:
301:
297:
294:
291:are used for
290:
286:
282:
278:
274:
269:
267:
263:
259:
258:lookup tables
255:
251:
247:
243:
238:
236:
231:
230:dereferencing
227:
223:
220:
219:memory-mapped
216:
212:
208:
204:
200:
196:
188:
184:
183:address space
180:
176:
172:
168:
163:
158:
156:
152:
146:
144:
131:
128:
120:
109:
106:
102:
99:
95:
92:
88:
85:
81:
78: –
77:
73:
72:Find sources:
66:
62:
56:
55:
50:This article
48:
44:
39:
38:
33:
19:
7471:Intersection
7355:
7118:
7049:. Retrieved
7038:
7032:3.4 Pointers
7026:
7018:
7013:
6993:
6977:
6961:
6947:
6933:
6922:. Retrieved
6920:. isocpp.org
6912:
6901:. Retrieved
6897:
6888:
6877:. Retrieved
6867:
6848:
6829:
6819:Jung, Ralf.
6814:
6804:Jung, Ralf.
6799:
6783:
6775:
6773:
6753:
6748:Plauger, P J
6732:
6729:ISO/IEC 9899
6724:
6717:
6714:ISO/IEC 9899
6709:
6702:ISO/IEC 9899
6697:
6690:ISO/IEC 9899
6685:
6674:. Retrieved
6670:the original
6660:
6652:
6646:. Retrieved
6626:
6618:
6607:the original
6576:
6572:
6562:Donald Knuth
6556:
6525:
6445:Cray pointer
6407:
6393:
6370:Turbo Pascal
6363:
6328:
6312:
6292:
6260:
6240:
6230:
6228:
6131:my_real_list
6101:my_real_list
6002:
5996:
5983:
5971:
5957:
5955:
5944:
5930:or without (
5912:multitasking
5901:
5885:
5883:statements.
5861:
5859:statements.
5836:
5816:
5772:
5717:AllocHGlobal
5655:
5620:
5601:
5351:
5199:
4873:
4853:
4715:
4584:
4577:
4575:
4552:
4508:sizeof(char)
4500:
4467:
4466:
4461:
4455:
4426:
4412:
4401:
4391:
4218:
4210:
4196:access types
4194:
4177:
4141:
4134:machine code
4130:
4129:to simulate
4124:
4119:
4091:
4089:
4086:
4073:linked lists
4070:
4067:Back pointer
3847:
3815:
3800:
3545:
3472:
3457:
3455:
3437:
3435:
3429:
3427:
3409:
3394:
3374:
3262:
3249:
3247:
3230:value in an
3227:
3216:null pointer
3215:
3213:
3210:Null pointer
3204:Null pointer
3180:option types
3175:
3171:
3165:
3145:
3133:
3117:wild pointer
3114:
3109:
3094:
3080:
3076:
3066:
3051:
3044:
3042:
3030:
3026:bit-shifting
3010:sizeof(char)
2998:
2931:
2920:
2877:
2848:
2817:
2802:
2784:program flow
2778:
2698:
2653:
2650:
2506:destroy_item
2488:
2086:
2081:
2077:
2071:
2066:
2062:
2058:
2056:
1872:
1860:
1838:
1791:
1726:
1716:*(array + i)
1696:
1691:*(array + i)
1647:
1640:
1516:
1467:
1463:sizeof(int*)
1442:
1431:
1296:*(array + i)
1289:
1280:lookup table
1265:
1258:
1240:
1231:
1218:(the actual
1215:
1197:
1177:
1167:
1157:
1138:
1112:
1102:
1092:
1077:
1047:
1037:
1027:
967:
956:
918:
863:
860:
849:
819:null pointer
812:
801:
786:
763:
751:
744:
740:
736:linked lists
731:
725:
721:imperatively
697:
662:
645:
620:
600:
565:
555:
526:
521:
517:
511:
506:
502:
498:
494:
492:
489:
485:
481:
476:
471:
461:
457:
455:
448:
442:
434:
430:
428:
417:
403:
399:
396:
378:created the
373:
336:magic cookie
327:
306:
304:
270:
239:
229:
225:
224:. A pointer
198:
192:
178:
174:
170:
166:
154:
151:Donald Knuth
148:
140:
123:
114:
104:
97:
90:
83:
71:
59:Please help
54:verification
51:
7701:Type theory
7696:Type system
7546:Bottom type
7493:Option type
7434:generalized
7320:Long double
7265:Fixed point
7139:|work=
7105:0pointer.de
7080:Over IQ.com
6450:Fat pointer
6366:Free Pascal
6167:sample_data
6110:real_list_t
6089:real_list_t
6056:real_list_t
6038:sample_data
6029:real_list_t
5759:FreeHGlobal
5190:// prints 2
5127:// prints 1
4849:// C++ cast
4559:programmers
4418:defined in
3826:char **argv
3480:linked list
3405:wild branch
3391:Wild branch
3361:'b'
3343:'a'
3232:option type
3226:and to the
3129:wild branch
3100:and recent
3083:raw pointer
3006:sizeof(int)
2888:typecasting
2788:subroutines
2753:'A'
2709:hexadecimal
2660:hexadecimal
2002:passByValue
1888:passByValue
1729:linked list
1527:hexadecimal
1459:sizeof(ptr)
1172:0x00008130
1162:0x00000008
1117:by coding:
1107:0x00008130
1097:0x00000005
1042:0x00000000
1032:0x00000005
753:memory leak
704:car and cdr
558:abstraction
356:type safety
242:performance
7721:Categories
7606:Empty type
7601:Type class
7551:Collection
7508:Refinement
7486:metaobject
7334:signedness
7193:Data types
7051:2018-04-13
6924:2022-11-26
6903:2024-02-15
6879:2018-04-13
6788:WG14 N1124
6676:2018-04-13
6648:2018-04-13
6549:References
6417:references
6275:references
5998:Fortran-90
5958:Enterprise
5834:pointers.
5591:A5_M1CFcvE
5549:FM1CA5_cvE
4448:shared_ptr
4444:unique_ptr
4223:, such as
4161:problems,
4150:JavaScript
4106:character
4071:In doubly
3381:*p2 = 'b';
3150:, support
3052:provenance
2769:See also:
2082:free store
764:The basic
760:C pointers
708:cons-lists
689:references
538:statically
360:validation
340:capability
250:structures
226:references
165:A pointer
117:April 2018
87:newspapers
7681:Subtyping
7676:Interface
7659:metaclass
7611:Unit type
7581:Semaphore
7561:Exception
7466:Inductive
7456:Dependent
7421:Composite
7399:Character
7381:Reference
7278:Minifloat
7234:Bit array
7141:ignored (
7131:cite book
7074:cdecl.org
6603:207630080
6581:CiteSeerX
6537:function
6390:data type
6279:exception
5916:functions
5908:recursion
5850:EXEC CICS
5795:unmanaged
5643:unmanaged
4884:&C::a
4856:void&
4484:void type
4457:reference
4410:uintptr_t
4388:C and C++
4225:FreeBASIC
4191:exception
4138:byte code
3110:reference
3056:uintptr_t
3014:money + 1
2169:make_item
1706:array + i
1659:array + 1
1152:Contents
1087:Contents
1022:Contents
712:recursive
681:FreeBASIC
604:Intel x86
530:data type
514:reference
497:(or just
466:logically
462:aggregate
460:(or just
435:primitive
433:(or just
424:reference
324:interface
312:data type
308:reference
7706:Variable
7596:Top type
7461:Equality
7369:physical
7346:Rational
7341:Interval
7288:bfloat16
7095:Archived
7002:Archived
6564:(1974).
6465:Iterator
6423:See also
6394:declared
6319:Modula-3
6303:Modula-3
6299:Modula-2
6289:Modula-2
6191:allocate
6080:end type
6019:ALLOCATE
5856:EXEC SQL
5341:A5_PFcvE
5323:FPA5_cvE
5175:<<
5157:<<
5112:<<
5091:<<
4896:function
4890:of type
4524:*(a + n)
4476:datatype
4452:weak_ptr
4229:BlitzMax
4120:C arrays
4104:megabyte
3073:pitfalls
3018:bags + 1
2878:because
2094:malloc()
2059:the user
1286:C arrays
1272:raw data
1232:relative
1216:absolute
747:allocate
542:strongly
246:iterable
205:in many
7649:Generic
7625:Related
7541:Boolean
7498:Product
7374:virtual
7364:Address
7356:Pointer
7329:Integer
7260:Decimal
7255:Complex
7243:Numeric
6760:108, 51
6475:Pointee
6398:Pointer
6372:or the
6351:dispose
6267:objects
6116:pointer
6062:pointer
6011:POINTER
5993:Fortran
5881:ADDRESS
5870:POINTER
5832:LINKAGE
5787:Marshal
5765:pointer
5753:Marshal
5741:Runtime
5711:Marshal
5699:Runtime
5687:pointer
5639:managed
5621:In the
5570:M1CFcvE
5528:M1CMS_c
5504:M1CM1Dc
5480:FM1CcvE
5459:M1CA5_c
5402:A5_M1Cc
5221:A5_A5_c
4597:C used
4595:K&R
4581:pointer
4567:Cyclone
4414:typedef
4304:integer
4262:integer
4116:integer
3607:element
3589:element
3574:element
3526:element
3499:element
3490:element
3228:Nothing
2809:integer
1251:aligned
1149:Address
1084:Address
1019:Address
638:of the
567:address
499:pointer
400:pointer
370:History
348:integer
296:methods
293:binding
254:strings
199:pointer
101:scholar
7639:Boxing
7627:topics
7586:Stream
7523:tagged
7481:Object
7404:String
6969:
6860:
6841:
6766:
6639:
6601:
6583:
6392:it is
6334:Pascal
6325:Pascal
6315:Oberon
6309:Oberon
6271:arrays
6224:end do
6149:iostat
6095:target
6015:TARGET
5980:Eiffel
5962:HANDLE
5951:PTRADD
5936:xxx=1;
5799:LPWSTR
5779:System
5735:System
5693:System
5684:IntPtr
5666:unsafe
5658:IntPtr
5627:unsafe
5184:"
5178:"
5166:->*
5133:->*
5121:"
5115:"
4944:return
4911:struct
4904:->*
4892:T C::*
4504:char *
4496:char *
4434:, the
4340:assert
4319:assert
4154:binary
4112:string
3890:return
3838:**argv
3778:insert
3604:struct
3586:struct
3571:struct
3565:insert
3523:struct
3496:struct
3487:struct
3375:Here,
3304:sizeof
3298:malloc
3254:Pascal
3161:Delphi
2793:switch
2773:, and
2747:0x1F00
2691:0x7FFF
2551:return
2512:struct
2492:free()
2475:return
2448:strcpy
2436:return
2376:strlen
2370:malloc
2292:struct
2286:sizeof
2268:memset
2256:return
2229:struct
2223:sizeof
2217:malloc
2193:struct
2160:struct
2106:struct
2038:return
1877:code:
1769:struct
1745:struct
1731:in C.
1669:*array
1446:sizeof
1438:malloc
1236:offset
1208:queues
1168:0x8134
1158:0x8130
1103:0x8134
1093:0x8130
1038:0x8134
1028:0x8130
766:syntax
728:lookup
677:Pascal
627:paging
447:and a
395:, the
322:whose
273:called
252:(e.g.
203:object
201:is an
173:i.e.,
103:
96:
89:
82:
74:
7534:Other
7518:Union
7451:Class
7441:Array
7224:Tryte
7123:(PDF)
6610:(PDF)
6599:S2CID
6569:(PDF)
6539:dlsym
6535:POSIX
6531:void*
6517:Notes
6251:->
6212:=>
6176:ioerr
6155:ioerr
6128:=>
6071:=>
6026:type
6007:=>
5924:BASED
5864:USAGE
5819:COBOL
5813:COBOL
5803:void*
5647:fixed
5631:using
5441:PM1Cc
5423:M1CPc
5366:class
5357:class
5305:PFcvE
5287:FPcvE
5269:PA5_c
5236:A5_Pc
5211:clang
5043:&
5037:const
5001:&
4977:&
4938:const
4882:then
4860:void*
4837:*>
4753:&
4718:void*
4633:&
4599:char*
4586:void*
4583:, or
4528:a + n
4492:void*
4432:C++11
4237:void*
4221:BASIC
4213:BASIC
4207:BASIC
4140:) of
4096:array
3989:&
3834:*argv
3784:&
3739:->
3727:break
3721:value
3718:->
3703:<=
3700:value
3697:->
3676:->
3661:&
3514:value
3104:like
3002:money
2923:money
2913:money
2880:money
2870:money
2850:money
2829:money
2713:ASCII
2608:->
2596:->
2569:->
2457:->
2406:->
2361:->
2340:->
2322:->
2304:->
2175:const
2142:float
2067:stack
2026:&
1846:is a
1710:array
1699:array
1687:array
1679:array
1673:array
1653:array
1621:1010
1604:100C
1587:1008
1570:1004
1553:1000
1519:array
1476:array
1434:array
1397:array
1361:array
1331:array
1310:array
1300:array
1292:array
1276:index
1268:ASCII
1230:) or
1222:or a
1212:stack
1204:lists
1202:like
1067:&
908:&
717:array
640:80286
612:AMD64
592:array
578:or a
572:index
536:; in
472:array
352:crash
283:. In
248:data
108:JSTOR
94:books
7654:Kind
7616:Void
7476:List
7391:Text
7229:Word
7219:Trit
7214:Byte
7154:link
7150:link
7143:help
6967:ISBN
6764:ISBN
6637:ISBN
6410:Perl
6408:The
6404:Perl
6355:free
6339:PL/I
6269:and
6263:Java
6257:Java
6247:make
6221:next
6203:next
6188:exit
6137:read
6104:type
6083:type
6074:null
6068:next
6050:type
6032:real
5984:The
5972:The
5956:IBM
5904:PL/I
5902:The
5898:PL/I
5876:and
5844:CALL
5817:The
5781:and
5773:The
5662:int*
5633:the
5606:and
5602:The
5594:)();
5579:char
5558:char
5552:());
5537:char
5513:char
5489:char
5471:char
5450:char
5438:::**
5432:char
5411:char
5393:char
5384:M1Cc
5375:char
5344:)();
5332:char
5326:());
5314:char
5308:)();
5296:char
5281:char
5260:char
5245:char
5230:char
5218:char
5163:ptrS
5154:cout
5130:ptrS
5088:cout
4971:ptrS
4902:and
4864:void
4831:<
4741:void
4621:void
4591:void
4579:void
4576:The
4563:Java
4480:void
4450:and
4416:name
4402:null
4396:and
4187:null
4183:null
4146:Java
3917:void
3911:main
3830:argv
3818:argv
3811:head
3807:head
3803:item
3793:item
3787:head
3766:item
3742:next
3736:item
3694:item
3679:next
3649:NULL
3634:head
3595:item
3580:head
3562:void
3548:head
3538:NULL
3532:head
3505:next
3401:jump
3319:char
3310:char
3286:char
3277:void
3271:func
3220:list
3182:for
3166:The
3106:Java
3048:LLVM
2937:char
2927:bags
2904:char
2895:bags
2884:bags
2882:and
2864:bags
2854:bags
2841:bags
2835:char
2805:type
2732:void
2723:void
2701:BIOS
2635:item
2629:free
2617:NULL
2611:name
2605:item
2599:name
2593:item
2587:free
2578:NULL
2572:name
2566:item
2545:NULL
2539:item
2521:item
2515:Item
2503:void
2478:item
2466:name
2460:name
2454:item
2439:NULL
2430:item
2424:free
2415:NULL
2409:name
2403:item
2382:name
2364:name
2358:item
2343:cost
2337:item
2331:NULL
2325:name
2319:item
2301:item
2295:Item
2274:item
2259:NULL
2250:NULL
2244:item
2232:Item
2211:item
2202:item
2196:Item
2184:name
2178:char
2163:Item
2145:cost
2133:name
2127:char
2109:Item
2078:heap
2063:heap
1975:void
1969:main
1924:void
1885:void
1848:cons
1828:Link
1819:Cons
1804:Link
1801:data
1778:next
1772:link
1760:data
1754:void
1748:link
1234:(an
1008:NULL
896:NULL
842:NULL
823:NULL
700:cons
665:PL/I
659:Uses
580:word
576:byte
546:type
540:(or
477:word
450:word
444:byte
397:word
389:IEEE
362:and
266:tree
264:and
197:, a
185:and
80:news
7513:Set
7209:Bit
6633:204
6591:doi
6386:Dec
6384:or
6382:Inc
6376:in
6341:or
6331:ISO
6295:VAR
6044:100
5942:).
5878:SET
5874:SET
5853:or
5801:or
5641:or
5588:::*
5573:)()
5567:::*
5546:::*
5525:::*
5519:::*
5501:::*
5495:::*
5483:();
5477:::*
5420:::*
5399:::*
5381:::*
5290:();
5251:PPc
5209:or
5207:g++
5172:)()
5148:std
5136:ptr
5109:)()
5082:std
5070:ptr
5034:)()
5028:::*
5019:int
4995:ptr
4992:::*
4986:int
4962:{};
4929:int
4920:int
4880:T a
4834:int
4816:int
4798:int
4783:int
4762:int
4726:int
4696:int
4681:int
4663:int
4642:int
4606:int
4542:or
4488:gcc
4460:or
4428:C++
4406:C99
4398:C++
4392:In
4334:257
4307:ptr
4298:dim
4283:ptr
4280:any
4274:dim
4271:257
4256:dim
4249:ANY
4245:ANY
4241:ANY
4233:ANY
4227:or
4179:Ada
4174:Ada
4142:any
4131:any
4075:or
4040:sum
3992:sum
3974:int
3968:int
3953:int
3926:int
3908:int
3875:int
3866:int
3860:sum
3857:int
3622:for
3511:int
3428:An
3313:));
3268:int
3256:or
3148:C++
3127:or
3045:and
2976:int
2955:int
2890:it
2858:GCC
2823:int
2741:VID
2726:foo
2705:CGA
2682:int
2667:int
2349:0.0
2298:));
2235:));
2115:int
2080:or
1984:int
1966:int
1933:int
1894:int
1840:Nil
1813:Nil
1663:int
1517:If
1473:int
1340:ptr
1325:ptr
1319:int
1307:int
1247:KiB
1226:in
1188:ptr
1141:ptr
1125:ptr
1115:ptr
1061:ptr
1054:ptr
1052:to
1002:ptr
996:int
981:int
974:ptr
959:ptr
943:ptr
933:ptr
925:ptr
923:to
902:ptr
890:ptr
884:int
869:int
836:ptr
830:int
815:ptr
810:."
808:int
804:ptr
797:int
789:ptr
779:ptr
773:int
673:C++
632:PAE
625:or
598:).
586:or
532:in
469:an
418:In
338:or
193:In
63:by
7723::
7135::
7133:}}
7129:{{
6984:,
6896:.
6790:,
6772:.
6762:.
6739:^
6651:.
6635:.
6597:.
6589:.
6575:.
6571:.
6368:,
6242:Go
6237:Go
6179:/=
6170:if
6134:do
6119:::
6113:),
6098:::
6092:),
6077:()
6065:::
6059:),
6035:::
6005:,
5964:.
5910:,
5894:.
5867:IS
5768:);
5726:);
5723:16
5617:C#
5613:.
5604:()
5248:**
5213:.
5181:\n
5169:fp
5151:::
5118:\n
5106:fp
5097:s1
5085:::
5061:s1
5049:::
5031:fp
5007:::
4980:s1
4959:s1
4953:};
4950:;}
4935:()
4900:.*
4866:.
4846:);
4843:p1
4822:p4
4807:p1
4789:p3
4774:p1
4768:p2
4747:p1
4705:p1
4675:p2
4654:p1
4648:p2
4627:p1
4550:.
4498:.
4464:.
4446:,
4301:as
4277:as
4259:as
4203:.
4148:/
4092:do
4055:);
4028:);
4016:)(
4013:fp
3983:fp
3977:);
3965:)(
3962:fp
3899:n2
3893:n1
3878:n2
3869:n1
3796:);
3688:if
3646:!=
3610:**
3577:**
3520:};
3456:A
3387:.
3377:p2
3355:p2
3337:p1
3325:p2
3292:p1
3248:A
3234:.
3214:A
3190:.
3174:,
3123:,
2929:.
2638:);
2602:);
2575:!=
2560:if
2542:==
2533:if
2469:);
2433:);
2412:==
2397:if
2394:);
2313:-1
2307:id
2247:==
2238:if
2154:};
2118:id
2032:);
2011:);
1957:14
1912:12
1858:.
1796::
1787:};
1633:0
1616:0
1599:0
1582:0
1565:0
1548:3
1512:};
1282:.
1206:,
1190:.
1056::
858:.
825::
723:.
679:,
675:,
671:,
667:,
618:.
493:A
456:A
429:A
426:.
410:.
302:.
287:,
260:,
256:,
237:.
171:b,
153:,
7185:e
7178:t
7171:v
7158:.
7156:)
7145:)
7125:.
7054:.
6955:.
6941:.
6927:.
6906:.
6882:.
6823:.
6808:.
6679:.
6593::
6577:6
6541:.
6359:C
6343:C
6218:%
6206:)
6200:%
6194:(
6185:)
6182:0
6173:(
6164:%
6158:)
6152:=
6146:,
6143:1
6140:(
6107:(
6086:(
6053:(
6047:)
6041:(
5968:D
5762:(
5756:.
5750:.
5744:.
5738:.
5720:(
5714:.
5708:.
5702:.
5696:.
5690:=
5611:*
5585:C
5582:(
5564:C
5561:(
5543:C
5540:(
5531:;
5522:C
5516:C
5507:;
5498:C
5492:D
5474:C
5465:;
5462:)
5456:*
5453:(
5444:;
5435:C
5426:;
5417:C
5414:*
5405:;
5396:C
5387:;
5378:C
5372:;
5369:D
5363:;
5360:C
5338:*
5335:(
5320:*
5317:(
5302:*
5299:(
5284:*
5275:;
5272:)
5266:*
5263:(
5254:;
5239:;
5233:*
5224:;
5187:;
5160:(
5145:;
5142:2
5139:=
5124:;
5103:*
5100:.
5094:(
5079:;
5076:1
5073:=
5067:*
5064:.
5055:;
5052:f
5046:S
5040:=
5025:S
5022:(
5013:;
5010:a
5004:S
4998:=
4989:S
4983:;
4974:=
4968:*
4965:S
4956:S
4947:a
4941:{
4932:f
4926:;
4923:a
4917:{
4914:S
4888:a
4876:C
4840:(
4825:=
4819:*
4810:;
4804:)
4801:*
4795:(
4792:=
4786:*
4777:;
4771:=
4765:*
4759:;
4756:x
4750:=
4744:*
4738:;
4735:4
4732:=
4729:x
4708:;
4702:)
4699:*
4693:(
4690:*
4687:=
4684:b
4678:;
4672:*
4669:=
4666:a
4657:;
4651:=
4645:*
4639:;
4636:x
4630:=
4624:*
4618:;
4615:4
4612:=
4609:x
4548:a
4544:3
4540:a
4536:a
4532:n
4520:a
4516:n
4512:a
4442:(
4394:C
4382:)
4379:)
4376:1
4373:+
4370:f
4367:@
4364:(
4361:=
4358:)
4355:4
4352:+
4349:g
4346:(
4343:(
4337:)
4331:=
4328:i
4325:*
4322:(
4316:g
4313:=
4310:i
4295:f
4292:@
4289:=
4286:g
4268:=
4265:f
4061:}
4052:b
4049:,
4046:a
4043:(
4037:=
4034:y
4025:b
4022:,
4019:a
4010:*
4007:(
4004:=
4001:x
3995:;
3986:=
3971:,
3959:*
3956:(
3950:;
3947:y
3944:,
3941:x
3938:,
3935:b
3932:,
3929:a
3923:{
3920:)
3914:(
3905:}
3902:;
3896:+
3884:{
3881:)
3872:,
3863:(
3790:,
3781:(
3772:}
3769:;
3763:=
3760:p
3757:*
3754:;
3751:p
3748:*
3745:=
3733:}
3730:;
3724:)
3715:)
3712:p
3709:*
3706:(
3691:(
3685:{
3682:)
3673:)
3670:p
3667:*
3664:(
3658:=
3655:p
3652:;
3643:p
3640:*
3637:;
3631:=
3628:p
3625:(
3616:;
3613:p
3601:{
3598:)
3592:*
3583:,
3568:(
3541:;
3535:=
3529:*
3517:;
3508:;
3502:*
3493:{
3370:}
3364:;
3358:=
3352:*
3346:;
3340:=
3334:*
3328:;
3322:*
3307:(
3301:(
3295:=
3289:*
3283:{
3280:)
3274:(
3086:s
2988:;
2982:)
2979:*
2973:(
2970:=
2964:;
2958:*
2952:;
2946:=
2940:*
2916:;
2910:)
2907:*
2901:(
2898:=
2873:;
2867:=
2844:;
2838:*
2832:;
2826:*
2759:}
2756:;
2750:|
2744:=
2738:{
2735:)
2729:(
2694:;
2688:)
2685:*
2679:(
2676:=
2670:*
2641:}
2632:(
2623:}
2620:;
2614:=
2590:(
2584:{
2581:)
2563:(
2554:;
2548:)
2536:(
2527:{
2524:)
2518:*
2509:(
2484:}
2481:;
2463:,
2451:(
2445:}
2442:;
2427:(
2421:{
2418:)
2400:(
2391:1
2388:+
2385:)
2379:(
2373:(
2367:=
2352:;
2346:=
2334:;
2328:=
2316:;
2310:=
2289:(
2283:,
2280:0
2277:,
2271:(
2262:;
2253:)
2241:(
2226:(
2220:(
2214:=
2205:;
2199:*
2190:{
2187:)
2181:*
2172:(
2166:*
2148:;
2136:;
2130:*
2121:;
2112:{
2047:}
2044:;
2041:0
2029:x
2023:(
2008:x
2005:(
1996:;
1993:3
1990:=
1987:x
1981:{
1978:)
1972:(
1963:}
1960:;
1954:=
1951:m
1948:*
1945:{
1942:)
1939:m
1936:*
1930:(
1918:}
1915:;
1909:=
1906:n
1903:{
1900:)
1897:n
1891:(
1875:C
1856:a
1852:a
1834:)
1831:a
1825:(
1822:a
1816:|
1810:=
1807:a
1781:;
1775:*
1763:;
1757:*
1751:{
1693:.
1683:i
1630:0
1627:0
1624:5
1613:0
1610:0
1607:1
1596:0
1593:0
1590:3
1579:0
1576:0
1573:4
1562:0
1559:0
1556:2
1545:2
1542:1
1539:0
1509:5
1506:,
1503:1
1500:,
1497:3
1494:,
1491:4
1488:,
1485:2
1482:{
1479:=
1424:;
1421:4
1418:=
1415:2
1409:;
1406:2
1403:=
1400:)
1394:+
1391:1
1388:(
1385:*
1379:;
1376:2
1373:=
1370:)
1367:1
1364:+
1358:(
1355:*
1349:;
1346:1
1343:=
1334:;
1328:=
1322:*
1313:;
1184:a
1180:a
1134:;
1131:8
1128:=
1122:*
1073:;
1070:a
1064:=
1050:a
1011:;
1005:=
999:*
993:;
990:5
987:=
984:a
970:a
963:a
952:;
949:8
946:=
940:*
929:a
921:a
914:;
911:a
905:=
899:;
893:=
887:*
881:;
878:5
875:=
872:a
845:;
839:=
833:*
782:;
776:*
669:C
179:b
175:a
167:a
130:)
124:(
119:)
115:(
105:·
98:·
91:·
84:·
57:.
34:.
20:)
Text is available under the Creative Commons Attribution-ShareAlike License. Additional terms may apply.