C语言指针与数组

最新推荐文章于 2023-03-02 23:21:05 发布
最新推荐文章于 2023-03-02 23:21:05 发布
阅读量1k 收藏 4
点赞数 5
分类专栏： C语言 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59969777/article/details/123698640
版权

指针操作数组

  • 指针操作一维数组
//int array[3]
//数组名: 代表了这段内存首地址  --->指针
//&array[0]
//正常操作： 直接存储数组的首地址
//直接把指针当作数组名就可以了
//非正常操作：指向其他元素开始操作数组

#include <stdio.h>
int main() 
{
	int array[3] = { 1,2,3 };
	printf("%p\n", array);
	printf("%p\n", &array[0]);
	int* p = array;
	for (int i = 0; i < 3; i++) 
	{
		//printf("%d\t", p[i]);  //--->这种方式使用不会错误
		printf("%d\t", *(p + i));
		//*(p+i) 等效p[i];
	}
	printf("\n");
	//array = array + 3;  不能修改
	//array-->&array[0]
	//array+3-->&array[3];
	for (p = array; p < array + 3; p++) 
	{
		printf("%d\t", *p);
		//*p等效p[0]  取当前地址对应内存中值
	}
	printf("\n");

	int test[3] = { 1,2,3 };
	int* pT = &test[2];
	printf("%d\n", pT[0]);   //指针操作数组，用数组用法，[0]下表不一定是第0个元素
	printf("%d\n", pT[-1]);
	printf("%d\n", pT[1]);	 //未知量  -858993460
	return 0;
}
//一级指针操作字符串
	char str[] = "ILoveyou";
	char* pstr = str + 3;
	puts(pstr);
	//[]操作等效取*运算
	putchar(pstr[0]);   //pstr[0] 等效*pstr操作，等效取当前地址下面值
	//*pstr 等效*(str+3) 等效 str[3];
	char* lastchar = str + 8;
	putchar(lastchar[0]);
	pstr = str;
	printf("\n");
	puts(pstr);
  • 指针操作二维数组
//二维数组基础知识
//数组名:指针数组的指针
//行地址:数组名[i];
//一级指针操作二维数组 (二维数组在内存连续的)
//数组指针操作二维数组
#include <stdio.h>
//void printArray2D(int p[][3], int cols, int row) 
void printArray2D(int(*p)[3], int cols, int row) 
{
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			printf("%d\t", p[i][j]);   //自己写代码这样就行，怎么方便怎么来
		}
		printf("\n");
	}
}

int main()
{
	int array[2][3] = { 1,2,3,4,5,6 };
	int* p = &array[0][0];
	//warning C4047: “=”:“int *”与“int (*)[3]”的间接级别不同
	//p = array;
	printf("%p\n", array);
	printf("%p\n", &array[0][0]);
	printf("%p\n", array[0]);

	printf("%p\n", array + 1);   //12/4=3
	printf("%p\n", p + 1);		 //4
	printf("%p\n", array[0] + 1);
	//char* pC = &array[0][0];
	//int* pI = &array[0][0];
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			printf("%d\t", *(p + j + i * 3));
			//j+i*3 把坐标转为第几个元素
			//p+n 等下偏移
		}
		printf("\n");
	}

	int(*pArray)[3] = NULL;    //括号必须要有,列数和表示的数组的列数必须相同
	//先算() ，他是一个子指针, 数组指针  指向数组的指针
	//联想整形指针,指向整数
	pArray = array;
	//直接当作数组名去名
	printf("-------------------------------\n");
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			printf("%d\t", pArray[i][j]);   //自己写代码这样就行，怎么方便怎么来
		}
		printf("\n");
	}
	printf("-------------------------------\n");
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			printf("%d\t", *(*(pArray + i) + j));
			//一维数组:p[i] 等效 *(p+i)
			//printf("%d\t", *(pArray[i] + j));
			//取* 等效数组下表运算 *(pArray+i)  (pArray+i)[0]
			//printf("%d\t", *((pArray + i)[0] + j));
			//printf("%d\t", ((pArray + i)[0] + j)[0]);
			//printf("%d\t", (pArray[i] + j)[0]);
			//看到会读就OK
		}
		printf("\n");
	}
	printf("-------------------------------\n");
	printArray2D(array, 2, 3);

	//存储多个字符串--->指针数组 多个指针变量
	//整形数组: 多个整形变量
	char* pstr[3] = { "Iloveyou","IMiss","IiIIII" };  //每一行上面字符串可以不相同，并且不浪费
	//int array[3]  array[0] array[1] array[2]
	//pstr[0] pstr[1] pstr[2]; 分别存储的是每个字符串首地址
	for (int i = 0; i < 3; i++) 
	{
		puts(pstr[i]);
	}
	//字符串二维数组也可以存储多个字符串？ 列数相同 会导致浪费，多余内存
	return 0;
}

二级指针

//int** p=NULL;
//int*** pp=NULL;
#include <stdio.h>
int main() 
{
	int a = 1;
	int* p = &a;		//一级指针变量存储的普通变量的地址
	int** pp=&p;		//二级指针变量存储一级指针变量地址
	//*地址 --->得到当前地址对应内存中的值
	printf("%d\t%d\n", *p, p[0]);
	printf("%d\t%d\n", **pp, pp[0][0]);
	int array[2][3] = { 1,2,3,4,5,6 };
	//一级指针算偏移
	//数组指针做遍历
	// warning C4047: “=”:“int **”与“int (*)[3]”的间接级别不同
	// 所有这种提醒麻烦大家当作错误处理 C++当作是错误的
	//pp = array;
	//for (int i = 0; i < 2; i++) 
	//{
	//	for (int j = 0; j < 3; j++) 
	//	{
	//		printf("%d\n", pp[i][j]);
	//	}
	//	printf("\n");
	//}
	return 0;
}

动态内存申请

  • 动态内存申请的函数
//No.1 断言
#include <assert.h>
assert(p);		//p等于 触发断点，中断程序 断言

#include <malloc.h>
//#include <stdlib.h>
//No.2 malloc  动态内存，不做初始化
void*  malloc(size_t _Size);  //size:申请内存的总字节数
//No.3 calloc  动态内存申请，会初始化为0
void*  calloc( size_t _Count,size_t _Size); //有几个数据:count,每个数据占用的字节数:size
//No.4 realloc  内存重新申请，保留原数据
void*  realloc(void*  _Block,size_t _Size); //原指针，重新申请的内存大小
//No.5 释放内存函数
void  free(void* _Block);
//__cdecl 调用准则，限定参数传参顺序(入栈顺序)--->了解一下
//_In_ 参数类型修饰 传入
//_out_ 传出参数
//size_t  unsigned int
//void* 使用前必须强制类型转换

 

#include <stdio.h>
#include <assert.h>
#include <malloc.h>
int main() 
{
	//No.1 malloc使用方式
	int* p = NULL;
	//assert(p);		//p等于 触发断点，中断程序 断言
	//1.一级指针动态申请内存成为一维数组
	p = (int*)malloc(sizeof(int) * 3);	// int p[3];
	assert(p);
	//等效：
	//if (p == NULL)
	//	return 0;
	//(指针类型)malloc(sizeof(指针所指向的类型)*个数);
	//int* p 
	//指针的类型: 去掉变量名: int*
	//指针所指向类型: 去掉变量名和* :int (操作的数据类型)
	for (int i = 0; i < 3; i++) 
	{
		p[i] = i;
		printf("%d\t", p[i]);
	}
	printf("\n");
	//数组经典错误
	int num = 0;
	scanf_s("%d", &num);
	//int array[num];  //错误 ，定义数组长度必须是常量 
	//C语言可以不写，建议写上，证明你学过void*
	int* pMeory = (int*)malloc(sizeof(int) * num);  //理解为一个数组
	assert(pMeory);
	//什么时候释放，当你不需要他的时候释放
	//注意点: 从那里申请的一定要从那里释放
	pMeory++;    
	//.....
	//无效堆栈指针
	pMeory--;
	free(pMeory);
	pMeory = NULL;			//防止野指针
	free(p);
	p = NULL;				//防止野指针
	//直到整个程序关掉，内存才会操作系统回收
	//No.2 calloc使用方式
	int* pc = (int*)calloc(3, sizeof(int));		//3也可以变量
	assert(pc);
	for (int i = 0; i < 3; i++) 
	{
		printf("%d\t", pc[i]);
	}
	printf("\n");
	int* pr = realloc(pc, sizeof(int) * 6);		//sizeof(int) * 6一定要比原来大小要大
	assert(pr);
	for (int i = 0; i < 6; i++) 
	{
		printf("%d\n", pr[i]);
	}
	//free(pc);
	//pc = NULL;
	free(pr);
	//free(pr);  同一段内存不能被重复释放
	pr = NULL;
	//指针充当变量只有两种途径
	//1.指向变量
	int a = 1;
	int* pa = &a;
	*pa = 1234;
	int result = (*pa) * 3;
	//2.动态内存申请
	//申请一个变量内存
	int* pM = NULL;
	pM = (int*)malloc(sizeof(int));
	assert(pM);
	*pM = 1003;
	free(pM);
	//二维数组的申请
	//二级指针
	//二级指针申请
	int** pArray = NULL;
	pArray = (int**)malloc(sizeof(int*) * 4);  //p[0] p[1]  p[2]  p[3] 
	assert(pArray);
	for (int i = 0; i < 4; i++) 
	{
		pArray[i] = (int*)malloc(sizeof(int) * 3);
		assert(pArray[i]);
	}
	for (int i = 0; i < 4; i++) 
	{
		for (int j = 0; j < 3; j++) 
		{
			pArray[i][j] = i * j;
			printf("%d\t", pArray[i][j]);
		}
		printf("\n");
	}
	//释放顺序和申请顺序相反的
	for (int i = 0; i < 3; i++) 
	{
		free(pArray[i]);
	}
	free(pArray);
	//数组指针申请维数组
	int(*p2D)[4] = NULL;
	//(指针类型)malloc(sizeof(指针所指向的类型)*个数);
	p2D = (int(*)[4])malloc(sizeof(int[4]) * 3);
	assert(p2D);
	for (int i = 0; i < 3; i++) 
	{
		for (int j = 0; j < 4; j++) 
		{
			p2D[i][j] = i * j;
			printf("%d\t", p2D[i][j]);
		}
		printf("\n");
	}
	free(p2D);
	p2D = NULL;
	return 0;
}

 

兴趣使然的Qsiri
关注
专栏目录
C语言指针和数组
m0_46321684的博客
08-14 468
1.指针和一维数组间的关系 1.数组名的特殊意义及其在访问数组元素中的工作 一旦给出数组的定义，编译系统就会为其在内存中分配固定的存储单元。相应地，数组的首地址也就确定了。数组元素在内存中是连续存放的，C语言中的数组名有特殊的含义，它代表存放数组元素的连续存储空间的首地址，即指向数组中第一个元素的指针常量。 a[o] = *(a + 0); a[1] = *(a + 1); 2.指针运算的特殊性及其在访问数组元素中的作用 指针的算术运算和关系运算常常是针对数组元素而言的。因数组在内存中是连续存放的，所以指
c语言指针与数组参数传参
拓海凌峰的博客
02-12 1748
c语言指针与数组参数传参 数组和指针的联系和应用是密不可分的，看一下数组作为函数参数是怎样的应用情况，我们看一段代码并进行分析 #include <stdio.h> int SumArray(int A[],int size) { int i,sum=0; for(i=0;i<size;i++) { sum += A[i]; } return sum; } int main(
C语言的指针和数组
马如林的IT博客
10-09 2136
  1.指针数组：一个数组里存放的都是同一个类型的指针，通常我们把他叫做指针数组。int * a[10];它里边放了１０个int * 型变量，由于它是一个数组，已经在栈区分配了１０个(int * )的空间，也就是３２位机上是４０个byte,每个空间都可以存放一个int型变量的地址，这个时候你可以为这个数组的每一个元素初始化，或者单独做个循环去初始化它。一个指针数组中的指针可以为任何同一类型，例
c语言指针和数组代码,C语言指针和数组(示例代码)
weixin_35407400的博客
05-25 372
C语言指针和数组binsearch else-ifshellsortinsertsort指针和地址指针是编程语言中的一类数据类型及其对象或变量，用来表示或存储一个内存地址，这个地址的值直接指向(points to)存在该地址的对象的值。取值运算*p返回保存在内存地址为p的内存空间中的值。取地址&p运算则返回操作数p的内存地址C语言是以传值的方式将参数值传递给被调用函数，被调用函数不能直...
C语言-指针与数组
huangjiaaaaa的博客
02-17 422
前面已经介绍了指针的基本知识，现在我们将指针与数组结合起来运用。 我们都知道，C语言中定义的数组，在内存中的地址是连续的，比如定义了一个数组 int a[5] 那么a[5]的首地址可以用a或者&a[0]表示 如果我们创建一个指针p，并将p指向数组a的首地址 int *p; p=&a[0];//数组a的首地址为&a[0]或a,将p指向数组a的首地址 那么接下来要对数组a...
【C语言】指针与数组
JL_xcly的博客
08-04 212
指针和数组 如果用一个指针指向数组 char *p; p=a;//语句1 p&a[0];//语句2 只需要用指针指向数组的第一个元素的地址即可，接下来进行指针的运算达到操作数组的目的。 当指针指向数组元素的时候，我们可以对指针变量进行加减运算，这样做的意义相当于指向距离指针所在位置向前或向后的第n个元素。 #include<stdio.h> #include<stdlib.h> #include<string.h> int main() { char
C语言 指针与数组的详解及区别
01-01
C语言 指针与数组的详解及对比 通俗理解数组指针和指针数组 数组指针： eg:int( *arr)[10]; 数组指针通俗理解就是这个数组作为指针，指向某一个变量。 指针数组： eg:int*arr[10]; 指针数组简言之就是存放指针的数组...
C语言指针与数组关系研究及应用.pdf
09-19
因此，可以使用数组指针和指针数组两种方法来处理二维数组和指针的关系。 数组指针是一种特殊的指针，它指向一个一维数组或多个维度的数组。通过定义一个数组指针，并给它赋值一个二维数组的首地址，我们能够通过...
简单分析C语言中指针数组与数组指针的区别
09-03
总之，理解和掌握C语言中的指针数组与数组指针是至关重要的，它们为程序提供了灵活性和高效性，但同时也要求程序员有严谨的思维和对内存管理的深刻理解。在编写涉及这些概念的代码时，务必小心谨慎，确保正确地管理...
c语言指针
zerokusinage的博客
07-28 592
c语言指针的基础知识点
7月27日笔记C语言基础指针0
CW_qian的博客
07-27 308
内存地址 字节：字节是内存的容量单位，英文称为 byte，一个字节有8位，即 1byte = 8bits 地址：系统为了便于区分每一个字节而对它们逐一进行的编号，称为内存地址，简称地址。 基地址 单字节数据：对于单字节数据而言，其地址就是其字节编号。 多字节数据：对于多字节数据而言，其地址是其所有字节中编号最小的那个，称为基地址。 取址符 每个变量都是一块内存，都可以通过取址符 & 获取其地址%p 例如： inta = 100; printf("整型变量 a 的地址是: %p\...
C语言指针的初始化和赋值
weixin_30678821的博客
05-28 86
1、指针的初始化 指针初始化时，“=”的右操作数必须为内存中数据的地址，不能够是变量，也不能够直接用整型地址值(可是int*p=0;除外，该语句表示指针为空)。此时，*p仅仅是表示定义的是个指针变量，并没有间接取值的意思。 比如： int a = 25; int *ptr = &a; int b[10]; int *point = b; int *p...
指针数组
liuhu7991879的博客
10-22 667
// 指针数组：元素均为指针类型的数据，称为指针数组。 // 指针数组中的每一个元素都存放一个地址，即，每一个元素都相当于一个指针变量。 // 定义一个指针数组： int *p[4];
指针数组 指针数组
liudening的博客
02-27 174
int (*p)[10];// 首先(p)，p是一个指针，int [10],是一个包含10个int的数组，该指针p指向，这个数组 // 是数组指针 int p[10]; // 写成 int p[10];比较合适，首先 [10]是一个包含 10个元素的数组，该元素类型为int,即指向整形的指针 // 是指针数组 int a[10];// 整数数组 printf("%x\n",&a);// ...
C语言指针 p[] (*(p+1)+1)
最新发布
Ander1023的博客
03-02 361
指针
关于int *p[]和int (*p)[] 的区别
mingf_13的博客
11-05 9038
int *p[] []优先级高于*，所以p先是一个数组，然后数组每个元素的类型是int*，int *p[]是一个(int *)类型的指针数组，p本质上是一个数组； int (*p)[] ()优先级高于[]，所以p先与*结合，是一个指针，指针的类型是一个int[]数组，int (*p)[]是一个数组指针，p本质上是一个指针。 #include <stdio.h> int main(void) { printf("=====int (*p)[]=====\n")...
指针数组与数组指针
无敌的专栏
05-29 639
指针数组 typename *p[n] : 定义了一个数组，数组包含了n个指针变量p[0],p[1]......p[n-1]; 例如： *p[3] = {"abc", "defg"};  sizeof(p) = 3*4 =12  (p 为数组名代表整个数组)  *p[1] = "abc"... p = &p[0]  (p+1)=&p[1] ,  符合一般数组的特性，除了数组中的元素是指
数组指针和指针数组
Helloo_jerry的博客
05-16 257
解答int (*p)[3];这里首先确定：p是一个指针，一个指向数组的指针。p = &amp;(p[0])       p是二维指针p[0] = &amp;(p[0][0]) p[0]是一维指针p[0] + 1表示在列上移动。  e.g:  p[0] + 1 = &amp;p[0][0] + 1 = &amp;p[0][1]p + 1   表示在行上移动。  e.g: p + 1 = &amp;(...
深入解析C语言指针与数组
数组的数组与多维数组是C语言中数组的两种不同形式。二维数组可以看作是一组数组的集合，每个元素本身就是一个数组。而数组的数组则是数组的数组元素不是等宽的，它们可以有不同的长度。理解这两种不同的数组结构有...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

兴趣使然的Qsiri

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

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

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

打赏作者

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

抵扣说明：

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

余额充值