/*指针和数组及存储单元*/

最新推荐文章于 2024-09-04 11:50:21 发布
原创 最新推荐文章于 2024-09-04 11:50:21 发布 · 266 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c语言 #指针 #算法

这段代码展示了在C语言中，通过指针计算数组元素之间的距离。程序首先定义了一个双精度浮点数数组，然后获取了数组第一个元素的指针，并将其加一。接着，程序打印出两个指针之间的字节差距以及整数差距。这揭示了C语言内存布局的细节。 
#include<stdio.h>
int main()
{
    double a[2],*p,*q;
    p=&a[0];
    q=p+1;
    printf("%lld\n",q - p);
    printf("%d\n",(int)q-(int)p);
    return 0;
}
C语言之指针数组与数组指针
m0_64365419的博客
07-10 1083
本质依然是数组，只是数组中存放的元素都是指针。就比如好孩子，好只是修饰词，无论他好不好，他都是孩子 本质依然是指针，只不过为指向数组的指针，存放数组的地址。 那该如何定义呢？首先，回忆我们之前学过的整形指针和字符指针的定义方法 其次，我们之前还学过对任意数组有： 那么数组指针是不是可以这样表示？ 下面那个是数组指针？ 正确答案是2，那么1为什么不是呢？原因是[]的优先级高于*,对于第一种，p1会优先和[]进行结合，这里的p就成为数组了，但2将p2...
【C语言】数组和指针
suiyishiguang的博客
05-28 889
【C语言】数组和指针
内存单元与指针
HONDELY的专栏
06-04 1918
C语言允许直接访问物理地址，能进行位（bit）操作，能实现汇编语言的大部分功能，可以直接对硬件进行操作。因此有人把它称为中级语言。也就是说，C语言可以直接对物理地址进行操作。 学习指针是学习C语言中最重要的一环，能否正确理解和使用指针是我们是否掌握C语言的一个标志。 在计算机中，所有的数据都是存放在存储器中的。一般把存储器中的一个字节称为一个内存单元，不同的数据类型所占用的内存单元数不等，如整型量占2个单元，字符量占1个单元等，在前面已有详细的介绍。为了正确地访问这些内存单元，必须为每个内存单元编上号。根据
指针与数组总结
LSG_Dawn的博客
05-09 397
总结： 一维数组与指针 type  a[N]]; sizeof(a[0])==>  sizeof(a)==> N*type  sizeof(&a)==> 4 a[0]+1==>值加1 &a[0]+1 ==>加一个元素 a+1 ==> 加一个元素,+type  &a+1 ==> 加一个数组 type *p = a; sizeof(p)==>   4 sizeof(*p)==>
变量存储单元与指针
liwuxing的专栏
02-12 714
试验程序 #include <rtthread.h> int main(void) { char num = '1'; //定义字符变量num，并赋值字符‘1’ char *ptr = # //定义字符变量的指针ptr，并指向num变量 char **p_ptr = &amp;ptr; //定义字符变量的指针p_ptr，并指向ptr变量 rt_kprintf("指针ptr指向的值%x\n",*ptr); rt_kprintf("指针ptr的值%...
C 语言对于存储区域及指针的概念总结
old__donkey的博客
11-23 864
存储区域：     全局变量分配在静态去，局部变量和形参存放在栈区，手动管理内存的在堆区，常量存放在常量区。 指针及指针变量：    一块存储单元对应的一个地址，指针就是地址，这个地址指向这个存储单元，存放存储单元的地址或指针的变量叫做指针变量，指针变量的值，就是这个地址或指针，指针变量可以为空，指针变量相减可去获取对应的存储单元长度，相加则无意义。
C语言基础知识之（十三）：指针、指针和数组
leleyuan1130的博客
08-30 598
一、指针的声明和定义 1、访问数据一般有两种方式：直接、间接 直接：通过变量访问数据， 如：通过变量a访问内存单元。 int a = 10; printf("%d\n",a); 间接：通过内存单元的地址访问数据。取地址符&，获取变量a所在的地址并用%p打印。 printf("变量a存储单元的地址：%p\n",&a);   2、指针的定义 存储内存单元地址的变量称为：指针 指
用指针计算数组元数个数和数组元素的存储单元数
03-28
使用指针计算数组元素个数和数组元素的存储单元数： ```c++ int arr[] = {1, 2, 3, 4, 5}; int* p = arr; // 将指针指向数组的首元素 int count = sizeof(arr) / sizeof(*p); // 数组元素个数为5 int size = sizeof...
C语言08--指针数组结合
weixin_69902486的博客
09-04 3100
C语言数组指针结合超详细讲解，助你拿下C语言的数组指针这两把利剑！ 少年，我来助你！
详谈C/C++数组名与数组指针
dyamoo的博客
07-19 591
数组是C/C++里面一个非常重要的连续型存储结构，而且数组名与指针也有着密切相关的关系，本篇博文主要讲解的就是其中的关系。
C语言复习-数组与指针
weixin_41859336的博客
03-29 1169
数组 数组由数据类型相同的一系列元素组成。 有时需要将数组设置成只读，这样程序只能从数组中检索值，不能把新值写入数组。 const int days[MONTHS] = {1,2,3,4,5,6,7,8,9}; 可以省略方括号中的数字，让编译器匹配数组大小和初始化列表的项数。 const int days[] = {1,2,3,4,5,6,7,8,9}; C99规定，可以在初始化列表中使用带方括号的下标指明待初始化的元素。 int days[6] = {[5] = 212...
指针的介绍
w843803110302005的博客
03-07 1578
内存单元(一个字节)的编号可以称为地址地址也可以称为指针。，指针相当于一个门牌号，而号码是由每位的1和0组成。下面我们进行一下联想：整形变量是存放整数值。字符变量就是存放单个字符的。指针变量就是存放指针(地址)的。2.指针变量的大小而指针在32位平台是4个字节，而在64位(bit)平台是8个字节。地址有多大，其指针变量就有多大。（单位：字节(byte))。指针的算术运算：指针可以进行算术运算，如递增（++）和递减（--），这些运算可以改变指针指向的内存地址。
10.28 c语言复习之指针相关
wp1995的博客
10-28 501
（1）指针的概念 指针定义的一般格式： 类型标识符   *标识符   如：float  *pointer_1;        float  *pointer_2; 指针的运算举例： #include int main() { int a=3; int *p; printf("1:a=%d\n",a); //直接访问方式 a p=&a; printf("2:*p
c语言的指针
CODER的博客
01-24 1148
1. 前言 指针是C语言的一个重要组成部分，是C语言的核心，精髓所在。以下是两个优点： ①提高程序的编译效率和执行速度，实现动态的存储分配 ②使程序更灵活，便于表示各种数据结构，编写高质量的程序 关于地址和指针的关系这里不介绍了 指针变量 1. 指针变量的一般形式 int *p;//定义一个整型指针 char *p;//定义一个字符型指针 2....
关于指针,存储方式
qq_41413485的博客
01-20 2701
在内存中，每8位在内存中作为一个储存单元，每8位（bit）也叫一字节（byte），作为内存单位 在32位系统中，每一个存储单元用4字节（也就是32位二进制数）给自己编号，也就是说，一个地址用32位二进制数来表示。编址范围是2^32，也就是4G。 在64位系统中，每一个存储单元用8字节（也就是64位二进制数）给自己编号，也就是说，一个地址用64位二进制数来表示。编址范围是2^64，也就是16777216T，但实际上只能存128G。 注意： 1、指针存储的是地址是用4个存储单元（一个整型变.....
指针知识点总结
2301_80151382的博客
08-10 1427
指针知识点总结
C语言指针——基础知识理解
qq_62311779的博客
03-17 4955
前言： 强转与指针，并称C语言的两大神器，用好了可呼风唤雨，威力无比，用不好也会伤及自身 理解指针要从变量的地址谈 （1）内存是如何编址的？ 内存中的每个字节都有唯一的编号（地址） 地址按字节编号，其字长一般与主机相同 32位机使用32位地址，最多支持232字节内存(4G) ...
C语言：利用指针计算数组中的元素和以及平均值
热门推荐
Java_yubaobao的博客
12-07 1万+
#include<stdio.h> int avg_sum(int*, int, float*, int*); int main(){ int a[10],i,sum; float avg; int *p=a; for(i=0;i<10;i++) scanf("%d",&amp;a[i]); avg_sum(&amp;a[i],i,&amp;avg,&amp;sum); prin...
/* 队列基本操作（数组实现） */ #include "queue.h"///data/workspace/myshixun/chp3/fatal.h #include "fatal.h" #include <stdlib.h> #define MinQueueSize ( 5 ) struct QueueRecord { int Capacity; //队列容量 int Front; //队首，进行出队操作 int Rear; //队尾，进行入队操作 int Size; //队列实际大小 ElementType *Array; //队列数组指针 }; /* START: fig3_58.txt */ int IsEmpty( Queue Q ) { // 请在此添加代码，队列空，返回1；否则返回0 /********** Begin *********/ /********** End **********/ } /* END */ int IsFull( Queue Q ) { // 请在此添加代码，队列满，返回1；否则返回0 /********** Begin *********/ /********** End **********/ } /* 队列的创建 */ Queue CreateQueue( int MaxElements ) { Queue Q; /* 1*/ if( MaxElements < MinQueueSize ) /* 2*/ Error( "Queue size is too small" ); /* 3*/ Q = malloc( sizeof( struct QueueRecord ) ); /* 4*/ if( Q == NULL ) /* 5*/ FatalError( "Out of space!!!" ); /* 6*/ Q->Array = malloc( sizeof( ElementType ) * MaxElements ); /* 7*/ if( Q->Array == NULL ) /* 8*/ FatalError( "Out of space!!!" ); /* 9*/ Q->Capacity = MaxElements; /*10*/ MakeEmpty( Q ); /*11*/ return Q; } /* START: fig3_59.txt 队列创建后各变量置初态 */ void MakeEmpty( Queue Q ) { // 请在此添加代码，初始化队列的Size，Front，Rear值 /********** Begin *********/ /********** End **********/ } /* END */ /* 队列的销毁 */ void DisposeQueue( Queue Q ) { if( Q != NULL ) { free( Q->Array ); free( Q ); } } /* START: fig3_60.txt 队列Q的Value值加1 */ static int Succ( int Value, Queue Q ) { if( ++Value == Q->Capacity )//指针value加1后返回，如果加1后等于容量了返回0 Value = 0; return Value; } /* 元素X入Q队 */ void Enqueue( ElementType X, Queue Q ) { if( IsFull( Q ) ) Error( "Full queue" ); else { // 请在此添加代码，完成入队操作 /********** Begin *********/ /********** End **********/ } } /* END */ /* 取队首元素 */ ElementType Front( Queue Q ) { if( !IsEmpty( Q ) ) return Q->Array[ Q->Front ];//返回队头元素值 Error( "Empty queue" ); return 0; /* Return value used to avoid warning */ } /* 出队，不保存出队元素 */ void Dequeue( Queue Q ) { if( IsEmpty( Q ) ) Error( "Empty queue" ); else { // 请在此添加代码，完成出队操作 /********** Begin *********/ /********** End **********/ } } /* 队首的元素出队后保存在变量X中可返回 */ ElementType FrontAndDequeue( Queue Q ) { ElementType X = 0; if( IsEmpty( Q ) ) Error( "Empty queue" ); else { Q->Size--; X = Q->Array[ Q->Front ];//队头元素放入X后被返回 Q->Front = Succ( Q->Front, Q ); } return X; } /* 测试主函数 */ main( ) { Queue Q; int i; Q = CreateQueue( 12 ); //创建队列 printf("第一次入队（0~9）：\n"); for( i = 0; i < 10; i++ ) //0到9入列 // 请在此添加代码，调用函数完成入队操作 /********** Begin *********/ /********** End **********/ printf("出队，即入队元素有：\n"); while( !IsEmpty( Q ) ) //遍历出队元素 { printf( "%d ", Front( Q ) ); Dequeue( Q ); } printf( "\n"); printf("第二次入队（0,3,6,9）：\n"); for( i = 0; i < 10; i+=3 ) //0到9中3的倍数入列 Enqueue( i, Q ); printf( "\n"); printf("出队，即入队元素有：\n"); while( !IsEmpty( Q ) ) //创建队列 { printf( "%d ", Front( Q ) ); // 请在此添加代码，调用函数完成出队操作 /********** Begin *********/ /********** End **********/ } printf( "\n"); DisposeQueue( Q ); //销毁队列 return 0; }
最新发布
11-19
<think> 根据用户需求，我们需要补全队列基本操作（数组实现）的C语言代码。我们将实现一个循环队列，因为数组实现的队列如果不使用循环，会出现“假溢出”问题。循环队列通过模运算实现队列头尾指针的循环移动。 循环队列的基本操作包括： 1. 初始化队列 2. 判断队列是否为空 3. 判断队列是否为满 4. 入队操作 5. 出队操作 注意：循环队列中，我们通常认为队头指针front指向队头元素的前一个位置，队尾指针rear指向队尾元素。但也可以有其他设计，这里我们采用常见的：队头指针front指向队头元素，队尾指针rear指向队尾元素的下一个位置。 队列判空条件：front == rear 队列判满条件：(rear+1) % MaxSize == front (此时队列中有一个空位，我们牺牲一个存储单元来区分队空和队满) 我们使用数组实现，定义如下： ```c #define MaxSize 50 // 队列的最大容量 typedef int ElemType; // 队列元素类型 typedef struct { ElemType data[MaxSize]; int front; // 队头指针 int rear; // 队尾指针 } SqQueue; ``` 现在补全各个函数： 1. 初始化队列：将front和rear都置为0。 2. 判断队列为空：front等于rear。 3. 判断队列为满：(rear+1) % MaxSize == front 4. 入队操作：先判断队列是否满，不满则将元素放入rear位置，然后rear=(rear+1)%MaxSize。 5. 出队操作：先判断队列是否空，不空则取出front位置的元素，然后front=(front+1)%MaxSize。 下面我们按照要求补全代码： ```c #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #define MaxSize 50 typedef int ElemType; typedef struct { ElemType data[MaxSize]; int front; int rear; } SqQueue; // 初始化队列 void InitQueue(SqQueue *Q) { Q->front = 0; Q->rear = 0; } // 判断队列是否为空 bool QueueEmpty(SqQueue Q) { if (Q.front == Q.rear) return true; else return false; } // 判断队列是否满 bool QueueFull(SqQueue Q) { if ((Q.rear + 1) % MaxSize == Q.front) return true; else return false; } // 入队 bool EnQueue(SqQueue *Q, ElemType x) { if (QueueFull(*Q)) { // 队满 return false; } Q->data[Q->rear] = x; Q->rear = (Q->rear + 1) % MaxSize; // 循环队列 return true; } // 出队 bool DeQueue(SqQueue *Q, ElemType *x) { if (QueueEmpty(*Q)) { // 队空 return false; } *x = Q->data[Q->front]; Q->front = (Q->front + 1) % MaxSize; return true; } int main() { SqQueue Q; InitQueue(&amp;Q); int x; // 测试入队 for (int i = 0; i < 10; i++) { EnQueue(&amp;Q, i); } // 测试出队 while (!QueueEmpty(Q)) { DeQueue(&amp;Q, &amp;x); printf("%d ", x); } printf("\n"); return 0; } ``` 注意：这里我们使用了`stdbool.h`来使用bool类型。如果没有这个头文件，可以用int代替。 以上代码实现了循环队列的基本操作。在入队和出队时，通过模运算实现循环。我们牺牲了一个存储单元来区分队满和队空。 §§相关问题§§ 1. 如何计算循环队列中元素的个数？ 2. 如果不牺牲一个存储单元，如何区分队空和队满？ 3. 循环队列在操作系统中有哪些应用？ </think> # 队列基本操作（数组实现）的C语言代码补全 下面是补全后的队列基本操作（数组实现）的C语言代码，包括队列初始化、判空、判满、入队和出队等操作： ```c #include <stdio.h> #include <stdbool.h> #define MAX_SIZE 50 // 定义队列最大容量 typedef struct { int data[MAX_SIZE]; // 存储队列元素的数组 int front; // 队头指针 int rear; // 队尾指针 } Queue; // 初始化队列 Queue* CreateQueue(int size) { Queue* q = (Queue*)malloc(sizeof(Queue)); if (q != NULL) { q->front = 0; q->rear = 0; } return q; } // 判断队列是否为空 bool IsEmpty(Queue* Q) { /********** Begin *********/ return Q->front == Q->rear; /********** End *********/ } // 判断队列是否已满 bool IsFull(Queue* Q) { /********** Begin *********/ return (Q->rear + 1) % MAX_SIZE == Q->front; /********** End *********/ } // 获取队头元素 int Front(Queue* Q) { /********** Begin *********/ if (IsEmpty(Q)) { printf("队列为空!\n"); return -1; // 错误值 } return Q->data[Q->front]; /********** End *********/ } // 入队操作 void Enqueue(int x, Queue* Q) { /********** Begin *********/ if (IsFull(Q)) { printf("队列已满!\n"); return; } Q->data[Q->rear] = x; Q->rear = (Q->rear + 1) % MAX_SIZE; // 循环队列 /********** End *********/ } // 出队操作 void Dequeue(Queue* Q) { /********** Begin *********/ if (IsEmpty(Q)) { printf("队列为空!\n"); return; } Q->front = (Q->front + 1) % MAX_SIZE; // 循环队列 /********** End *********/ } // 销毁队列 void DisposeQueue(Queue* Q) { free(Q); } // 主函数用于测试 int main() { Queue* Q = CreateQueue(12); // 创建队列 int i; printf("第一次入队（0~9）：\n"); for(i = 0; i < 10; i++) { Enqueue(i, Q); // 入队操作 } printf("出队，即入队元素有：\n"); while(!IsEmpty(Q)) { printf("%d ", Front(Q)); Dequeue(Q); // 出队操作 } printf("\n"); printf("第二次入队（0,3,6,9）：\n"); for(i = 0; i < 10; i += 3) { Enqueue(i, Q); } printf("\n"); printf("出队，即入队元素有：\n"); while(!IsEmpty(Q)) { printf("%d ", Front(Q)); Dequeue(Q); // 出队操作 } printf("\n"); DisposeQueue(Q); // 销毁队列 return 0; } ``` ## 代码说明 ### 1. 循环队列的实现原理 我使用了**循环队列**实现，通过模运算(`%`)实现队列的循环利用[^2]。关键点： - `front`指向队头元素 - `rear`指向队尾元素的下一个位置 - 队列满的条件：`(rear + 1) % MAX_SIZE == front` - 队列空的条件：`front == rear` ### 2. 各函数功能说明 1. **`CreateQueue`**：初始化队列，设置`front`和`rear`为0 2. **`IsEmpty`**：检查队列是否为空（`front == rear`） 3. **`IsFull`**：检查队列是否已满（`(rear + 1) % MAX_SIZE == front`） 4. **`Front`**：获取队头元素（不删除） 5. **`Enqueue`**：元素入队，更新`rear`指针 6. **`Dequeue`**：元素出队，更新`front`指针 ### 3. 循环队列的优势 循环队列解决了数组实现队列时的"假溢出"问题[^2]，通过模运算实现了队列空间的循环利用，提高了空间利用率。 ## 输出结果示例 ``` 第一次入队（0~9）： 出队，即入队元素有： 0 1 2 3 4 5 6 7 8 9 第二次入队（0,3,6,9）： 出队，即入队元素有： 0 3 6 9 ```
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

超翔之逸

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值