In computer science, a pointer is a programming language data type whose value refers directly to (or "points to") another value stored elsewhere in the computer memory using its address. Obtaining the value to which a pointer refers is called dereferencing the pointer. A pointer is a simple implementation of the general reference data type (although it is quite different from the facility referred to as a reference in C++). Pointers to data improve performance for repetitive operations such as traversing string and tree structures, and pointers to functions are used for binding methods in Object-oriented programming and run-time linking to dynamic link libraries (DLLs).

While "pointer" has been used to refer to references in general, it more properly applies to data structures whose interface explicitly allows the pointer to be manipulated as a memory address. Because pointers allow largely unprotected access to memory addresses, there are risks associated with using them. For general information about references, see reference (computer science).

Source Site:
http://en.wikipedia.org /wiki/Pointer_(computing)

Answered by Reeta K , an ibibo Master, at 4:32 PM on August 27, 2008

hello pankaj ....Out of all the introductory concepts in computer science, pointers can be the hardest to learn as well as one of the most rewarding. Pointers open up a world of possibilities allowing programmers to do things that would otherwise be extremely difficult if not impossible. This tutorial sets about to introduce pointers painlessly and familiarize you with them and the basic concepts surrounding them so that you can understand and begin to use them quickly. Pointers are nothing more than variables that store memory addresses and can be used to access the memory at those addresses. Various operators such as the *, the &, and the [], enable us to use pointers to do these things.
and In computer science an array is a data structure consisting of a group of elements that are accessed by indexing. In most programming languages each element has the same data type and the array occupies a contiguous area of storage.

Most programming languages have a built-in array data type, although what is called an array in the language documentation is sometimes really an associative array. Conversely, the contiguous storage kind of array discussed here may alternatively be called a vector, list,[1] or table.[2]

Some programming languages support array programming (e.g., APL, newer versions of Fortran) which generalises operations and functions to work transparently over arrays as they do with scalars, instead of requiring looping over array members.

Multi-dimensional arrays are accessed using more than one index: one for each dimension.

Arrays can be classified as fixed-sized arrays (sometimes known as static arrays) whose size cannot change once their storage has been allocated, or dynamic arrays, which can be resized.

Answered by raj u , an ibibo Master, at 12:20 PM on August 22, 2008

In computer science, a pointer is a programming language data type whose value refers directly to (or “points to”) another value stored elsewhere in the computer memory using its address. Obtaining the value to which a pointer refers is called dereferencing the pointer. A pointer is a simple implementation of the general reference data type (although it is quite different from the facility referred to as a [[reference (C++)|reference]] in C++).

Pointers are so commonly used as references that sometimes people use the word “pointer” to refer to references in general; however, more properly it only applies to data structures whose interface explicitly allows it to be manipulated as a memory address. If you are seeking general information on a small piece of data used to find an object
Array - An ordered arrangement of data elements. A vector is a one dimensional array, a matrix is a two-dimensional array. Most programming languages have the ability to store and manipulate arrays in one or more dimensions. Multi-dimensional arrays are used extensively in scientific simulation and mathematical processing; however, an array can be as simple as a pricing table held in memory for instant access by an order entry program.

Answered by Nishu's , an ibibo Master, at 9:40 AM on August 22, 2008

Pointer are a fundamental part of C. If you cannot use pointers properly then you have basically lost all the power and flexibility that C allows. The secret to C is in its use of pointers.

C uses pointers a lot. Why?:

* It is the only way to express some computations.
* It produces compact and efficient code.
* It provides a very powerful tool.

C uses pointers explicitly with:

* Arrays,
* Structures,
* Functions.

A pointer is a variable which contains the address in memory of another variable. We can have a pointer to any variable type.

The unary or monadic operator & gives the ``address of a variable''.

The indirection or dereference operator * gives the ``contents of an object pointed to by a pointer''.

To declare a pointer to a variable do:

int *pointer;

An array is a series of elements of the same type placed in contiguous memory locations that can be individually referenced by adding an index to a unique identifier.

That means that, for example, we can store 5 values of type int in an array without having to declare 5 different variables, each one with a different identifier. Instead of that, using an array we can store 5 different values of the same type, int for example, with a unique identifier.

Like a regular variable, an array must be declared before it is used. A typical declaration for an array in C++ is:

type name [elements];

where type is a valid type (like int, float...), name is a valid identifier and the elements field (which is always enclosed in square brackets []), specifies how many of these elements the array has to contain.

When declaring a regular array of local scope (within a function, for example), if we do not specify otherwise, its elements will not be initialized to any value by default, so their content will be undetermined until we store some value in them. The elements of global and static arrays, on the other hand, are automatically initialized with their default values, which for all fundamental types this means they are filled with zeros.

Answered by Nagendra , an ibibo Master, at 8:51 AM on August 22, 2008

well;
C is a language of "expressions", for it offers the facility to explore, the practicability to implement, and the depth of low-levelness. Pointer is one such concept that can offer an approach to more compact and efficient code.

A pointer, in its simplest form, is an object capable of holding an lvalue of a compatible object. In C, the address-of operator (&) gives the address of an object. The following example shows it how:

int k;
int *p; /* p is pointer to an int */
p = &k; /* p points to k */
*p = 3; /* k is now 3 */

The second statement declares p as a pointer to an integer. The address-of operator gives the address of k which is stored in the pointer p; p is now said to point to k. The asterisk(*) in the expression, *p, is called a dereference operator which retrieves the value pointed by the pointer. Now, *p can occur in any context or expression where k could.

Pictorially,

addr ess: 0x1000 0x2000
__________ k __________
| 3 | <---- | 0x1000 |
---------- | ----------
| | p
|______________|
points to

Since, both, p and k are objects, an implementation-defined memory storage unit is allocated to each as shown. The objects k and p reside at the addresses 0x1000 and 0x2000, respectively; and, p is shown pointing to k.

An array is a nonempty set of sequentially indexed elements having the same type of data. Each element of an array has a unique identifying index number. Changes made to one element of an array do not affect the other elements.

In C, the declaration

int a[10];

defines an array of size 10, each of which is an integer object. These objects -- named a[0], a[1], ..., a[9] -- appear contiguously in the storage area, that is, there is no padding between the array members.

An array type is called as an aggregate type since it is considered to be derived from it's element type. If the element type is T, then the array type is called as "array of T". For example, in the above declaration element type of a is integer, so the array a is called as "array of integers".

An array must not be declared/defined with the `register' storage class specifier; doing so is an undefined-behavior.

Answered by Kishore , an ibibo Master, at 8:05 AM on August 22, 2008

Pointers and Arrays

Up to now, we've carefully been avoiding discussing arrays in the context of pointers. The interaction of pointers and arrays can be confusing but here are two fundamental statements about it:

* A variable declared as an array of some type acts as a pointer to that type. When used by itself, it points to the first element of the array.
* A pointer can be indexed like an array name.

The first case often is seen to occur when an array is passed as an argument to a function. The function declares the parameter as a pointer, but the actual argument may be the name of an array. The second case often occurs when accessing dynamically allocated memory. Let's look at examples of each. In the following code, the call to calloc() effectively allocates an array of struct MyStruct items.

float KrazyFunction( struct MyStruct *parm1, int p1size, int bb )
{
int ix;
for (ix=0; ix<p1size; ix++) {
if (parm1[ix].m_aNumber == bb )
return parm1[ix].num2;
}
return 0.0f;
}
.
.
struct MyStruct myArray[4];
#define MY_ARRAY_SIZE (sizeof(myArray)/sizeof(*myArr ay))
float v3;
struct MyStruct *secondArray;
int someSize;
int ix;
.
/* initialization of myArray ... */
.
v3 = KrazyFunction( myArray, MY_ARRAY_SIZE, 4 );
.
secondArray = calloc( someSize, sizeof *secondArray);
for (ix=0; ix<someSize; ix++) {
secondArray[i].m_aNumber = ix *2;
secondArray[i].num2 = .304 * ix * ix;
}

Pointers and array names can pretty much be used interchangably. There are exceptions. You cannot assign a new pointer value to an array name. The array name will always point to the first element of the array. In the function KrazyFunction above, you could however assign a new value to parm1, as it is just a pointer to the first element of myArray. It is also valid for a function to return a pointer to one of the array elements from an array passed as an argument to a function. A function should never return a pointer to a local variable, even though the compiler will probably not complain.

When declaring parameters to functions, declaring an array variable without a size is equivalent to declaring a pointer. Often this is done to emphasize the fact that the pointer variable will be used in a manner equivalent to an array.

And for more information visit the source site:
http://en.wikibooks.org /wiki/C_Programming/Pointers_a nd_arrays

Answered by Dinesh , an ibibo Master, at 7:32 AM on August 22, 2008

"Pointer" redirects here. For other uses, see Pointer (disambiguation).

In computer science, a pointer is a programming language data type whose value refers directly to (or "points to") another value stored elsewhere in the computer memory using its address. Obtaining the value to which a pointer refers is called dereferencing the pointer. A pointer is a simple implementation of the general reference data type (although it is quite different from the facility referred to as a reference in C++). Pointers to data improve performance for repetitive operations such as traversing string and tree structures, and pointers to functions are used for binding methods in Object-oriented programming and run-time linking to dynamic link libraries (DLLs).

While "pointer" has been used to refer to references in general, it more properly applies to data structures whose interface explicitly allows the pointer to be manipulated as a memory address. Because pointers allow largely unprotected access to memory addresses, there are risks associated with using them. For general information about references, see reference (computer science).

Source Site:
http://en.wikipedia.org /wiki/Pointer_(computing)

Answered by Deepak , an ibibo Master, at 7:31 AM on August 22, 2008

hello pankaj...

Pointer is the concept in programming language by which you can points to perrticular objects and using this you can alocate memory at runtime.

Arrays are the collection of continous memory location. Arrays are used for static implementation of memory allocation in a programming language.

Answered by Saq , an ibibo Master, at 10:41 PM on August 21, 2008

A pointer is a variable in a program is something with a name, the value of which can vary. The way the compiler and linker handles this is that it assigns a specific block of memory within the computer to hold the value of that variable. The size of that block depends on the range over which the variable is allowed to vary.

For example, on 32 bit PC's the size of an integer variable is 4 bytes. On older 16 bit PCs integers were 2 bytes. In C the size of a variable type such as an integer need not be the same on all types of machines. Further more there is more than one type of integer variable in C. We have integers, long integers and short integers which you can read up on in any basic text on C. This document assumes the use of a 32 bit system with 4 byte integers.

If you want to know the size of the various types of integers on your system, running the following code will give you that information.

#include <stdio.h>

int main()
{
printf("size of a short is %d\n", sizeof(short));
printf("size of a int is %d\n", sizeof(int));
printf("size of a long is %d\n", sizeof(long));
}


An array is a variable that holds multiple values of the same type.

For example :

#include <stdio.h>

void main()
{
int numbers[10]; /* Array storing 10 values */
int count = 10; /* Number of values to be read */
long sum = 0L; /* Sum of the numbers */
float average = 0.0f; /* Average of the numbers */
int i = 0; /* Loop counter */

printf("\nEnter the 10 numbers:\n");

/* Read the ten numbers to be averaged */
for(i = 0; i < count; i ++)
{
printf("%2d : ",i+1);
scanf("%d", &numbers[i]); /* Read a number */
sum += numbers[i]; /* Add it to sum */
}

average = (float)sum/count; /* Calculate the average */

printf("Average of the ten numbers entered is: %f\n", average);
}

Answered by Ashish Yadav , an ibibo Wizard, at 7:32 PM on August 21, 2008

Array ----------->>>
An Array is a collection of variables having similar data types and stored in adjacent memory locations.An ordinary variable is capable of storing only one value at a time.

However,there are situations where we would be wanting to store more than one value at a time in a single variable.
At that time we use Array and construct one variable (called as subscripted variable) capable of storing or holding multiple values.

Before using an array its type and size must be declared
For example :
int arr[90];

An array variable is defined using index or subscript which specifies the size of the variable ie, how many values it can store.

Pointer ia a variable but not an ordinary one ,it stores the address of other variable.
There are two operators which are mainly used in pointers one is the '&' known as "address of" operator. It returns the address of the variable
Suppose for example :

int i;
int *j;
j=&i;

Here j stores the address of variable "i".

The second operator is the '*' called "value at address " operator.It gives the value stored at a particular address. In the above example "j" is the pointer variable.

Answered by Prakash Kuma , an ibibo Advisor, at 7:23 PM on August 21, 2008