首页 > 其他分享 >数组遇上指针

数组遇上指针

时间：2023-03-01 19:45:08浏览次数：41  
标签：10 arr int char 数组 printf sizeof 遇上 指针 

//一个8位的空间，如果表示无符号数0-255 unsigned char  0~2^8 -1
//如果用来表示有符号数 -128~127       char           -2^7 ~2^7-1
//对其范围的探求，不止于，自字节数
#if 0
1字节 char
0 - 255 unsigned char         0~2^8 - 1
-128~127         char           -2^7 ~2^7-1

2字节 short
0	-65535                    0 ~2^16 -1
-32768 -32767		          -2^15~ 2^15-1

4个字节 int
#endif

输入输出

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{ 
	int a = 1;
	printf("%2d\n", 123456);//当实际宽度大于域宽时，按实际输出
	printf("%2d\n", a);
	printf("%10d\n", 10);
	printf("%-10d###\n", 10); //左对齐
	printf("%15d\n", 123456); //默认空格 
	printf("%015d\n", 123456); //0 右对齐时用0补齐  默认空格
}
/*
123456
 1
        10
10        ###
         123456
000000000123456
*/

数组

//相同的数据类型构造，就构成了数组
//不同的数据类型，就构成了结构体

//对于构造类型来说，
//定义 大小 初始化 访问

//未初始化
//满初始化
//部分初始化，其余部分清零；初始化清零
//越界初始化 禁止 c语言对于越界是不检的 灵活

凡是构造类型，在定义的时候初始化，不可以先定义再初始化的方式赋值

凡是基本数据类型，既可以在定义时初始化，也可以先定义，再赋值

int main(int argc, char* argv[]) {
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10};
	for (int i = 0; i < 10; i++) {
		printf("arr[%d] = %d\n",i,arr[i]);
	}
	printf("sizeof(arr)=%d\n", sizeof(arr));
	printf("sizeof(arr[0])=%d", sizeof(arr[0]));
}

int main(int argc, char* argv[]) {
	int arr[10] = {0};
	for (int i = 0; i < 10; i++) {
		arr[i] = rand() % 50; //[0,50)
	}
	for (int i = 0; i < 10;i++) {
		printf("arr[%d] = %d\n",i,arr[i]);
	}
}

一维数组的存储

一维数组，在内存中是一段连续的存储区域

#include <stdio.h>


int main(int argc, char* argv[]) {
	int arr[10];
	for (int i = 0; i < 10; i++) {
		printf("&arr[%d]= %p\n",i,&arr[i]);
	}
}
/*
&arr[0]= 000000231DF2FCC8
&arr[1]= 000000231DF2FCCC
&arr[2]= 000000231DF2FCD0
&arr[3]= 000000231DF2FCD4
&arr[4]= 000000231DF2FCD8
&arr[5]= 000000231DF2FCDC
&arr[6]= 000000231DF2FCE0
&arr[7]= 000000231DF2FCE4
&arr[8]= 000000231DF2FCE8
&arr[9]= 000000231DF2FCEC
*/

数组的三要素

数组的声明，已经把数组访问不的三要素，均已表示出来了，三要素就是，起始位置、移步刻度、终止位置。

#include <stdio.h>


int main(int argc, char* argv[]) {
	int maxValue;
	int minValue;
	int arr[10] = {100,2,7,4,5,6,7,8,9,10};
	maxValue = arr[0];
	minValue = arr[0];
	for (int i = 0; i < 10; i++) {

		if (maxValue < arr[i]) {
			maxValue = arr[i];
		}
		if (minValue > arr[i]) {
			minValue = arr[i];
		}
	}
	printf("int arr max = %d;min = %d", maxValue, minValue);
	return 0;
}

#include <stdio.h>
int main(void)
{
//	int arr[] = { 1,2,3,4,56 };
//	int[4] arr[3];
//	int arr[3][4]; // int[4] arr[3];T arr[3]
	int arr[][3] = { 1,2,4,5,6,7,9,10,11,12 };
	for (int i = 0; i < sizeof(arr) / sizeof(int[3]); i++) {
		for (int j = 0; j < 3; j++) {
			printf("%3d", arr[i][j]);
		}
		putchar(10);
	}
	printf("sizeof(arr)=%d\n",sizeof(arr));
	return 0;
}

三要素

#include <stdio.h>
int main(void)
{
	int arr[4];
	printf("%p\n", arr); //起始地址
	printf("&arr[0] = %p\n", &arr[0]);
	printf("arr = %p arr + 1 = %p\n",arr,arr + 1); //步长

	return 0;
}

#include <stdio.h>
int main()
{
	int arr[3][4]; //int[4] arr[3]  T arr[3]

	printf("arr =  %p \n", arr); //起始地址
	printf("&arr[0] = %p\n", &arr[0]);
	printf("arr = %p arr + 1 = %p\n", arr, arr + 1); //步长 16 一个一维数组的大小

	printf("arr[0] = %p\n",arr[0]); //内嵌一维数组的起始地址
	printf("&arr[0][0] =%p \n",& arr[0][0]); //内嵌一维数组首元素的地址
	printf("arr[0] + 1 = %p\n",arr[0] + 1);//内嵌一维数组的步长 4 

	printf("sizeof(arr[0]) = %d sizeof(int[4])= %d\n",sizeof(arr[0]), sizeof(int[4])); //16
	printf("sizeof(arr) = %d\n", sizeof(arr)); //48
    	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 4; j++) {
			arr[i][j] = rand() % 100;
	}
	}
	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 4; j++) {
			printf("%3d", arr[i][j]);
		}
		putchar(10);
	}
	return 0;
}
/*
arr =  000000869E33FBB8
&arr[0] = 000000869E33FBB8
arr = 000000869E33FBB8 arr + 1 = 000000869E33FBC8
arr[0] = 000000869E33FBB8
&arr[0][0] =000000869E33FBB8
arr[0] + 1 = 000000869E33FBBC
sizeof(arr[0]) = 16 sizeof(int[4])= 16
sizeof(arr) = 48
 41 67 34  0
 69 24 78 58
 62 64  5 45
*/

//一维数组的数组名，是一级指针

//二维数组的数组名是，数组指针

arr = &arr[0]
*arr = arr[0] 

#include <stdio.h>
int main()
{
	int arr[3][4];
	printf("arr = %p\n", arr);
	printf("&arr[0] = %p\n", &arr[0]);
	printf("arr+1 = %p\n", arr + 1);
	// & reference * dereferrence
	printf("arr[0] = %p\n",arr[0]);
	printf("&arr[0][0] = %p\n", &arr[0][0]);
	printf("arr[0] + 1 = %p\n", arr[0] + 1);

	printf("arr = %p\n", arr );
	printf("arr + 1= %p\n", arr + 1);
	//arr = &arr[0]
	printf("*arr = %p\n", *arr);//arr[0]
	printf("*arr + 1 = %p\n", *arr + 1);
	return 0;
}
/*
arr = 000000B6EE10FC28
&arr[0] = 000000B6EE10FC28
arr+1 = 000000B6EE10FC38
arr[0] = 000000B6EE10FC28
&arr[0][0] = 000000B6EE10FC28
arr[0] + 1 = 000000B6EE10FC2C
arr = 000000B6EE10FC28
arr + 1= 000000B6EE10FC38
*arr = 000000B6EE10FC28
*arr + 1 = 000000B6EE10FC2C
*/

二维数组的数组名是，数组指针

#include <stdio.h>
int main()
{
	int arr[3][4] = { {2,2,2,0} ,{1,2,0,3}, {4,4,4,4} };
	printf("arr = %p\n", arr);
	printf("&arr[0] = %p\n", &arr[0]);
	printf("arr+1 = %p\n", arr + 1);
	// & reference * dereferrence
	printf("arr[0] = %p\n",arr[0]);
	printf("&arr[0][0] = %p\n", &arr[0][0]);
	printf("arr[0] + 1 = %p\n", arr[0] + 1);

	printf("arr = %p\n", arr );
	printf("arr + 1= %p\n", arr + 1);
	//arr = &arr[0]
	printf("*arr = %p\n", *arr);//arr[0]
	printf("*arr + 1 = %p\n", *arr + 1);

	//想访问第2行的第二个元素  arr+1 => a[1]  *(arr + 1) = &a[1]   
//(*(arr + 1) + 1) => &a[1][1]
	printf("a[1][1] = %d\n", *(*(arr + 1) + 1));
    	                         //&arr[0] + 1  =  &a[1] =
	//想访问第2行的第二个元素  arr+1 => &a[1]  *(arr + 1) = &a[1]   
//(*(arr + 1) + 1) => &a[1][1] 
	return 0;
}
/*
arr = 000000CC63CFF518
&arr[0] = 000000CC63CFF518
arr+1 = 000000CC63CFF528
arr[0] = 000000CC63CFF518
&arr[0][0] = 000000CC63CFF518
arr[0] + 1 = 000000CC63CFF51C
arr = 000000CC63CFF518
arr + 1= 000000CC63CFF528
*arr = 000000CC63CFF518
*arr + 1 = 000000CC63CFF51C
a[1][1] = 2
*/

int main() {
    char *p, q;//声明了一个指针变量，一个int类型的变量
    printf("sizeof(p) = %d sizeof(q) = %d\n",sizeof(p),sizeof (q));

}

指针的运算

#include <stdio.h>
//指针 类型(步长） 地址（物理数据）
int main() {
    int data = 0x12345678;
    char *pc = &data;
    printf("%x\n", *pc);
    int *p = (int *) 0x0001;
    int pData = 0x0001;
    printf("p = %#x  p+1 = %#x\n", p, p + 1);
    printf("pData = %#x  pData+1 = %#x\n", pData, pData + 1);

    printf("(double*)p = %#x  (double*)p+1 = %#x\n", (double*)p, (double*)p + 1);
    printf("(int)pData = %#x  (int)pData+1 = %#x\n", (int)pData, (int)pData + 1);

    printf("%x\n",++p);
    printf("%x\n",++pData);

    int arr[10];
    int pHead = (int)&arr[0];int pTail = (int)&arr[9];
    printf("%d\n",pHead - pTail); //-36
//    int arr[10];
//    int *pHead = &arr[0];int *pTail = &arr[9];
//    printf("%d\n",pHead - pTail); //-9
}
/*
pData = 0x1  pData+1 = 0x2
(double*)p = 0x1  (double*)p+1 = 0x9
(int)pData = 0x1  (int)pData+1 = 0x2
5
2
-36
*/

判断是否是回文数

int main() {
 char name[5] = {'m', 'a', 'd', 'a', 'm'};
 char *ph = &name[0];
 char *pt = &name[4];
 int flag = 1;
 while(ph < pt){
     if (*ph == *pt ){
         ph ++;
         pt --;
     }
     else{
         break;
         flag = 0;
     }
 }
 if (flag == 1){
     printf("yes");
 }
 else{
     printf("非回文");
 }
 return 0;
}

#include <stdio.h>
int main() {
//数组访问  偏移法
    int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
//    for (int i = 0; i < 10; i++) {
//        printf("%d\n", *(arr + i)); // arr = &arr[0]   *arr = arr[0]
//    }
    //数组名是指针常量，方可唯一的表示一个数组。数组名是数组的唯一标识符。
    printf("arr = %p\n", arr);
    printf("arr + 1 = %p\n", arr + 1);

    printf("&arr[0] = %p\n", &arr[0]);
    printf("&arr[0]+1=%p", &arr[0] + 1);
    //&arr[0] ==arr 在一定程度上。 int *
    //一维数组名，可以赋给一级指针
    int *pa = &arr[0];
    int *pb = arr;
    //数组名能干的指针就能干，数组名不能干的 指针也能干
    return 0;
}
/*
arr = 00000073a7dff970
arr + 1 = 00000073a7dff974
&arr[0] = 00000073a7dff970
&arr[0]+1=00000073a7dff974
*/

#include <stdio.h>
int main() {
    int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int *pa = arr;
    for (int i = 0; i < 10; i++) {
        printf("%d\n", *(pa + i));
    }
    for (int i = 0; i < 10; i++) {
        printf("%d\n", pa[i]);
    }
    for (int i = 0; i <10 ; ++i) {
        printf("%d\n",*pa++);
    }
    return 0;
}

int *pa = arr;
for (int i = 0; i < 10; ++i) {
 printf("%d\n", *(pa++));
}

小结：

  1. 数组名是一个常量，不允许重新赋值
  2. 指针变量是一个变量，可以重新赋值
  3. p+i和a+i均表示数组元素a[i]的地址，均指向a[i]
  4. //*(p+i）和 *(a+i)均表示p+i和a+i所指向的内容a[i]
  5. *p++ = *(p++) 先得到 *p 再使 p=p+1
  6. (*p)++表示将p所指向的元素的值加一，等价于a[i]++
  7. 指向数组元素的指针也可以表示成数组的形式，即允许指针变量带下标，*(p+i) 也可以表示成p[i]

二维数组的访问方式

下标法

​ 数组元素的表示方法是：数组名[行] [列]

本质偏移法

​ a a[0] a[0] [0]

int a[3] [4]; a = &a[0]

*a = a[0]

&a[0] = a

a[i] <==> *(a+i)

a[i] [j] <==>* (*(a+i)+j)

a是数组首元素的地址，所以a的值和&a[0]的值相同，另一方面，a[0]本身是包含4个整数的数组，因此，a[0]的值同其首元素的地址&a[0] [0]相同。简单的讲，a[0]是一个整数大小对象的地址，而a是4个整数大小对象的地址。因为整数和4个整数组成的数组开始于同一个地址，因此a和a[0]的值是相同的。

a 所指的对象大小是4个int，而a[0]所指的对象大小一个int 所以a+1 和 a[0] + 1

推论(仅助理解)

二维数组名解引用，降维为一维数组名 *(a+1) a[1]

一维数组名，对其引用，升级为二维数组名 &a[1] <>(a+1)

&引用和*解引用互为逆向关系

#include <stdio.h>
int main() {
    int arr[3][4] = {1, 2, 3, 4,
                     10, 20, 30, 40,
                     100, 200, 300, 400};
    for (int i = 2; i >= 0; i--) {
        for (int j = 3; j >= 0; j--) {
            printf("arr[%d][%d] = %#x\n", i, j, &arr[i][j]);
        }
        printf("=======\n");
    }
    // arr[2][1]  ==> *(*(arr + 2)+1)
    printf("%d\n", *(*(arr + 2) + 1));
    printf("arr = %#p arr+1 = %#x arr+2 = %#x \n", arr, arr + 1, arr + 2);
    printf("arr[0] = %#p arr[0]+1 = %#x arr[0]+2 = %#x \n", arr[0], arr[0] + 1, arr[0] + 2);
    printf("*arr = %#p *arr+1 = %#x *arr+2 = %#x \n", *arr, *arr + 1, *arr + 2);
    printf("&arr[0] = %#p &arr[0]+1 = %#x &arr[0]+2 = %#x \n", &arr[0], &arr[0] + 1, &arr[0] + 2);

    printf("arr[0][0] = %d arr[0][1] = %d arr[0][2] = %d \n", *arr[0], *(arr[0] + 1), *(arr[0] + 2));
    printf("arr[0][0] = %d arr[0][1] = %d arr[0][2] = %d \n", **arr, *(*arr + 1), *(*arr + 2));

    //arr   arr[0]
    // *arr  --> arr[0]
    //arr[0]  arr
    // &arr[0] --> arr
    return 0;
}
/*
arr[2][3] = 0x1e9ffa1c
arr[2][2] = 0x1e9ffa18
arr[2][1] = 0x1e9ffa14
arr[2][0] = 0x1e9ffa10
=======
arr[1][3] = 0x1e9ffa0c
arr[1][2] = 0x1e9ffa08
arr[1][1] = 0x1e9ffa04
arr[1][0] = 0x1e9ffa00
=======
arr[0][3] = 0x1e9ff9fc
arr[0][2] = 0x1e9ff9f8
arr[0][1] = 0x1e9ff9f4
arr[0][0] = 0x1e9ff9f0
=======
200
arr = 0x481e9ff9f0 arr+1 = 0x1e9ffa00 arr+2 = 0x1e9ffa10
arr[0] = 0x481e9ff9f0 arr[0]+1 = 0x1e9ff9f4 arr[0]+2 = 0x1e9ff9f8
*arr = 0x481e9ff9f0 *arr+1 = 0x1e9ff9f4 *arr+2 = 0x1e9ff9f8
&arr[0] = 0x481e9ff9f0 &arr[0]+1 = 0x1e9ffa00 &arr[0]+2 = 0x1e9ffa10
arr[0][0] = 1 arr[0][1] = 2 arr[0][2] = 3
arr[0][0] = 1 arr[0][1] = 2 arr[0][2] = 3

Process finished with exit code 0

*/

二维数组的本质是，数组指针 二维数组名 跟二级指针没有毛关系

#include <stdio.h>
int main()
{
	char* p = "abcdef";//"abcdef"是一个常量字符串
	//*p = 'W'; 错误的 segmentation fault 段错误
	printf("%s\n",p);
	printf("%c\n", *p);
	printf("%s\n",p); //%s 指针p 会打印整个字符串
	return 0;

}

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "acbdef";
	char* p1 = "abcdef";
	char* p2 = "abcdef";
	if (arr1 == arr2)
	{
		printf("hehe\n");
	}
	else
	{
		printf("haha\n");
	}
}
//输出haha

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "acbdef";
	char* p1 = "abcdef";
	char* p2 = "acbdef";
	if (p1 == p2)
	{
		printf("hehe\n");
	}
	else
	{
		printf("haha\n");
	}
}
//输出hehe

指针数组 是数组 用来存放指针的

int main()
{
	int arr[10] = { 0 };//整型数组
	char ch[5] = { 0 };//字符数组
	int* parr[4];//存放整型指针的数组 -指针数组
	char* pch[5];//存放字符指针的数组 -指针数组
	return 0;
}

int main()
{
	int a = 10;
	int b = 20;
	int c = 30;
	int d = 40;
	int* arr[4] = { &a,&b,&c,&d };
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		printf("%d ",*(arr[i]));
	}
	return 0;
}
//输出 10 20 30 40

指针加一并不是单纯的加一，而是指向下一个元素的地址，看指针的类型，例如int 则是郏4个字节

int main()
{
	int arr1[] = {1,2,3,4,5};
	int arr2[] = {2,3,4,5,6};
	int arr3[] = {3,4,5,6,7};
	int* parr[] = {arr1, arr2,arr3};
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 5; j++)
		{
			printf("%d ", * (parr[i] + j));
		}
		printf("\n");
	}
	return 0;
}

数组指针

//数组指针 - 指针
int main()
{
	//int* p = NULL;//整型指针 -指向整型的指针 - 可以存放整型的地址
	//char* pc = NULL;//pc是字符指针 -指向字符的指针 - 可以存放字符的地址
	//数组指针 - 指向数组的指针 - 可以存放数组的地址
	//int arr[10] = { 0 };
	// arr - 首元素地址
	//&arr[0]- 首元素地址
	//&arr - 数组的地址
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int (*p)[] = &arr;//数组的地址要存起来
	printf("%d", (*p)[0]); //(*p) 相当于 arr
}

int main()
{
	char* arr[5];
	char* (*pa)[5] = &arr;
	return 0;
}

数组指针的使用

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int (*pa)[10] = &arr;
	for (int i = 0; i < 10; i++)
	{
		//printf("%d ",(* pa)[i]);
		printf("%d ", *(*pa + i));// *pa数组首元素的地址 + i 第i个元素的地址  然后解引用
	}
	return 0;
}

//参数是数组的方式
void print1(int arr[3][5],int x,int y)
{
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 5; j++)
		{
			//printf("%d ", (*(arr))[i] + j);
			printf("%d ", arr[i][j]); //理解成二维数组中 一维数组的 数组名
		}
		printf("\n");
	}
}
//参数是指针的形式
void print2(int (*p)[5],int x,int y)
{
	for (int i = 0; i < x; i++)
	{
		for (int j = 0; j < y; j++)
		{
			//printf("%d ", *(*(p + i) + j));
			printf("%d ", (*(p + i))[j]);
		}
		printf("\n");
	}
}
int main()
{
	int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
	print1(arr,3,5);//arr - 数组名 - 首元素地址  看成一维数组 就是{1,2,3,4,5}这个数组的地址
	print2(arr, 3, 5);
	return 0;
}
/*
1 2 3 4 5
2 3 4 5 6
3 4 5 6 7
1 2 3 4 5
2 3 4 5 6
3 4 5 6 7
*/

int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int i = 0;
int* p = arr;
for (int i = 0; i < 10; i++)
{
	printf("%d ", p[i]);
	//printf("%d ", *(p + i));
	//printf("%d ", *(arr + i));
	//printf("%d ", arr[i]);  //arr[i] == *(arr+i) == *(p+i) ==p[i]
}
return 0;

**arr[i] == (arr+i) == (p+i) ==p[i]

改写

void print2(int (*p)[5],int x,int y)
{
	for (int i = 0; i < x; i++)
	{
		for (int j = 0; j < y; j++)
		{
			//printf("%d ", *(*(p + i) + j));
			//printf("%d ",*(p[i]+j))
			printf("%d ", p[i][j]);
			//printf("%d ", (*(p + i))[j]);		
			
		}
		printf("\n");
	}
}
int main()
{
	int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
	print2(arr, 3, 5);
	return 0;
}

指针Pointer

认识内存

线性内存

内存的最小单位b 内存的最小编址单元B，内存中每个字节都对应一个地址，通过地址才能找到每个字节。

#include <stdio.h>
int main(int argc, char* argv[]) {
	int arr[3][4] = { 1,2,3 };
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 4; j++) {
			printf("%p\n",&arr[i][j]);
		}
		putchar(10); //输出一个ascii码值是10的字符 即回车换行
	}
	return 0;
}
/*
00000050F78FF7F8
00000050F78FF7FC
00000050F78FF800
00000050F78FF804

00000050F78FF808
00000050F78FF80C
00000050F78FF810
00000050F78FF814

00000050F78FF818
00000050F78FF81C
00000050F78FF820
00000050F78FF824*/

#include <stdio.h>
int main(int argc, char* argv[]) {
	//除了char占一个字节，占一个地址
	// 其他类型包含多个字节，也就是拥有多个地址。
	//当我们变量取地址的时候 拿到的是哪个字节的地址？ 低字节的地址
	char a; short b; int c; double d;
	printf("%p\n", &a); printf("%#x\n", &a);
	printf("%p\n", &b); printf("%#x\n", &b);
	printf("%p\n", &c); printf("%#x\n", &c);
	printf("%p\n", &d); printf("%#x\n", &d);

	printf("sizeof(a) = %d\n",sizeof(&a));
	printf("sizeof(b) = %d\n", sizeof(&b));
	printf("sizeof(c) = %d\n", sizeof(&c));
	printf("sizeof(d) = %d\n", sizeof(&d));
	return 0;
}
/*
000000A16E14F5D4
0x6e14f5d4
000000A16E14F5F4
0x6e14f5f4
000000A16E14F614
0x6e14f614
000000A16E14F638
0x6e14f638
sizeof(a) = 8
sizeof(b) = 8
sizeof(c) = 8
sizeof(d) = 8*/

指针常量

指针常量 ->指针变量

对变量取地址，取出的地址，就是一个指针，且常量指针

& * reference derefer 取地址 取内容

常量指针不是一个单纯的地址，而是有类型的

指针的本质，是一个有类型的地址，类型决定了，从这个地址开始的寻址能力。

#include <stdio.h>
int main(int argc, char* argv[]) {

	//指针常量 ->指针变量
	//对变量取地址，取出的地址，就是一个指针，且常量指针
	//& * reference derefer 取地址 取内容
	char a = 1; short b = 2; int c = 10; double d = 123.45;
	printf("%p ", &a); printf("%#x\n", &a);
	printf("%p ", &b); printf("%#x\n", &b);
	printf("%p ", &c); printf("%#x\n", &c);
	printf("%p ", &d); printf("%#x\n", &d);
	printf("%d\n",*(&a));
	printf("%d\n",*(&b));
	printf("%d\n",*(&c));
	printf("%f\n",*(&d));
    printf("%d\n", *((char*) 0x8a53fca4));
	printf("%d\n", *((short*) 0x8a53fcc4));
	printf("%d\n", *((int*) 0x8a53fce4));
	printf("%f\n", *((double*) 0x8a53fd08));
	return 0;
}
&a 0x8a53fca4 (char*) 0x8a53fca4
&b 0x8a53fcc4 (short*) 0x8a53fcc4
&c 0x8a53fce4 (int*) 0x8a53fce4
&d 0x8a53fd08 (double *)0x8a53fd08

小端序

12
34
56
78 
#include <stdio.h>
int main(int argc, char* argv[]) {

	int data = 0x12345678;
	printf("%p\n",&data);
	printf("%#x\n",*(&data));
	//printf("%x\n",*((char*) 0000009CB7D2F574))

	printf("%x\n",*((char*)&data));  //对变量取地址 不仅取出了地址 还有类型
	printf("%x\n", *((short*)&data));
	printf("%x\n", *((int*)&data));
	
	return 0;
}
/*
0000009CB7D2F574
0x12345678
78
5678
12345678
指针的本质，是一个有类型的地址，类型决定了，从这个地址开始的寻址能力。
*/

指针变量

64位系统，这个位数指的是CPU 里面的通用寄存器的数据宽度为64位，也就是说一个地址占二进制位数是64，所以：sizeof(double *)sizeof(int *)sizeof(char *)64/88。

32位系统，同理，他的一个地址占32位二进制空间，sizeof(double *)sizeof(int *)sizeof(char *)32/84。

type * pointerName; *表明了本变量是指针变量，大小 此处的*仅能用于表示声明，类型决定了该指针变量中存储的地址的寻址能力。

#include <stdio.h>

//声明一个指针变量，必须要保存两种东西 一个地址数据 一个类型

//type * pointerName; *表明了本变量是指针变量，大小
int main(int argc, char* argv[]) {
	//int a = 12;
	//char c = 'c';
	//float d = 1.2f;
	char a; short b; int c; float f; double d;
	printf("%d\n",(sizeof(char *)));
	printf("%d\n", (sizeof(short *)));
	printf("%d\n", (sizeof(int *)));
	printf("%d\n", (sizeof(double *)));
	char* pa = &a;
	short* pb = &b;
	int* pc = &c;
	float* pf = &f;
	double* pd = &d;

	printf("%f\n", *pd);//printf("%f\n", *(&d));
	return 0;
}
/*
8
8
8
8
5.600000
*/

int main() {
	int data = 0x12345678;
	int* pd = &data;
	printf("%x\n", *pd);
	printf("%x\n", *((int*)pd));
	printf("%x\n", *((short*)pd));
	printf("%x\n", *((char*)pd));
	return 0;
}
/*
12345678
12345678
5678
78
*/

#include <stdio.h>


int main(int argc, char* argv[]) { 
	int arr[10];
	for (int i = 0; i < 10; i++) {
		printf("&arr[%d]= %p\n",i,&arr[i]);
		arr[i] = i;
	}
	for (int i = 0; i < 10;i++) {
		printf("%d\n", arr[i]);
		printf("%d\n", *(arr + i));
	}
	//代表构造类型/参与元素的访问，此时代表首元素的地址
	//arr 首元素地址
	printf("&arr[0] = %p\n", &arr[0]);
	printf("arr = %p\n", arr);
	printf("arr = %p\n", arr);
	printf("%d  %d\n",arr[1],1[arr]); //[]下标运算符  基址变址运算符
}
/*
&arr[8]= 0000009B60AFF808
&arr[9]= 0000009B60AFF80C
0
0
1
1
2
2
3
3
4
4
5
5
6
6
7
7
8
8
9
9
&arr[0] = 0000009B60AFF7E8
arr = 0000009B60AFF7E8
arr = 0000009B60AFF7E8
1  1
*/

标签：10,arr,int,char,数组,printf,sizeof,遇上,指针
From： https://www.cnblogs.com/hekang520/p/17169456.html

相关文章

  • 和为K的子数组
    给你一个整数数组 nums 和一个整数 k ，请你统计并返回 该数组中和为 k 的连续子数组的个数 。/***@param{number[]}nums*@param{number}k*@return{......
  • lc.977 有序数组的平方
    题目描述给你一个按非递减顺序排序的整数数组nums，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。输入：nums=[-4,-1,0,3,10]输出：[0,1,9,16,100]解释：平方后......
  • 求给定数组中所有子数组的最大和
    解题思路：$nums1=[-2,1,3,4,-19];functionmaxHe($nums1){//先定义2个变量，一个是扫描值，一直是所求的最大值。我们初始都给所求数组的第一位$scan_num=$nums1[0];......
  • 如何检查数组是否为空或存在？
    第一次加载页面时，我需要检查是否有图像image_array并加载最后一张图像。否则，我禁用预览按钮，提醒用户按下新图像按钮并创建一个空数组来放置图像；问题是一直image_arra......
  • Java的学习（冒泡排序和稀疏数组）
    1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置2.每一次比较，都会产生一个最大或者最小的数字；3.下一轮则可以减少一次排序4.依次循环，直到结束......
  • 按要求编写字符界面(算法初阶、最小值和最大值)、填充每个节点的下一个右侧节点指针(
    按要求编写字符界面(算法初阶、最小值和最大值)编写一个字符界面的JavaApplication程序，接受用户输入的10个整数，并输出这10个整数的最大值和最小值。importjava.util.Sc......
  • 【读书笔记&个人心得】第7章：数组与切片
    数组与切片这章我们开始剖析集合，它是可以包含大量条目(item)的数据结构，例如数组、切片和map。从这看到Go明显受到Python的影响。数组有特定的用处，但是却有一些呆......
  • js-- 数组中取最大值的三种写法
    js数组取最大值方法有哪些Math.max()letarr=[3,1,2,4,6,0,19];console.log(Math.max(...arr))//19functionmathGetMax(arr){returnMath.max.apply(null......
  • C语言 指针参数 示例代码
    指针参数的DEMO#include<stdio.h>voidhex_printf(char*buf,intbuf_len){inti=0;if(NULL==buf){return;}printf("leni......
  • 代码随想录训练营day 3|59.螺旋矩阵II 加 数组总结篇
    59.螺旋矩阵II题目链接：59.螺旋矩阵II题目描述：给定一个正整数n，生成一个包含1到n^2所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。示例:输入:3输出:[[1,......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99