pointer to array

Question

I'm wondering, can you make a pointer to a group of variables in an array? like this

array[20]{'a','b','c',...}
pointer = array[6 through 10];

so then you could say...

*pointer[0] == array[6];

and

*pointer[5] == array[10];

and the length of *pointer

5 == sizeof(*pointer) \ sizeof(type);

OK

Let me explain what I'm trying to accomplish, maybe that will clear me up a bit. I want to read a full file into a buffer, but I want to do it piece by piece. passing a small array into read() and then looping it into the larger array defeats the purpose. I was hoping that I could directly 'point' to an area in the buffer I want to fill, and pass that to the read() function.

I DO NOT want to use streams or anything that buffers behind my back

that would be counterproductive as I'm trying read the whole file into memory at once. As fast as possible.

I need speed!!!

Answer 1

pointer = &array[6]. pointer[0] will now reference the same value as array[6]. It's not directly possible to extract a reference to a slice of an array and keep sizeof semantics for it. You can emulate it with something like this:

template <class T>
class Slice {
public:
 Slice(T* elements, int begin, int end) : m_elements(elements + begin), m_size(end - begin) {}
 T& operator[] (int index) {return m_elements[index];}
 int size() const {return m_size;}
private:
 T* m_elements;
 int m_size; 
};

int values[10];
Slice<int> slice(values, 5, 10);
values[5] = 3;
assert(slice[0] == values[5]);
assert(slice.size() == 5);

Answer 2

Sure enough you can.

int a[4] = {1,2,3,4};
int *b = &a[2];
cout << b[0] << "-" << b[1] << endl;

The output will be 3-4.

Answer 3

Yes, if you use the addresses correctly:

int* ptr = new int[10];
int* ptrSub = &ptr[5];

Answer 4

You can have a pointer pointing to any element of a C array. Since C arrays do not "know" their length, the idea of a "range" of a C array cannot be expressed directly. As you have to store the length of the array itself, so you have to store the length of the range the pointer points to.

Answer 5

Pointers only 'point' to the first item in any structure or variable. They are only an address. You could imply a range by making them a pointer to a specific type which identifies a range.

Answer 6

In the below example I've declared a static array of 10x ints. I've created 2 pointers to it's elements - thus defining a range. What I did next was : I declared a pointer in the for loop starting with the pointer p1 which went through every item in the array until it reached pointer p2 - printing item's value.

Is that what you were looking for?

#include <iostream>
using namespace std;

int main()
{ 
    int a[10] = { 0, 4, 5, 7, 4, 3, 1, 6, 2, 9 };

    int *p1 = &a[3];
    int *p2 = &a[7];

    for(int *p = p1; p != p2; ++p)
    {
     cout << *p << endl;
    }

    return 0;
}

Answer 7

a pointer points to a single memory location, so while, as others have said you can get a pointer to point to a location in the middle of an array

char *p = array + 6;

you need to express the allowed range some other way i.e. by passing a max length. or a second pointer

its probably worth pointing out that

array[i]

is identical to

*(array + i)

Answer 8

If I read your question you want to address a range of elements in the original array, a slice so to say.

In C++ you can do that easily - provided you implement your own arrayclass (keeping a pointer + number elements). Then you can define memberfunctions which will give you back a slice: a pointer into the original array and a number of elements such that you will not address outside the original array.

In Plain-Old-C you cannot have to sized arrays sharing storage and a pointer is unbounded by definition: it just points at a single element. You cannot let the C-code "re-interpret" a sized array since the name of the array (the symbol) is the address of the storage, which you cannot modify.

What you want is this:

int  array1[10];
int  array2[3];

// reference 3 elements from array1, starting at element 5 in array1
array2 = array1[5];

but that is not allowed. The name "array2" is translated by the compiler into a fixed address which you cannot redefine at runtime - that's why there are pointers: of those you can change whatever they point to at will at runtime.

Answer 9

Despite what everyone has said, this is possible, with one small caveat - unless you have a C99 compiler, you have to know the size of the "slice" that you want at compile time.

To declare and use the pointer correctly, you also have to know that the subscript operator [] binds before the * dereference operator, so parantheses are needed.

Behold:

int array[20] = {'a','b','c','d','e','f','g','h','i','j','k','l'};
int (*pointer)[10 - 6 + 1] = (int (*)[10 - 6 + 1])&array[6];    /* = array[6 through 10] */

printf("(*pointer)[0] = %c\n", (*pointer)[0]);
printf("(*pointer)[4] = %c\n", (*pointer)[4]);
printf("sizeof *pointer / sizeof **pointer = %lu\n", (unsigned long)(sizeof *pointer / sizeof **pointer));

Addendum:

For the answer to your actual problem that you've put in, that's a lot easier. Just use a pointer that is set to an offset from the buffer array, eg:

unsigned char buffer[102400];
unsigned char *ptr;

/* ... */
ptr = buffer + 500;
read(fd, ptr, 1024); /* Try and read up to 1024 bytes at position buffer[500] */