尽管大家已经说过的话,但是,如果你有99个编辑机构,那么这个网站(is)可能有一个小洞穴,你必须知道你在汇编时想要的“slice”的大小。

为了正确宣布和使用点人,你还必须知道,底线操作者<代码>[在<代码>*上对参照操作者具有约束力,因此需要准绳。

:

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
", (*pointer)[0]);
printf("(*pointer)[4] = %c
", (*pointer)[4]);
printf("sizeof *pointer / sizeof **pointer = %lu
", (unsigned long)(sizeof *pointer / sizeof **pointer));

<><>>

回答你的actual问题,这非常容易。 仅使用一个点,由缓冲阵列抵消,例如:

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

够了。

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

产出为3-4。

在以下例子中,我宣布了10个x的固定阵列。 我提出了两个要点,从而界定了范围。 下面我做了些什么:我宣布,从点码1开始,在到达点码第2页——印刷项目价值之前,该页逐个逐项。

你们正在寻找什么?

#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;
}

正如其他人所说的那样,你可以很容易地做第一部分的工作。 Just do pointer = protocol + 6。 但<代码>点名/代码”是什么? cannot 声明如下:

char pointer[5];

或相似。 它必须是点/>点:

char *pointer = array + 6;

这是因为你可以把一个阵列分配给其他一些名称(一个阵列不是一个可变的负值)。 说:

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

现在,在C,点人的规模只是点人的规模,因为点人没有某种“单位数目”的概念。 另一方面,Arrays确切知道他们拥有多少要素,你可以通过适当使用<<>条码/代码>的操作员获取这一规模。

因此,在你的例子中,<代码>阵列为10(如果它有10个要素),而<代码>sizeof pointer/code>则为char点号>所占领的tes的数量。 Therefore, 您在问题第二部分中提出的内容在C是不可能做到的。 在C++中,你可以查阅数据类型,以便你能够做你想要的事情。

。 a. 阅读草原档案:

请允许我说,你有了一个大的缓冲,相信你可以把整个档案读到:

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

可在<条码>上登记。 因此:

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

(或如果你重新感到冒险,则在第一份发言中以较大的积极数字取代1)。

根据C标准,答案是no。 如该链接所述,C的初级专业文凭。 使用了这一trick。

作为一旁,我认为你意味着

pointer[0] == array[6];

而不是

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

您提出的问题(类似*pointer[5])

你可以指出C阵列的任何内容。 自2006年以来 阵列并不“知道”其长度,不能直接表达“距离”的意思。 由于你必须储存阵列的长度,因此,你必须储存距离点。

a 点数指一个单独的记忆点,而其他人则表示,你可以找到点点点,指出一个阵列中的位置。

char *p = array + 6;

你们需要以某种其他方式表示,即通过最长期限。 或第二点

也许值得指出的是:

array[i] 

相同

*(array + i)

是的,如果你正确使用地址:

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

<代码>pointer = &array[6].pointer[0] 现在将参照与array[6]相同的数值。 不可能直接引用一个阵列的斜体,并保留<>条码>。 你们可以效仿:

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

如果我阅读你的问题,你想谈谈原阵列中的一系列内容,就这样说了。

在C++中,如果你执行自己的阵列(保持一个点+点数要素),你可以很容易地这样做。 然后,你可以界定成员职能,使你能够回头角:在原有阵列上点子,以及你不会在原阵列之外处理的若干要素。

在Plain-Old-C,你不能需要大小阵列共用储存,而根据定义,点子没有约束:它只是一个要素。 您不能让C-code“re-interpret”号大小阵列,因为其阵列(符号)的是储存的地址,你不能改动。

你们想要的是:

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

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

但不允许这样做。 “举报2”的名称由汇编者翻译成固定地址,你无法在操作时间重新界定——这说明为什么有点人:在你看来,无论在操作时间,他们都可以改变。

点击器仅指任何结构或变量中的第一个项目。 只是一个地址。 您可以提出一系列内容,将其放在确定范围的具体类别上。