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

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()函数。

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

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

我需要速度!!!

===============>>#1 票数:12 已采纳

尽管每个人都说过,这可能的,只有一个小小的警告 - 除非你有一个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] */

===============>>#2 票数:6

果然你可以。

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

输出将是3-4。

===============>>#3 票数:4

在下面的例子中,我声明了一个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;
}

===============>>#4 票数: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]

===============>>#5 票数:3

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

===============>>#6 票数:3

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

char *p = array + 6;

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

它可能值得指出

array[i] 

是完全相同的

*(array + i)

===============>>#7 票数:2

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

===============>>#8 票数:2

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

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

===============>>#9 票数:1

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

在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”由编译器转换为固定地址,您无法在运行时重新定义 - 这就是为什么存在指针:您可以在运行时随意更改它们的那些指针。

===============>>#10 票数:-1

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

  ask by Kelly Elton translate from so

未解决问题?本站智能推荐:

3回复

指向数组语法的指针

我对数组指针的语法有疑问。 我们知道数组本身就是指针(我们的大学教授说的),所以为什么当我们用另一个指针(将是指向指针的指针)指向它们时,我们使用以下语法: 代替此语法: 虽然我知道使用malloc会是正确的,但是为什么不按常规方式使用,这是编译器还是语法问题,或者我在其他地方
1回复

指向数组混乱的指针

根据定义,它是一个指向数组的指针变量。 我的代码打印三个元素数组的值。 我的问题,为什么使用printf("Value at %p = %d\\n", ptr2arr +i, *(ptr2arr[0]+i)); 和错误的结果,除了使用printf("value at %p =%d\\n
3回复

c / c ++指向数组的指针与指向指针的指针

在运行此程序之前,我认为数组和指针基本上是同一件事: 输出为: 有人可以解释一下为什么&b的输出与b相同吗? 谢谢! -埃尔本
2回复

指向多维数组的指针[重复]

这个问题已经在这里有了答案: C指针指向数组/指针数组消除歧义 12个答案 之间有什么区别 和 另外,如果我们定义另一个这样的指针 这代表什么? 如果任何人都可以解释以上三个之间的区别,这将非常有帮助。
2回复

指向4维数组的指针

你好, 我试图弄清楚为什么将指针int的类型指针用于数组z元素类型的逻辑? 初始化数组z时,为yr分配类型为int的指针时会发生什么。 yr is和int的指针数组。 yr衰减为int指针。 在数组z初始化之前。 但是在z初始化之后,yr是指向该指针的指针。 由于衰减,
12回复

指向[-1]数组索引的指针

指针如何指向[-1]数组的索引每次都会产生合法的输出。 指针赋值实际发生了什么? 代码输出: 编辑:如果这种情况有效,那么我可以用它来定义一个索引从1开始而不是0的数组,即:array [1],array [2],...
3回复

指向char数组C ++的指针

我在将下一个代码从c转换为c ++时遇到问题: 我有一个函数,将一组移动序列(从a到i的字符序列)作为arg。 码: gcc可以很好地编译该代码,但是如果我尝试使用g ++进行编译,则会发出下一个警告: main.cpp:17:39:警告:不建议将字符串常量转换为'char
1回复

指向CUDA中对象的指针数组的指针

我遵循了这个问题和此链接提供的指导, 这些指导涉及将指针数组传递给设备并返回的概念,但是当指针指向对象时,我似乎在为我的具体情况苦苦挣扎。 请参阅下面的示例代码,其中为了简洁起见,我已删除了错误检查。 所以问题是: 如果上面的SEE QUESTION 1指示的行为指针分配了主
2回复

编译后的数组和指向数组的指针之间的区别?

例如,在此函数中,变量a指向内存中连续9个整数的位置。 但是c呢? c是否指向内存中某个位置,该位置指向内存中连续包含9个整数的位置? 那么,从技术上讲, c是单层指针还是双层指针? 我上面说的不对吗? 执行以下功能时会如何: a和c都指向相同的位置? c不应是
1回复

指向由数组初始化的矩阵的指针的数组

我想使用指向矩阵的指针数组在不同矩阵之间循环,我想使用数组变量初始化这些矩阵的行。 由于不同的原因,我无法创建一个新类。 更具体地说,我想要这样的东西: 第一点 然后: 但是编译器说我不能用这种方式初始化矩阵。 我现在有: 然后,我想使用指针访问它们,