C语言-学习之路-06

C语言-学习之路-06

          • 指针
            • 内存
            • 物理存储器与存储地址空间
          • 内存地址
          • 指针和指针变量
            • 指针变量的定义和使用
            • 指针大小
            • 野指针和空指针
            • 万能指针 void *
            • const修饰的指针
          • 指针和数组
            • 数组名
            • 指针法操作数组元素
            • 指针数组
          • 多级指针
          • 指针和函数
            • 函数形参改变实参的值
            • 数组名作函数参数
            • 指针作为函数的返回值
          • 指针和字符串
            • 字符指针
          • 实践中常用的字符串应用模型

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

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

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

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 

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 

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 


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

	*((int*)p) = 11;

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

	return 0;
}
const修饰的指针

指针常量/常量指针

#include 
#include 


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 

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 

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

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

	return 0;
}
//7600584
//7600588

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

#include 

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 

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 

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 

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 
#include 
#include 

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 

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 

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 

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 


int a = 10;

int* getA()
{
	return &a;
}

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

	return 0;
}
指针和字符串
字符指针
#include 

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 
#include 
#include 

//(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 
#include 
#include 

//(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;
}

你可能感兴趣的:(C/C++,c语言,学习,开发语言)