C语言-学习之路-06

企业开发 2023-07-12 02:31:48 阅读次数: 0

C语言-学习之路-06

指针
内存
  • 内存：内部存储器，断电即丢失数据，如DDR、DDR2、DDR3、DDR4、SRAM等。
  • 外存：外部存储器，断电也仍然保证存储，如硬盘、ROM、光盘、U盘等。
物理存储器与存储地址空间
  • 物理存储器：实际存在的存储器芯片。例如:内存条、显卡上的RAM等。
  • 存储地址空间：对存储器编码的范围。编码：对每个物理存储单元（一个字节）分配一个号码。寻址：可以根据分配的号码找到相应的存储单元，完成数据的读写。
内存地址
  • 将内存抽象成一个很大的一维字符数组。
  • 编码就是对内存的每一个字节分配一个32位或64位的编号（与32位或者64位处理器相关）。
  • 这个内存编号我们称之为内存地址。内存中的每一个数据都会分配相应的地址：例如：char 一个字节分配一个地址空间、int 4个字节分配四个地址空间、float 8个字节分配8个地址空间等
指针和指针变量

内存中每一个字节都对应一个编号，即 ——“地址”。
如果在程序中定义了一个变量，在对程序进行编译或运行时，系统就会给这个变量分配内存单元，并确定它的内存地址。
指针的实质就是内存地址。指针就是地址，地址就是指针。
指针时内存单元的编码，指针变量是存放地址的变量。

指针变量的定义和使用
  • 指针也是一种数据类型，指针变量是一个变量。
  • 指针变量指向谁，就把谁的地址赋值给指针变量。
  • **“ * ”**操作符操作的是指针变量指向的内存空间。
#include <stdio.h>

int main()
{
    
    
	int a = 0;
	char b = 100;
	printf("%p,%p\n",&a,&b);

	int* p; // int * 整型指针，p是变量名  可以指向一个int类型变量的地址，所以也被称为指针变量
	p = &a; //将a的地址赋值给变量p，p也是一个变量，值是一个内存地址编号。
	printf("%d\n",*p); //p指向的是a的地址，*p就是a的值。

	char* p1 = &b;
	printf("%c\n",*p1);


	return 0;
}

注：& 可以取一个变量在内存中的地址。但是，不能取寄存器变量，因为寄存器变量不在内存立，而在CPU内，所以是没有地址的。

由于指针指向的是变量的地址，我们也可以通过指针间接修改变量的值！

#include <stdio.h>

int main()
{
    
    
	int a = 0;
	int b = 12;

	int *p1 = &a;
	int *p2 = &b;

	*p1 = 100;
	printf("%p\n",p1);
	printf("%d\n", *p1);
	printf("%d\n", a);

	return 0;
}

//006FFCD8
//100
//100
指针大小

可以使用sizeof()获取指针的大小，不过得到的是4（32位平台）或8（64位平台）。

	printf("%d\n", sizeof(char *));
	printf("%d\n", sizeof(int *));
	printf("%d\n", sizeof(double *));
野指针和空指针

指针变量也是变量，是变量就可以任意赋值，不要越界即可。但是，任意数值赋值给指针变量是没有意义的，因为这样的指针就成了野指针，此指针指向的区域是未知的（操作系统不允许操作此指针指向的内存区域）。所以，野指针不会直接引发错误，操作野指针指向的内存是错误的。

#include <stdio.h>

int main()
{
    
    
	int a = 100;
	int *p;

	p = a; //把a的值赋值给指针变量p，p为野指针，是没有意义的。

	p = 0x12345678; //把地址赋值给指针变量p,p为野指针，也是无意义的。
	
	*p = 1000; //错误操作。
	

	return 0;
}

那么我们就不能定义一个没有指向任何变量的指针变量吗？答案是：可以的，空指针。

int main()
{
    
    
	int * p = NULL;
	

	return 0;
}
万能指针 void *

void * 指针可以指向任意变量的内存空间：

#include <stdio.h>


int main()
{
    
    
	void * p = NULL;
	int a = 10;
	p = (void*)&a;

	*((int*)p) = 11;

	printf("%d\n", *((int*)p));
	

	return 0;
}
const修饰的指针

指针常量/常量指针

#include <stdio.h>
#include <stdlib.h>


int main()
{
    
    
	int a = 10;
	int b = 20;

	const int c = 100;  //常量
	printf("%d\n", c);

	//int * p = &c;  // 此方式，仍然可以修改常量c的值，是不安全的，不建议使用！
	//*p = 101;
	//printf("&d\n", *p);

	//常量指针
	//修饰 *，指针指向内存区域不能修改，指针指向可以改变
	const int* p1; 
	p1 = &a;
	printf("%d\n", *p1);  //10
	p1 = &b;
	printf("%d\n", *p1);  //20

	//指针常量
	//修饰p2,指针指向不能变，指针指向的内存可以修改
	int* const p2 = &a;
	//p2 = &b;
	*p2 = b;
	printf("%d\n", *p2);  //20

	

	return 0;
}
指针和数组
数组名

数组名字是数组的首元素地址，但它是一个常量：

#include <stdio.h>

int main()
{
    
    
	int a[] = {
    
    1,2,3,4,5,6};

	printf("%p\n", a);
	printf("&a[0]=%p\n", &a[0]);

	return 0;
}
指针法操作数组元素

（1）加法运算

  • 指针计算不是简单的整数相加
  • 如果是一个int * ，+1的结果是增加一个int的大小
  • 如果是一个char *， +1的结果是增加一个char的大小
#include <stdio.h>

int main()
{
    
    
	int a = 0;
	int* p = &a;
	printf("%d\n", p);
	p = p + 1;

	printf("%d\n",p);

	return 0;
}
//7600584
//7600588

通过改变指针指向操作数组元素：

#include <stdio.h>

int main()
{
    
    
	int a[] = {
    
    0,1,2,3,4,5};
	int i = 0;
	int n = sizeof(a) / sizeof(a[0]);

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


	return 0;
}

（2）减法运算

#include <stdio.h>

int main()
{
    
    
	int a[] = {
    
    0,1,2,3,4,5};
	int i = 0;
	int n = sizeof(a) / sizeof(a[0]);

	int* p = a+n-1;
	for (i = 0; i < n; i++)
	{
    
    
		printf("%d\n", *p);
		p--;
	}


	return 0;
}

#include <stdio.h>

int main()
{
    
    
	int a[] = {
    
    0,1,2,3,4,5};
	int *p1 = &a[2];
	int* p2 = &a[1];

	int n1 = p1 - p2;
	int n2 = (int)p1 - (int)p2;

	printf("%d\n", n1 ); // 1
	printf("%d\n", n2);  // 4



	return 0;
}
指针数组

指针数组，它是数组，数组的每个元素都是指针类型。

#include <stdio.h>

int main()
{
    
    
	//指针数组
	int* p[3];
	int a = 1;
	int b = 2;
	int c = 3;
	int i = 0;

	p[0] = &a;
	p[1] = &b;
	p[2] = &c;

	for (i = 0; i < 3; i++)
	{
    
    
		printf("%d\n", *(p[i]));

	}
	return 0;
}
//1
//2
//3

指针冒泡排序：

多级指针
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

void bubble(int *p,int len)
{
    
    
	for (int i = 0; i < len - 1; i++)
	{
    
    
		for (int j = 0; j < len - i - 1; j++)
		{
    
    
			//*(p+j) = p[j]
			if (p[j]>p[j+1])
			{
    
    
				int temp = p[j];
				p[j] = p[j+1];
				p[j+1] = temp;
			}
		}
	}
}

int main()
{
    
    
	int arr[10] = {
    
     4,9,10,3,5,7,1,8,2,6 };
	int* p = arr;
	int len = sizeof(arr)/sizeof(arr[0]);
	printf("%d\n",sizeof(arr));
	printf("%d\n", sizeof(p));
	
	bubble(arr, 10);

	for (int i = 0; i < len; i++)
	{
    
    
		printf("%d\n", arr[i]);
	}

	system("pause");
	return 0;
}
  • C语言允许有多级指针存在，在实际的程序中一级指针最常用，其次是二级指针。
  • 二级指针就是指向一个一级指针变量地址的指针。
  • 三级指针基本用不着，但是考试会考。
#include <stdio.h>

int main()
{
    
    
	//多级指针

	int a = 10;
	int* p = &a; //一级指针
	*p = 100;  //*p 就是a ，通过指针改变a的内容。

	int** q = &p;  // *q = p  **q = a

	int*** t = &q;  //*t = q   **t = p  ***t = a

	return 0;
}
指针和函数
函数形参改变实参的值
#include <stdio.h>

void swap01(int x, int y)
{
    
    
	int temp;
	temp = x;
	x = y;
	y = temp;

	printf("x=%d,y=%d\n",x,y);
}

void swap02(int* x, int* y)
{
    
    
	int temp;
	temp = *x;
	*x = *y;
	*y = temp;
}

int main()
{
    
    
	int a = 3;
	int b = 5;
	swap01(a,b); //值传递
	printf("a=%d,b=%d\n",a,b);

	a = 3;
	b = 5;
	swap02(&a, &b); //地址传递
	printf("a2=%d,b2=%d\n",a,b);

	return 0;
}
数组名作函数参数

数组名作函数参数，函数的形参会退化为指针：

#include <stdio.h>

void printArray(int* a, int n)
{
    
    
	int i = 0;
	for (i = 0; i < n; i++)
	{
    
    
		printf("%d\n",a[i]);
	}
}

int main()
{
    
    

	int a[] = {
    
     1,2,3,4,5,6 };
	int n = sizeof(a) / sizeof(a[0]);

	printArray(a, n);

	return 0;
}
指针作为函数的返回值
#include <stdio.h>


int a = 10;

int* getA()
{
    
    
	return &a;
}

int main()
{
    
    
	*(getA()) = 111;
	printf("a=%d\n",a);

	return 0;
}
指针和字符串
字符指针
#include <stdio.h>

int main()
{
    
    
	char str[] = "hello world";
	char* p = str;

	*p = 'm';
	p++;
	*p = 'i';
	printf("%s\n", str);
	
	const char *str1 = "mike jiang";
	printf("%s\n",str1);

	return 0;
}
实践中常用的字符串应用模型
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

//(1)利用strstr标准库函数找出一个字符串中substr出现的个数
//a）while模型
int main()
{
    
    
	const char* p = "11abcd111122abcd333abcd22abcd234234qqq";
	int n = 0;
	//strstr() 为C语言标准库函数，它的函数原型为： char *strstr(const char *str1,const char *str2)
	//其中str1为要在其中查找的字符串，str2为要查找的字符串。
	//如果str2是str1的子字符串，则函数返回str2在str1中第一次出现的位置的指针。
	//否则，函数返回NULL。
	while ((p = strstr(p, "abcd")) != NULL)
	{
    
    
		//检查到存在
		//重新设置起点位置
		p = p + strlen("abcd");
		n++;
		if (*p == 0) //如果检查到0，则到结束符
		{
    
    
			break;
		}
	}

	printf("n=%d\n", n);

	return 0;
}

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

//(1)利用strstr标准库函数找出一个字符串中substr出现的个数
//a）while模型
int main()
{
    
    
	const char* p = "11abcd111122abcd333abcd22abcd234234qqq";
	int n = 0;
	do
	{
    
    
		p = strstr(p, "abcd");
		if (p != NULL)
		{
    
    
			n++;

			p = p + strlen("abcd");
		}
		else
		{
    
    
			break;
		}
	} while (*p != 0);

	printf("n=%d\n", n);

	return 0;
}

猜你喜欢

转载自blog.csdn.net/weixin_50918736/article/details/130503081
今日推荐
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
【转】spring中对控制反转和依赖注入的理解
tms webcore 安装和使用
java程序员进阶相关书籍
SpringMVC接受请求参数、
如何保存训练好的机器学习模型
MyEclipse、Eclipse设置项目JDK的三个地方
商超行业微信小程序开发定制一般多少钱 （行业技术人员解读）
Markdown编辑器语言——30分钟入门到到精通
Linux系统下MongoDB的简单安装与基本操作
Power Strings
每日归档
更多
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022