指向数组的指针

Question

我想知道，你能指出一个数组中的一组变量吗？ 像这样

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

所以你可以说......

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

和

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

和*指针的长度

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

好

让我解释一下我想要完成的事情，也许这会让我有所了解。 我想将一个完整的文件读入一个缓冲区，但我想要一块一块地完成。 将一个小数组传递给read（）然后将其循环到更大的数组中就会失败。 我希望我可以直接“指向”我要填充的缓冲区中的一个区域，并将其传递给read（）函数。

我不想使用流或在我背后缓冲的任何东西

这会适得其反，因为我正在尝试将整个文件一次性读入内存。 尽可能快地。

我需要速度!!!

Answer 1

尽管每个人都说过，这是可能的，只有一个小小的警告 - 除非你有一个C99编译器，你必须知道编译时你想要的“切片”的大小。

要正确声明和使用指针，您还必须知道下标operator []在* dereference运算符之前绑定，因此需要parantheses。

看吧：

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));

附录：

为了解决您所提出的实际问题，这会更容易。 只需使用一个设置为缓冲区数组偏移量的指针，例如：

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] */

Answer 2

果然你可以。

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

输出将是3-4。

Answer 3

在下面的例子中，我声明了一个10x整数的静态数组。 我已经创建了2个指向它的元素 - 因此定义了一个范围。 我接下来做的是：我在for循环中声明一个指针，从指针p1开始，遍历数组中的每个项目，直到它到达指针p2 - 打印项目的值。

那是你在找什么？

#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 4

正如其他人所说，你可以很容易地完成第一部分。 只做pointer = array + 6 。 但pointer是什么？ 它不能声明为：

char pointer[5];

或类似的。 它必须是一个指针 ：

char *pointer = array + 6;

这是因为您无法将数组分配给其他名称（数组不是可修改的l值）。 说：没有意义：

char a[10];
char b[10];
b = a;

现在，在C中，指针的大小就是指针的大小 - 因为指针没有指向给定类型的“单位数”的概念。 另一方面，数组确切地知道它们具有多少元素，并且可以通过适当使用sizeof运算符来获得该大小。

因此，示例中的sizeof array将为10（如果它有10个元素），而sizeof pointer将是char指针占用的字节数。 因此，你在问题的第二部分提出的问题在C中是不可能的 。 在C ++中，您可以访问应该允许您执行所需操作的数据类型。

编辑 ：要以块的形式读取文件：

假设您有一个很大的缓冲区，您确信可以将整个文件读入：

unsigned char bigbuf[1UL << 24]; /* or whatever you want */
unsigned char *ptr = bigbuf;
size_t chunk = BUFSIZ;
FILE *fp = fopen("foo.txt", "rb"); /* no error checking */
size_t nread;
size_t total = 0;
while ((nread = fread(ptr, 1, chunk, fp)) > 0) {
    ptr += nread;
    total += nread;
    if (total + chunk > sizeof bigbuf) {
        /* oops, not enough space */
    }
}
if (ferror(fp)) {
    /* read error */
} else {
    /* bigbuf now has data, total has the number of bytes */
}

对于无缓冲的I / O，请查看setvbuf() 。 但是测试缓冲和无缓冲输入以查看哪一个更快。 也测试不同的读数。

现在放在一边，我以前放过，我想我还是会留在这里：

回答这个问题之后，更有意思的是以另一种方式做到这一点 ，即给出：

T a[10];

对于任何类型T ，你可以声明pointer ，使得：

pointer[1] == a[0]
pointer[2] == a[1]
...
pointer[11] == a[10]

（或者如果你喜欢冒险，在第一个声明的LHS上用一个更大的正数代替1）。

根据C标准，答案是否定的 。 如链接中所述， C中的Numerical Recipes使用了这个“技巧”。

顺便说一句，我认为你的意思

pointer[0] == array[6];

并不是

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

在你的问题中（类似于*pointer[5] ）

Answer 5

您可以使用指针指向C数组的任何元素。 由于C数组不“知道”它们的长度，因此无法直接表达C数组的“范围”。 由于必须存储数组本身的长度，因此必须存储指针指向的范围的长度。

Answer 6

指针指向单个内存位置，因此，正如其他人所说，你可以得到一个指向数组中间位置的指针

char *p = array + 6;

你需要以其他方式表达允许的范围，即通过最大长度。 或第二个指针

它可能值得指出

array[i] 

是完全相同的

*(array + i)

Answer 7

pointer = &array[6] 。 pointer[0]现在将引用与array[6]相同的值。 直接提取对数组切片的引用并为其保持sizeof语义是不可能的。 您可以使用以下内容模拟它：

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 8

是的，如果您正确使用地址：

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

Answer 9

如果我读了你的问题，你想要解决原始数组中的一系列元素，可以说是一个切片。

在C ++中，您可以轻松地完成此操作 - 只要您实现自己的数组类（保持指针+数字元素）。 然后你可以定义成员函数，它会返回一个切片：一个指向原始数组的指针和一些元素，这样你就不会在原始数组之外寻址。

在Plain-Old-C中，您不必使用大小的数组共享存储，并且指针在定义上是无限的：它只指向一个元素。 您不能让C代码“重新解释”一个大小的数组，因为数组的名称 （符号）是存储的地址，您无法修改。

你想要的是这个：

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

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

但这是不允许的。 名称“array2”由编译器转换为固定地址，您无法在运行时重新定义 - 这就是为什么存在指针：您可以在运行时随意更改它们的那些指针。

Answer 10

指针仅指向任何结构或变量中的第一个项目。 他们只是一个地址。 您可以通过使其成为指向标识范围的特定类型的指针来暗示范围。