C++ 对于数组指针

我想知道，你能在数组中创建一个指向一组变量的指针吗？ 像这样

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

那么你可以说

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

及

以及*指针的长度

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

好啊 让我解释一下我想完成什么，也许这会让我清醒一点。 我想把一个完整的文件读入缓冲区，但我想一块一块地读。将一个小数组传递到read（）中，然后将其循环到更大的数组中，这样做是行不通的。我希望可以直接“指向”缓冲区中要填充的区域，并将其传递给read（）函数

我不想使用流或任何在我背后缓冲的东西 这会适得其反，因为我正试图立即将整个文件读入内存。尽可能快

---

我需要速度

指针=&array[6]

<代码>指针[0]现在将引用与数组[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);

模板
类切片{
公众：
切片（T*元素，int开始，int结束）：m_元素（元素+开始），m_大小（结束-开始）{
T&运算符[]（int-index）{返回m_元素[index]；}
int size（）常量{返回m_size；}
私人：
T*m_元素；
国际货币单位大小；
};
int值[10]；
切片（值5、10）；
数值[5]=3；
断言（片[0]==值[5]）；
断言（slice.size（）=5）；

你当然可以

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

inta[4]={1,2,3,4}；
int*b=&a[2]；
cout是，如果正确使用地址：

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

您可以有一个指向C数组中任何元素的指针。由于C数组不“知道”它们的长度，所以不能直接表示C数组的“范围”。由于必须存储数组本身的长度，因此必须存储指针指向的范围的长度
 指针仅“指向”任何结构或变量中的第一项。它们只是一个地址。您可以通过使其成为指向标识范围的特定类型的指针来表示范围。
在下面的示例中，我声明了一个10倍整数的静态数组。我创建了两个指向其元素的指针，从而定义了一个范围。接下来我做的是：我在for循环中声明了一个指针，从指针p1开始，指针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;
}

#包括
使用名称空间std；
int main（）
{ 
inta[10]={0,4,5,7,4,3,1,6,2,9}；
int*p1=&a[3]；
int*p2=&a[7]；
对于（int*p=p1；p！=p2；++p）
{
CUT
指针指向单个内存位置，因此，正如其他人所说的，您可以得到指向某个数组的中间位置的指针
char *p = array + 6;

您需要以其他方式表示允许的范围，即通过传递最大长度或第二个指针

也许值得指出的是

array[i] 

与相同

*(array + i)

正如其他人所说，您可以轻松地完成第一部分。只需执行
pointer=array+6
。但什么是
pointer
？它不能声明为：

char pointer[5];

或类似。它必须是指针：

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

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

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

因此，在您的示例中，
sizeof array
将是10（如果它有10个元素）而代码>是由代码> char < /C>指针所占用的字节数。<强>因此，在第二部分中，在C<强>中不可能要求的是什么。在C++中，您可以访问允许您做所需的数据类型。< /P>
编辑：要分块读取文件，请执行以下操作：

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

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

对于任何类型的
T
，您能否声明
指针
：

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

（或者，如果你有冒险精神，在第一句话的左上角用一个更大的正数替换1）

根据C标准，答案是。正如链接中提到的，C中的数字配方利用了这个“技巧”

顺便说一句，我想你的意思是

pointer[0] == array[6];

而不是

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

在你的问题中（类似于
*指针[5]
）
如果我读了你的问题，你想解决原始数组中的一系列元素，也就是说一个片段

在C++中，你可以很容易地完成这一操作——只要你实现了自己的ARAYEYE类（保持指针+数字元素）。然后你可以定义将返回一个切片的成员函数：指向原始数组的指针和一些元素，这样你就不会在原始数组之外进行寻址。
在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”被编译器翻译成一个在运行时无法重新定义的固定地址-这就是为什么会有指针：在这些指针中，您可以在运行时随意更改它们指向的任何对象。
不管大家怎么说，这是可能的，但有一点需要注意-除非您有C99编译器，否则您必须知道“切片”的大小编译时需要的

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

瞧：

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

附录：
*pointer[0] == array[6];

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

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

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