指向同一数组的指针数组
是一个数组，其元素都是指针，且这些指针都指向同一个数组的不同元素。
概念：
指向同一数组的指针数组是一种特殊的数组，它的元素都是指针类型，这些指针都指向同一个数组的不同元素。
分类：
指向同一数组的指针数组可以根据指针的类型进行分类，比如可以是整型指针数组、字符型指针数组、结构体指针数组等。
优势：
- 灵活性：通过指向同一数组的指针数组，可以方便地对数组中的元素进行操作和访问。
- 节省内存：使用指针数组可以减少内存的占用，特别是在需要处理大量数据的情况下。
应用场景：
指向同一数组的指针数组在很多场景下都有应用，例如：
- 多维数组：可以使用指向同一数组的指针数组来表示多维数组，方便对多维数组进行操作。
- 字符串数组：可以使用指向同一数组的指针数组来表示字符串数组，方便对字符串数组进行处理和操作。
- 数据结构：在一些数据结构中，如图、树等，可以使用指向同一数组的指针数组来表示节点之间的关系。
推荐的腾讯云相关产品：
腾讯云提供了一系列云计算相关的产品，以下是一些推荐的产品：
- 云服务器（CVM）：提供弹性计算能力，可根据需求快速创建、部署和管理云服务器实例。 产品介绍链接：https://cloud.tencent.com/product/cvm
- 云数据库 MySQL 版（CDB）：提供高性能、可扩展的关系型数据库服务，支持自动备份、容灾等功能。 产品介绍链接：https://cloud.tencent.com/product/cdb
- 云存储（COS）：提供安全、稳定、低成本的对象存储服务，适用于存储和处理各种非结构化数据。 产品介绍链接：https://cloud.tencent.com/product/cos
- 人工智能（AI）：提供丰富的人工智能服务，包括图像识别、语音识别、自然语言处理等功能。 产品介绍链接：https://cloud.tencent.com/product/ai
请注意，以上推荐的腾讯云产品仅供参考，具体选择应根据实际需求进行。
相关·内容
2回答
比较两个指针的限制是什么？
、、、、
int a=40,b=34;
int *iptr1,*iptr2;
iptr1 = &a;
iptr2 = &b;
printf("\n Equal condition of two pointers=%d", (ip1 == ip2)); //no error
char name1[20], name2[20];
char *p1 = name1;
char *p2 = name2;
if(p1 > p2) /*Error*/
为什么关系操作有错误/警告，而比较操作没有错误/警告
浏览 4提问于2017-08-29得票数 0
ISO C11标准在哪里声明比较没有指向同一数组的两个指针(与<、>、<=、>=)是未定义的行为？
浏览 0提问于2019-08-30得票数 1
回答已采纳
1回答
我在C中实现了一个AVL树，直到后来我才读到指针比较只在同一个数组中的对象之间有效。在我的实现中，我做了一些平等测试。例如，为了测试节点是否是父节点的正确子节点，我可能会测试node==node->parent->right。但是，节点是根据需要分配的，而不是在一个连续的块中分配的。这个行为被定义了吗？如果不是这样，你会怎么写这段代码呢？
浏览 0提问于2016-01-24得票数 1
回答已采纳
2回答
在理解*binsearch函数中某些代码行的机制方面，我遇到了问题。特别是，低和高是两个指针，并分别初始化为&tab和&tabn。在下一行中，我看到了low<high，我认为它无效，因为不可能比较两个指针的两个地址。下一行也有同样的问题。我不知道我说的对不对，我需要你们大家的一些想法。
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#define MAXWORD 100
int getword(char *, int);
struct key *binsearch(c
浏览 2提问于2019-12-20得票数 5
回答已采纳
在C中，我有一个数组int A[20]。我有两个指针int *pi和int *pj分别指向两个条目A[i]和A[j]。我不认识i和j。我想知道i > j、j<i还是i==j。
我的想法是在pi和pj=A+j的基础上，通过比较pi = A + i和pj=A+j来实现这一点。我不知道i > j是否正确当且仅当pi>pj和i == j当且仅当pi==pj？谢谢!
浏览 4提问于2014-04-06得票数 1
回答已采纳
给定以下代码：
char buffer[1024];
char * const begin = buffer;
char * const end = buffer + 1024;
char *p = begin + 2000;
if (p < begin || p > end)
std::cout << "pointer is out of range\n";
执行的比较(p < begin和p > end)是否定义明确？或者这段代码有未定义的行为，因为指针已经超过了数组的末尾？
如果比较被很好地定义了，那么定义是什么？
(额外的奖励
浏览 0提问于2012-12-22得票数 13
回答已采纳
1回答
我通过了解到，递增空指针或在数组结束后递增并不是定义良好的行为：
int* pointer = 0;
pointer++;
int a[3];
int* pointer2 = &a[0];
pointer2 += 4;
但是，如果指向无效位置的指针仅用于比较，并且从未访问他所在位置的内存，该怎么办？
示例：
void exampleFunction(int arrayLen, char** strArray)
{
for(char** str = strArray; str < strArray + arrayLen; str++) //or even str <
浏览 4提问于2017-07-26得票数 6
回答已采纳
请考虑一下
int main(void)
{
int a;
int b;
int* pa = &a;
int* pb = &b;
int e = pa == pb;
}
这是定义良好的吗？pa和pb没有指向同一个数组中的元素.
浏览 0提问于2018-03-06得票数 1
回答已采纳
当我使用指针算法和!=创建一个过程时，例如
template <typename T> void reverse_array ( T * arr, size_t n )
{
T * end = arr + n;
while (arr != end && arr != --end)
{
swap(arr,end);
++arr;
}
}
我总是非常谨慎，因为如果我写错了我的过程，那么在一个角落的情况下，第一个指针可能会“跳过”第二个指针。但是，如果数组是这样的
&arr[0] < &
浏览 1提问于2015-04-25得票数 2
回答已采纳
2回答
我可能弄错了，但我似乎记得对于给定的内存分配。
char *p = malloc(4);
指针p是分配中所有字节的有效指针，也是分配之后的第一个字节的有效指针。
因此，要通过指针访问内存，p只有偏移p[0] .. p[3]是有效的。但是对于指针比较，&( p[4] )也是一个有效的指针。
这是正确的吗?在C标准()中，它是这么说的吗？似乎暗示了答案的正确方向，但它还是有点模糊。
浏览 2提问于2014-03-12得票数 6
回答已采纳
3回答
char** buffer{ /* some buffer */ };
char* ptr1{buffer[0]};
char* ptr2{buffer[10]};
assert(ptr1 < ptr2);
如果两个指针指向同一缓冲区中的不同位置，比较它们是否安全？
我想通过比较：assert(rangeBeginPtr < rangeEndPtr)来了解指针的范围是否有效。
浏览 4提问于2013-08-26得票数 1
回答已采纳
我有两个功能
void foo1(int);
void foo2(int);
也就是说，两者都有相同的签名。我有一个函数指针
typedef void (*func_pt)(int)
它可以指向foo1或foo2。
if (match_condition) {
func_pt = foo1;
}
else {
func_pt = foo2;
}
在后面的代码中，我需要了解func_pt是指向foo1还是foo2。
这段代码if (func_pt == foo1)似乎有效。
这是推荐的安全吗？如果没有，是否有其他方法可以找到函数指针指向的函数？
我不明白C编译器是如何计算出等式的。
浏览 1提问于2014-10-12得票数 2
回答已采纳
1回答
(有关>，<，<=，>=)
如果表达式P指向数组对象的元素，表达式Q指向同一数组对象的最后一个元素，则指针表达式Q+1比P大。在所有其他情况下，行为都是未定义的。
上面的几节(第6.5.8节)解释说，指针算法基本上可以像预期的那样工作在数组上。也就是说，int a[3]; int *p = a; int *q = &a[2]; //q-p == 3是有效的。但是，正如我所读到的，上面的q > p是UB。
我遗漏了什么？
浏览 1提问于2013-05-14得票数 5
减少指向数组第一个元素的指针是C17时未定义的行为。引用了C17的标准说法
C17 6.5.6/8
如果指针操作数和结果都指向同一个数组对象的元素，或者指向数组对象的最后一个元素，则计算值不会产生溢出；否则，行为将未定义。
这是最早定义的标准吗？这种操作是如何在早期的标准中定义的？以前是合法的吗？
浏览 2提问于2021-09-18得票数 0
回答已采纳
2回答
C中有效指针操作的问题
、、、
在K&R中，它说有效的指针操作是分配同一类型的点，加或减相同的数组......All --其他指针算法是非法的。
然而，当我在维基百科上阅读双链接列表的代码时，它会比较指向链接列表的不同节点的两个指针。这让我很困惑。这是代码
unsigned int DetectCycleinList(void)
{
DoublLinkedList* pCurrent = pHead;
DoublLinkedList* pFast = pCurrent;
unsigned int cycle = FALSE;
while
浏览 7提问于2016-06-02得票数 0
回答已采纳
2回答
比较两个指针有很多问题，但我没有发现这两种类型是否可以进行比较。给定的
A* a;
B* b;
我想知道表达式a @ b是否有效，其中@是==、!=、<、<=、>、>=之一(我不介意nullptr_t或任何其他可以隐式转换为指针的类型)。是当A, B是
平等？
除了简历-资格证书外，平等吗？
在同一类层次结构中？
...？
我在std::type_traits里什么也没发现。我可以做我自己的SFINAE测试，但我正在寻找规则，以直接应用它们。我想这对编译器来说会更容易，对吧？
编辑以再次澄清:我在比较指针，而不是指向的对象。我想事先知道a @ b
浏览 0提问于2014-03-18得票数 2
回答已采纳
4回答
指针比较的==
、、、
我引用Kernighan &Ritchie的“C编程语言”：
任何指针都可以有意义地与零进行相等或不等式的比较。但是，对于不指向同一数组成员的指针的算术或比较，则未定义此行为。(有一个例外:数组结束后的第一个元素的地址可以在指针算法中使用。)
这是否意味着我不能依靠==来检查不同指针的相等性？在什么情况下，这种比较会导致错误的结果？
浏览 8提问于2012-04-03得票数 29
1回答
在C++？
下面是一个例子：
void* p = malloc(64);
int* one = (int*)((char*)p);
int* two = (int*)((char*)p + 7);
printf("%x %x %d %d\n", one, two, sizeof(int), two - one);
。
我得到了输出的8a94008 8a9400f 4 1，所以它看起来像是做了除法并截断了余数。是否定义了行为？
浏览 18提问于2016-03-16得票数 19
回答已采纳
对于指向同一个对象或函数的两个指针( a和b )，C标准在什么情况下保证a == b？当a != b和b指向同一个对象时，是否有a可以容纳的平台？
浏览 2提问于2014-11-16得票数 6
回答已采纳
3回答
运算符<和>是如何处理指针的？
、、、、
只是为了好玩，我有一个const char*的std::list，每个元素指向一个以null结尾的文本字符串，并在其上运行一个std::list::sort()。碰巧，它没有对字符串进行排序(没有双关语的意思)。考虑到它是在指针上工作，这是有意义的。
根据std::list::sort()的，它(默认情况下)使用元素之间的operator <进行比较。
暂时忘记列表，我的实际问题是:这些(>，<，>=，<=)运算符是如何在C++和C中处理指针的？它们只是简单地比较实际的内存地址吗？
char* p1 = (char*) 0xDAB0BC47;
char* p2 =
浏览 3提问于2011-01-06得票数 13
回答已采纳
2回答
我正在重写libc的一部分，更确切地说，memmove是一个练习，在无法亲自完成之后，我查找了它的源代码，并找到了这个源代码(以及它的变体)：
void *memmove(void *dest, const void *src, size_t n)
{
char *d = dest;
const char *s = src;
if (d < s)
while (n--)
*d++ = *s++;
else
{
char *lasts = s + (n-1);
char *lastd = d + (n-1);
浏览 4提问于2021-10-25得票数 0
回答已采纳
2回答
C标准是否要求指针为(整数)数字？
有人可能会说，是的，因为指针运算.
但是另一方面，像--或++这样的操作可以理解为以前的内存位置，下一个内存位置，这取决于它们在标准中的描述方式，而实际的实现可以使用任何表示来保存指针数据(只要实现了上述操作).
想到了另一个问题-C是否要求数组/缓冲区等是连续的，即下一个元素存储在下一个内存位置(++p，其中p是一个指针)？我之所以这样问，是因为您经常可以在网上看到似乎认为是这样的实现。
浏览 1提问于2019-12-25得票数 1
回答已采纳
1回答
Stroustrup的C++编程语言第三版说，
只有当两个指针指向同一个数组的元素时才定义指针的减法(尽管语言无法快速确保这种情况)。当从另一个指针中减去一个指针时，结果是两个指针(一个整数)之间的数组元素数。可以向指针中添加整数或从指针中减去整数；在这两种情况下，结果都是指针值。如果该值没有指向与原始指针相同的数组中的元素，则使用该值的结果未定义。。
例如：
void f ()
{
int v1 [10];
int v2 [10];
int i1 = &v1[5] - &v1[3]; // i1 = 2
int i2 = &
浏览 4提问于2015-08-02得票数 8
回答已采纳
4回答
数组的C指针算法
、、、
我正在阅读K&R中关于数组算法的部分，我发现了一些奇怪的东西。我张贴了整个段落的上下文，但我主要集中在粗体部分。
如果p和q指向同一个数组的成员，那么像==、!=、<、>=等关系就会正常工作。例如，如果p指向比q更早的数组成员，则p<q为真。任何指针都可以有意义地与零进行相等或不等式的比较。但是，对于不指向同一数组成员的指针的算术或比较，则未定义此行为。(有一个例外:数组结束后的第一个元素的地址可以在指针算法中使用)。
这一例外的原因是什么？在定义数组大小时，是否为数组的末尾分配了额外的内存？若然，目的何在？是用空字符结束数组吗？
浏览 9提问于2013-06-18得票数 11
回答已采纳
3回答
下面的c程序的输出是1。有人能解释一下吗？
#include<stdio.h>
#include<string.h>
int main(){
int a = 5,b = 10,c;
int *p = &a,*q = &b;
c = p - q;
printf("%d" , c);
return 0;
}
浏览 3提问于2013-12-27得票数 0
2回答
因此，我有一个函数，它返回数组A中一个元素的指针。我还有另一个函数，它将指针作为参数。但是，我需要这个函数来处理它可能被传递给一个完全任意的指针的可能性。
是否有一种方法可以检测指针是否指向结构中的某个位置？在这种情况下，我的数组A？
我也见过关于C++的类似问题，但C没有。
浏览 3提问于2016-10-30得票数 2
回答已采纳
考虑两个具有静态存储持续时间和相等的恒定初始值的对象：
static const int a = 50;
static const int b = 50;
编译器将这些组合在一起是否有效，以便&a == &b
(对于上下文，我正在考虑使用静态常量对象来获取唯一的地址，以用作定点指针值。如果编译器将这样的对象组合在一起是合法的，并且我对两个这样的对象使用相同的常量值，那么地址可能相等，并且我不能将它们用作标记值。)
浏览 0提问于2013-02-08得票数 1
回答已采纳
2回答
我是否正确地认为，为了对指针数组进行排序，将指针作为int来处理是很好的。
qsort(ptrs, n, sizeof(void*), int_cmp);
我想对ptrs进行排序，以确定是否存在任何重复，而不管指针指向的是什么类型，因此qsort是进行此操作的先驱。
我的int_cmp()是相当标准的。
int int_cmp(const void *a, const void *b)
{
const int *ia = (const int *)a; // casting pointer types
const int *ib = (const int *)b;
/
浏览 0提问于2014-04-04得票数 2
回答已采纳
4回答
由于在一起添加两个指针是非法的，那么这个代码段如何有效？
struct key *low = &tab[0];
struct key *high = &tab[n];
struct key *mid;
while (low < high)
{
mid = low + (high-low) / 2; //isn't this adding pointers?
//code continues...
while循环中的第一个语句似乎将两个地址相加在一起，这是如何合法的？
这段代码来自于第122页的C语言K&Rs。
浏览 5提问于2014-08-15得票数 4
回答已采纳
3回答
在strchr引用的中，提供了这个示例。
/* strchr example */
#include <stdio.h>
#include <string.h>
int main ()
{
char str[] = "This is a sample string";
char * pch;
printf ("Looking for the 's' character in \"%s\"...\n",str);
pch=strchr(str,'s');
while (p
浏览 9提问于2015-01-03得票数 1
回答已采纳
当我定义并初始化一个数组a时
如果(&(a[x]) > &(a[y]))有效，那么x > y被暗示，这绝对是绝对安全的吗？
我很担心一些我不知道的奇怪的特殊的记忆地址。
浏览 0提问于2018-12-07得票数 4
回答已采纳
我有一个类型化指针typed，它是使用指针算法初始化的，它指向数组中的一个对象。我还有一个函数，它接受两个指针args，第一个类型与前面提到的指针相同，第二个是void * (参见下面代码中的myfunc() )。
如果我将typed作为第一个参数，而另一个指针键入与typed相同的第二个参数，然后比较这些参数在函数中是否相等，这是未定义的行为吗？
#include <stdio.h>
typedef struct S {int i; float f;} s;
void myfunc(s * a, void * b)
{
if (a == b) // <------
浏览 3提问于2020-07-29得票数 2
回答已采纳
2回答
我使用一个代码示例来检查两个整数之间的距离，比如在中。
int i = 0, j = 0;
std::cout << &i - &j;
根据我对内存表示的理解，这两个变量的这些内存地址应该是相邻的，两者的区别应该是1。
令我惊讶的是，在VS2017中用MS编译器运行此代码会打印3，并与GCC运行相同的代码打印1。
为什么会发生这种情况，VS有什么问题吗？
浏览 3提问于2019-10-15得票数 1
回答已采纳
1回答
我有个愚蠢的怀疑。假设我有一个数组int a[]={3,4,5,6}，现在我想知道这个数组的地址是指向只有3个或整个数组元素的位置？
浏览 2提问于2022-08-08得票数 0
3回答
什么时候指针减法在C中没有定义？
、、、、
char *buf = malloc(bufsize)
char *ptr = buf;
…
while(condition) {
ptrdiff_t offset = ptr - buf; // <========== THIS LINE
// offset will never be negative because we only ever *increase* ptr
if ((size_t)offset > bufsize) {
// we need more room
bufsize += 128;
浏览 7提问于2012-08-23得票数 11
回答已采纳
2回答
我正在研究上的公共域实现。它实现memmove()，如下所示:它“不是完全可移植的”！我想知道为什么：
括号放在代码的第一行，并且
代码不是完全可移植的。
守则如下：
void *(memmove)(void *s1, const void *s2, size_t n)
{
char *p1 = s1;
const char *p2 = s2;
if (p2 < p1 && p1 < p2 + n) {
/* do a descending copy */
p2 += n;
p1 += n
浏览 4提问于2013-10-26得票数 5
回答已采纳
int i = 0, j = 0;
int *a , *b;
a = &i + 1;
b = &j;
printf(" %p \n ",a);
printf(" %p \n ",b);
if(a==b)
printf(" yo \n");
输出：
0x7ffda8e133a4
0x7ffda8e133a4
A与b相同，但printf仍不执行。
当我将a和b作为正态变量时，这是很好的。(int a，b;)
浏览 0提问于2019-05-08得票数 3
回答已采纳
1回答
我试图使用boost缓冲区函数访问序列化的数据，并希望将其填充到两个向量中。我在填写第二个向量的地址上有问题。下面的类显示了这两个向量以及它们是如何填充的。
class LidarMeasurement {
private:
std::vector<uint32_t> _header;
std::vector<float> _azimuth;
public:
//The header consists of an array of uint32_t's in the following layout
enum Inde
浏览 1提问于2019-08-14得票数 2
回答已采纳
2回答
#include <stdio.h>
main() {
int *i,*j;
i = (int *) 60;
j = (int *) 20;
printf("%d\n", i - j);
}
这段代码的输出是什么？我在指针方面做了很多工作，但从来没有遇到过这样的代码。
浏览 2提问于2012-09-01得票数 0
示例：
int a[99];
int (*p)[99] = &a;
// this prints 1
printf("%d\n", (void *) p == (void *) *p);
通常，如果p是指向数组的指针，那么p和*p的对象表示(即位模式)是相等的。
我只是迷路了，对这种行为的可移植性完全不确定。
所以，我很好奇这种行为是否得到了标准的保证。如果是的话，请有人引用所有保证这一点的相关段落？
浏览 6提问于2021-07-29得票数 4
回答已采纳
3回答
下列行为是否会引发第4行和/或第5行中未定义的行为：
#include <stdio.h>
int main(void)
{
char s[] = "foo";
char * p = s - 1; /* line 4 */
printf("%s\n", p + 1); /* line 5 */
return 0;
}
浏览 3提问于2013-08-12得票数 15
回答已采纳
假设我有两个指向T类型的指针
T* first = ...// whatever
T* second = ... //whatever else
我能确定这两个指针之间的距离永远不会超过：
((size_t)(-1))/sizeof(T)
浏览 0提问于2011-10-20得票数 5
回答已采纳
3回答
我正在阅读K&R指针第5.4节，其中完成了malloc()和free()的堆栈实现。我正在使用gdb调试代码，alloc()部件正在按预期工作。但是对于afree()部分，指针仍然指向与以前相同的位置。以下是代码：
#include <stdio.h>
#define ALLOCSIZE 10000
static char allocbuf[ALLOCSIZE];
static char* allocp = allocbuf;
char* alloc(int n)
{
if(allocbuf + ALLOCSIZE - allocp >= n)
{
浏览 2提问于2016-02-08得票数 1
回答已采纳
4回答
如果减去两个空指针，就会得到指针位置之间的相对距离(至少在我的测试系统上是这样)。我应该使用哪种类型来存储结果，以便它与64位系统兼容？size_t是正确的类型还是长的？
背景:我们需要检查给定的空指针作为双指针使用是否安全。我们过去常常将指针转换为int，并检查下三位是否为零，但是我们当前的编码标准不再允许将指针转换为整数类型。我正在考虑计算空指针和空指针之间的差异，并检查这种差异是否可以被8除。假设空指针总是8字节对齐？
浏览 3提问于2016-04-14得票数 4
回答已采纳
2回答
我知道在C标准中，只有当指针指向相同的内存空间(如数组)时，才允许与<进行指针比较。
如果我们取一个数组：
int array[10];
int *ptr = &array[0];
是否允许将ptr与array+10进行比较？array+10指针是否被认为在数组内存之外，因此不允许进行比较？
示例
for(ptr=&array[0]; ptr<(array+10); ptr++) {...}
浏览 0提问于2013-04-26得票数 8
回答已采纳
2回答
如果我存储一个指向某个函数的指针，然后在我的程序执行过程中的某个时候，将其与同一个函数的地址进行比较，则这两个地址保证相等。
例如。
int foo(void){return 0;}
int (*foo_p)(void) = &foo;
assert(foo_p == &foo);
在上面的代码中，断言总是被保证成功吗？在什么情况下，一个函数的地址可以改变？
浏览 3提问于2011-09-08得票数 12
回答已采纳
1回答
对于非空原始指针nullptr < ptr和ptr < nullptr，ptr != nullptr是否有很好的定义？欢迎来自C++标准的报价。
浏览 1提问于2017-07-11得票数 4
回答已采纳
2回答
假设你有一个数组： int array[SIZE]; 或者 int *array = new(array[SIZE]); C或C++是否保证 ，如果是这样的话，在哪里？ 我知道，无论语言规范如何，许多操作系统都通过将虚拟地址空间的顶部保留给内核来保证这一特性。我的问题是，这是否也是有保证的 通过语言 ，而不仅仅是通过绝大多数实现。 例如，假设OS内核位于较低的内存中，并且有时会将最高的虚拟内存页面分配给用户进程，以响应 请求匿名内存。如果 或者 直接调用 用于分配一个巨大的数组，并且数组的末尾紧邻虚拟地址空间的顶部，使得 回绕到零，这是否等同于该语言的不合规实现？ 澄清 Stackoverf
浏览 35提问于2021-03-02得票数 74
回答已采纳
6回答
我是在笔试中提出这个问题的。在我的lapi上运行下面的代码时，我得到了10作为输出
#include<stdio.h>
int main()
{
int *i, *j;/* two pointer variable*/
i = (int *)60;
j = (int *)20;
printf("%d \n",i-j);
return 0;
}
产出：
10
有人能告诉我为什么输出是10吗？
浏览 8提问于2015-01-11得票数 9
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
