C基础06_指针

已于 2022-10-27 20:50:48 修改
阅读量415 收藏
点赞数
分类专栏： # C语言 文章标签： c语言
于 2022-08-04 00:07:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41865866/article/details/126091070
版权

1 指针的定义和使用

指针的定义和使用：
1、指针：是一种数据类型 指针变量也是一种变量
2、指针格式： 对应的数据类型 * p：指针类型变量 用来指向一个变量的地址
3、通过指针修改变量的值
 *p = 200；
4、指针类型在内存中的大小 : 在32位操作系统中所有指针大小都是4个字节大小 
  打印指针内存大小格式： sizeof(int *) || sizeof(p)
5、内存按照 unsignned int 为每个一个内存分配编号
6、讲解：
①定义变量 int a =10;  数值10 存在内存 为a开辟的空间中 a的地址为0xff00 
②定义指针 int * p = &a  指针变量p 在内存中存贮的是 a的地址 0xff00，指针变量p 在内存中的大小在32位系统中都是4个字节大小
③*p = 200 通过操作指针变量p 所存储的 a的地址 来改变a的值
④指针p 有一个自己的内存地址 指针p地址 与 定义变量a的地址 0xff00不同

在这里插入图片描述

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

int main()
{
	int a = 10;
	a = 20;
	int b = 100;
	//指针是一种数据类型  p是指针类型变量 用来指向一个变量的地址
	int* p = &a;
	p = &b;
	printf("%p\n", &b);
	printf("%X\n", p);

	//通过指针修改变量的值
	*p = 100;
	printf("%d\n", b);
	printf("%d\n", *p);

	//sizeof()指针类型在内存中的大小  在32位操作系统中所有指针大小为4个字节大小
	//在64位操作系统中所有指针大小为8个字节大小
	printf("%d\n", sizeof(p));
	printf("int*=%d\n", sizeof(int*));
	printf("char*=%d\n", sizeof(char*));
	printf("short*=%d\n", sizeof(short*));
	printf("long*=%d\n", sizeof(long*));
	printf("float*=%d\n", sizeof(float*));
	printf("double*=%d\n", sizeof(double*));

	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

指针类型在内存中大小：
在这里插入图片描述指针指向变量和赋值操作：
在这里插入图片描述

2 野指针，空指针和万能指针

野指针、空指针与 万能指针
1、野指针：野指针是指向一个未知的内存空间，可能在读写的时候出现错误。
 0-255都是系统保留的 不可以读，不可以写
2、空指针 没有指向任何的地址（其指向0的地址）
空制指针就是指向内存编号为零的空间，操作该内存空间会报错，一般情况空指针用于程序条件判断
3、万能指针：void *  指针可以指向任意变量的内存空间

指针指向变量和赋值操作
在这里插入图片描述

野指针：

int main()
{
	int a = 10;
	int* p = &a;
	//指向内存编号为100的内存地址
	//0-255都是系统保留的 不可以读，但是不可以写
	//野指针是指向一个未知的内存空间，可能在读写的时候出现错误
	p = 100;
	*p = 100;

	system("pause");
	return EXIT_SUCCESS;
}

会报错

空指针：

int main()
{
	int* p;
	//空指针就是指向内存编号为0的空间，操作该内存空间会报错，一般情况空指针用于程序条件判断
	p = NULL;
	*p = 100;
	printf("%d\n", *p);
	if(p != NULL)
	{
		//free();
	}
}

会报错

万能指针：

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

int main01()
{
	int a = 10;//4
	// int* p=&a;
	void* p = &a; //万能指针
	*(int*)p = 100; //使用时得制定类型
	printf("%d\n", a);
	printf("%d\n", *(int*)p);
	system("pause");
	return EXIT_SUCCESS;
}

int main()
{
	int arr[10] = { 0 };
	void* p = arr;
	*(int*)p = 100;//arr[0]; arr[1]
	*((int*)p + 1) = 200;//arr[1]
	for (int i = 0; i < 10; i++)
	{
		printf("%d\n", arr[i]);
	}
	return 0;
}

在这里插入图片描述

3 const修饰指针

const修饰指针
1.通过指针修改const修饰的常量
const int a = 10;
int *p += &a;
*p = 100;
a =100;
可以通过1级指针修改一个常量的值

2.const修饰指针类型 int * 不能改变指针变量指向的内存地址的值 但是可以改变指针指向的地址 
const int *p = &a
p=&b
*p = 100
可以改变指针指向的地址

3.const修饰指针变量    能改变指针指向地址的值，但不能改变指针指向的地址

int * const p = &a;
*p = 100;
 p=&b
可以修改指针指向地址的值

4.const修饰指针类型修饰指针变量  不能改变指针指向的的值 也不能改变指针指向的地址 
const int * const *p = &a;
*p =100;
p = &b;

const修饰指针类型
在这里插入图片描述
const修饰指针变量
在这里插入图片描述
1.通过指针修改const修饰的常量

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define LVL 100


int main()
{
	//这种方式不安全，可以通过指针修改
	//1.通过指针修改const修饰的常量
	const int a = 10;
	printf("%d\n", a);
	int* p = &a;
	*p = 100;
	printf("%d\n", a);
	printf("%d\n", *p);
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述
2.如果const修饰int* 不能改变指针变量指向的内存地址的值，但是可以改变指针指向的地址

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define LVL 100

int main()
{
	int a = 10;
	int b = 20;
	const int* p;
	p = &a;
	//但是可以改变指针指向的地址
	p = &b;
	//如果const修饰int* 不能改变指针变量指向的内存地址的值
	//* p = 100;
	printf("%d\n", *p);

	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述
3.const修饰指针变量，能改变指针变量指向地址的值，但不能改变指针指向的地址

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define LVL 100

int main()
{
	int a = 10;
	int b = 20;
	int* const p = &a;
	//但不能改变指针指向的地址
	//p = &b;
	//const修饰指针变量，能改变指针变量指向地址的值
	* p = 100;
	printf("%d\n", *p);

	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述
4.4.const 修饰指针类型，也修饰指针变量，不能改变指针变量指向的内存地址的值，也不能改变指针指向的地址

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define LVL 100

int main()
{
	int a = 10;
	int b = 20;
	//4.const 修饰指针类型，也修饰指针变量，不能改变指针变量指向的内存地址的值，也不能改变指针指向的地址
	const int* const p = &a;
	//p = &b;
	//*p = 100;
	printf("%d\n", *p);

	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述
结论：
在这里插入图片描述

4 指针和数组，指针运算

指针和数组、指针运算：
1、数组名是数组的首地址，这是一个常量
2、指向数组的指针 
  格式int arr [10] = { 0 } ;  
      int * p = arr;
  当操作指针的时候 间接操作了数组 arr[i] = p[i];
3、指针的降级操作 ,取当前地址的值：p[5]、*p 
4、对指向数组的指针进行加减操作，可能会导致数组下标越界 。
5、相同的类型的指针相减  结果是两个指针相差的长度
区别：数组名通过sizeof可以求出数组大小，指针只包含数组的首地址信息

指针和数组关系
在这里插入图片描述
1.指向数组的指针，当操作指针的时候，间接操作了数组
2.指针的降级操作

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

int main()
{
	//数组名是数组的首地址，这是一个常量
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10};
	//printf("%p\n", arr);
	//printf("%p\n", &arr[0]);
	//p = arr; [数据类型 *] 变量名
	//1.指向数组的指针，当操作指针的时候，间接操作了数组
	int* p = arr;

	//2.指针的降级操作
	//*p = 100;
	//*(p + 1) = 100;
	//p[5] = 300;
	//*(p + 5) = 300;
	//*p==arr[0]
	//p = p+1;
	*(p + 1) = 200;

	p++;
	*p = 200;
	p[2] = 300;
	arr[2] = 400;
	for (int i = 0; i < 10; i++)
	{
		//*(p+i) //内存变了1*sizeof(int)
		printf("%d\n", arr[i]);
		//printf("%d\n", p[i]);//0 9
		//printf("%d\n", *(p+i));
	}
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述
3.数组下标越界

p[10]=300

指针的运算

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

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = arr;
	p++;
	*p = 100;//{ 1,100,3,4,5,6,7,8,9,10 };
	p = 100;//野指针
	*p = 100;//非法操作野指针内存
	p = &arr[9];
	*p = 100;//{ 1,100,3,4,5,6,7,8,9,100 };
	p--;
	*p = 20;//{ 1,100,3,4,5,6,7,8,20,100 };
	p = &arr[0];
	*p += 100;//{ 101,100,3,4,5,6,7,8,20,100 };

	for (int i = 0; i < 10; i++)
	{
		printf("%d\n", arr[i]);
	}
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

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

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = arr;
	p++;
	*p = 100;//{ 1,100,3,4,5,6,7,8,9,10 };
	//p = 100;//野指针
	//*p = 100;//非法操作野指针内存
	p = &arr[9];
	*p = 100;//{ 1,100,3,4,5,6,7,8,9,100 };
	p--;
	*p = 20;//{ 1,100,3,4,5,6,7,8,20,100 };
	p = &arr[0];
	*p += 100;//{ 101,100,3,4,5,6,7,8,20,100 };
	printf("%d\n", p);
	p += 100;
	printf("%d\n", p);
	int len = p - arr;
	printf("len = %d\n", len);
	for (int i = 0; i < 10; i++)
	{
		printf("%d\n", arr[i]);
	}
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

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

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

	for (p = arr; p < &arr[10]; p++)
	{
		//printf("%d\n", *p);
		//printf("%d\n", p);
		printf("%d\n", p[0]);
	}
	return 0;
}

在这里插入图片描述

5 指针冒泡排序

数组名和指针的区别：
数组名通过sizeof可以求出数组大小，指针只包含数组的首地址信息

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

int main()
{
	int arr[10] = { 4,9,10,3,5,7,1,8,2,6 };
	//数组名和指针的区别，数组名通过sizeof可以求出数组大小，指针只包含数组的首地址信息
	int* p = arr;
	printf("%d\n", sizeof(arr));
	printf("%d\n", sizeof(p));
	return 0;
}

在这里插入图片描述
冒泡排序：

#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 - 1 - i; 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 };
	//数组名和指针的区别，数组名通过sizeof可以求出数组大小，指针只包含数组的首地址信息
	int* p = arr;
	int len = sizeof(arr)/sizeof(arr[0]);
	//printf("%d\n", sizeof(arr));
	//printf("%d\n", sizeof(p));
	bubble(p, len);
	for (int i = 0; i < 10; i++)
	{
		printf("%d\n", arr[i]);
	}
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

6 实现strchr函数

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


char* mystrchr1(char* arr, char ch)  //arr1的值不可改变
{
	int i = 0;
	while (arr[i] != '\0')
	{
		if (arr[i] == ch)
		{
			return &arr[i];
		}
		i++;
	}
	return NULL;
}

char* mystrchr2(const char* arr, char ch)  //arr1的值不可改变
{
	char* p = arr;
	while (*p != '\0')
	{
		if (*p == ch)
		{
			return p;
		}
		p++;
	}
	return NULL;
}

int main()
{
	char arr1[] = "hello world";
	char ch = 'o';
	//char* p = strchr(arr1, ch);
	//char* p = mystrchr1(arr1, ch);
	char* p = mystrchr1(arr1, ch);
	printf("%s\n", p);
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

7 字符串反转

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

void rec(char* arr)
{
	int len = strlen(arr);
	//printf("%d\n",len);
	//字符串的首地址
	char* p1 = arr;
	//字符串最后一个有效字符的地址
	char* p2 = &arr[len - 1];
	while (p1 < p2)
	{
		char temp = *p1;
		*p1 = *p2;
		*p2 = temp;
		p1++;
		p2--;
	}
}
int main()
{
	char arr[] = "hello world";//dlrow olleh
	rec(arr);
	printf("%s\n", arr);

	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

8 指针数组

指针数组
1、存储char *类型的地址数组
 char * arr[] ={"hello","world","niao","baobei"};
2、指针数组，它是数组，数组的每个元素都是指针类型。

指针数组基本概念:

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

int main()
{
	int a = 10;
	int b = 20;
	int c = 30;
	int* arr[] = { &a,&b,&c };
	//arr[0]==&a;
	//arr[1]==&b;
	*arr[0] = 100;

	printf("%d\n", a);
	printf("%d\n", b);
	printf("%d\n", c);
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述
存储char *类型的地址数组:

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

int main()
{
	//存储char *类型的地址数组
	char* arr[] = { "hello","world","nihao","baobei" };
	int len = strlen(arr[1]);
	printf("%d\n", len);
	printf("%c\n", *arr[0]);
	printf("%c\n", *(arr[0]+1));
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

9 多级指针

多级指针：
1、如果二级指针前面加一个* 代表一级指针的值
2、二级指针前面加** 代表指针指向一级指针指向地址的值，加*降维度
3、如果n级指针在前面加n个*就是指针指向一级指针指向地址的值

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

int main()
{
	int a = 10;
	int* p = &a;
	int** pp = &p;
	//二级指针，前面加*代表一级指针的值
	*pp = &a;
	//二级指针前面加**,代表指针指向一级指针指向地址的值
	**pp = 20;
	system("pause");
	return EXIT_SUCCESS;
}

多级指针推论：
在这里插入图片描述

10 指针和函数

1.值传递不会改变实参的值

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

void tab(int a, int b)
{
	int temp = a;
	a = b;
	b = temp;
	printf("%d    %d\n", a, b);
}

int main()
{
	int a = 10;
	int b = 20;
	tab(a, b);
	printf("%d    %d\n", a, b);
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述
函数值传递的执行过程：
在这里插入图片描述
2.地址传递可以改变实参的值

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

void tab(int* a, int* b)
{
	int temp = *a;
	*a = *b;
	*b = temp;
	printf("%d    %d\n", *a, *b);
}

int main()
{
	int a = 10;
	int b = 20;
	tab(&a, &b);
	printf("%d    %d\n", a, b);
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述
地址传递：
在这里插入图片描述

11 指针作为函数参数


1、地址传递可以改变实参的值
2、函数参数中如果有数组 都会  转化为指针 sizeof(数据类型) 所以求出来的值不作为循环的值使用
3、两种方式可以求出字符串长度 \0 （图1）
①int len = strlen(arr)
②int i = 0;

1.函数参数中如有数组，都会转化为指针，sizeof(int*)=4，所以求出来的值不能作为数组的循环条件存在，所以要传长度

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

void print(int arr[10])
{
	// 函数参数中如有数组，都会转化为指针，sizeof(int*)=4，所以求出来的值不能作为数组的循环条件存在
	for (int i = 0; i < sizeof(arr); i++)
	{
		printf("%d\n", arr[i]);
	}
}

int main()
{
	int arr[] = { 1,2,3,4,6,0,7,8,9,10 };
	print(arr);
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

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

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

int main()
{
	int arr[] = { 1,2,3,4,6,0,7,8,9,10 };
	print(arr,sizeof(arr)/sizeof(arr[0]));
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述
2.字符串数组传递

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

//1.数组作为函数参数可以退化为指针
//2.在传递数组时需要加上数组的个数
void print(char * arr)
{
	//两种方式可以求出字符串长度  \0
	int len = strlen(arr);
	int i = 0;
	while (arr[i] != '\0')
	{
		i++;
	}
}

int main()
{
	//char arr[] = "hello world";
	//print(arr);
	char arr[] = { 'h','e','l','l','o' }; //这个要传递个数
	system("pause");
	return EXIT_SUCCESS;
}

12 函数的返回值是指针

字符数组，创建位置在栈区

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

char* test()
{
	//字符数组，创建位置在栈区
	char arr[] = "hello world";
	return arr;
}
int main()
{
	char* p = test();
	printf("%p\n", p);
	printf("%s\n", p);
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述
字符串常量，会在程序运行时，创建在常量区

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

char* test()
{
	//字符数组，创建位置在栈区
	//char arr[] = "hello world";
	//字符串常量，会在程序运行时，创建在常量区，不能被修改
	char* arr = "hello world";
	return arr;
}
int main()
{
	char* p = test();
	printf("%p\n", p);
	printf("%s\n", p);
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

13 实现strstr函数

#include<stdlib.h>

/*
1.两个匹配的字符串，必须完全匹配，匹配个数=字符串长度
2.如果匹配一个字符串，需要记录别匹配字符串地址
3.如果匹配一个半成功，回到记录被匹配字符串地址+1
4.如果匹配的被匹配字符串的结尾，匹配个数不等于字符串长度
*/

char* mystrstr(char* dest, char* src)
{
	int i = 0;
	int j = 0;
	//匹配个数
	int count = 0;
	int len = strlen(src);
	char* p=NULL;
	while (dest[i] != '\0')
	{
		while (dest[i] == src[j])
		{
			if (!count)
				//如果匹配成功一个字符,需要记录位置
				p = &dest[i];
			count++;
			i++;
			j++;
			//匹配成功
			if (count == len)
			{
				return p;
			}
		}
		//发生改变的值  i  j  count  p
		if (count < len)
		{
			i = i - count;
			j = 0;
			count = 0;
		}
		i++;
	}
	return NULL;
}
int main()
{
	//char* p = strstr("hello world", "llo");
	char* p = mystrstr("hello world", "llo");
	printf("%s\n", p);
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述
strstr优化

#include<stdlib.h>

/*
1.两个匹配的字符串，必须完全匹配，匹配个数=字符串长度
2.如果匹配一个字符串，需要记录别匹配字符串地址
3.如果匹配一个半成功，回到记录被匹配字符串地址+1
4.如果匹配的被匹配字符串的结尾，匹配个数不等于字符串长度
*/

char* mystrstr(char* dest, char* src)
{
	char* p=NULL;
	char* temp = src;
	while (*dest)
	{
		p = dest;
		while (*dest == *temp)
		{
			dest++;
			temp++;
		}
		if (!*temp)
			return p;
		else
			temp = src;
		dest = p;
		dest++;
	}
	return NULL;
}
int main()
{
	//char* p = strstr("hello world", "llo");
	char* p = mystrstr("hello world", "llo");
	printf("%s\n", p);
	system("pause");
	return EXIT_SUCCESS;
}

14 指针和字符串

6、指针和字符串
①*p改变字符串中的值
②字符串与指针在程序中打印的值：
③字符串常量 是一个常量的数组 可以读取字符和字符串  但是不能修改

字符串数组：

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

int main()
{
	char arr[] = "hello world"; //栈区
	char* p;
	p = arr;
	*p = 'A';//arr[0] p[0]
	p++;
	*p = 'B';//arr[1] p[1]
	printf("%s\n", p);
	printf("%s\n", arr);
	printf("%d\n", sizeof(arr)); //12 包含\0
	printf("%d\n", strlen(arr)); //11
	printf("%d\n", sizeof(p)); //4
	printf("%d\n", strlen(p)); //10
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述
字符串常量：

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

int main()
{
	char* arr = "hello world";//常量区
	printf("%s\n", arr);
	printf("%c\n", arr[0]);
	char* p = arr;
	printf("%p\n", p);
	//字符串常量是一个常量的数组，可以读取字符或者字符串，但不能修改
	//p[0] = 'A';//报错
	//*p = 'A';//报错
	p = "hello world";
	//p[0] = 'A';//报错
	//*p = 'A';//报错
	printf("%p\n", p);
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

15 实现strcat函数

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

void mystrcat(char* arr, char* s1)
{
	//while (*arr)
	//	arr++;
	//while (*arr++ = *s1++);
	while (*arr)
		arr++;
	while (*s1)
	{
		*arr = *s1;
		arr++;
		s1++;
	}
	*arr = '\0';
}

int main()
{
	char arr[100] = "hello";
	char* s1 = "world";
	mystrcat(arr, s1);
	printf("%s\n", arr);
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

16 字符串排序

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

void bubble(char** arr,int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - i - 1; j++)
		{
			//比对两个字符串的首字母
			/*
			  int *p =&a;
			  *(p+j)
			 */
			//1.指针判断
			/*
			if (**(arr+j) < **(arr +j+1))
			{
				char* temp = *(arr+j);
				*(arr+j) = *(arr +j+ 1);
				*(arr+j + 1) = temp;
			}
			*/
			//2.数组判断
			/*
			if (*arr[j]<*arr[j+1])
			{
				char* temp = arr[j];
				arr[j] = arr[j+1];
				arr[j + 1] = temp;
			}
			*/
			//3.混合判断
			if (arr[j][0] < arr[j + 1][0])
			{
				char* temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

int main()
{
	char* arr[] = { "dstudent","btree","cnew","abee" };
	bubble(arr, 4);
	for (int i = 0; i < 4; i++)
	{
		printf("%s\n", arr[i]);
	}
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

好奇养活小猫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 虚基类表指针字节对齐模型
chengonghao的博客
06-15 3317
关于虚基类表指针/虚函数表指针这些类里面的“隐藏成员”在结构里面是如何进行字节对齐的这个问题困惑了我48个小时。虽然网上也有很多关于虚继承、虚函数表、虚基类等内存布局的一些文章，但是基本上谈的都是大致的布局，什么地方有什么，按照什么顺序来排放等这些泛泛而谈的东西，好像都没有把字节对齐方面考虑进去的文章，或许他们都没有考虑到一些复杂层次的类继承关系，从而字节对齐的问题也没有成为问题，也自然而然地会被
c指针基础
wuwndj的博客
12-13 1337
一、指针、指针变量的引用 1.一个变量的地址称为该变量的指针 例如，地址2000是变量 i 的指针 2.一个变量专门用来存放另一变量的地址（即指针），则它称为指针变量 3.定义指针变量： 类型名 * 指针变量名 指针变量的值是地址 二、指针变量作函数参数 三、通过指针引用数组 四、通过指针引用多维数组 五、通过指针引用字符串 六、动态内存分配 ...
指针（一）
qq_37369726的博客
12-06 543
1.什么是指针 指针就是地址。 先说内存分配地址：以一个字节为单位分配地址，每一个地址都有一个标号，也可以说叫指针。 地址也需要存储，32为编译器用32位存储地址，64位编译器用64位存储地址。 房间有大有小，所以c语言也给变量划分类型，有int 4字节，char 1字节。这里要说的是，int类型它包含4个地址标号，而不是一个，取地址&取得是首地址，因为int类型4个字节固定，所以也能够知...
C语言字节对齐问题详解
godleading的专栏
10-31 1371
C语言字节对齐
数组名退化作一个元素的指针，降级
chenchen_fcj程序猿的博客
07-09 471
写一篇博客方便自己复习。参考网址：https://www.cnblogs.com/sanghai/archive/2013/11/01/3402258.html数组名退化为指针：在使用数组时，大多数情况下数组都会自动转换为指向第一个元素的指针，例如： int a[10]; // array of 10 ints int* p = a; // convert a to pointer to firs...
【C语言】指针大小与指针类型无关？
hd2720641894的博客
09-29 150
电脑操作系统分为32位和64位，其中32位操作系统有32根地址线，因此它的地址是一个由32个二进制位组成的数字，最多有2^32中情况，也就是32位操作系统最多有2^32个内存地址；同理，64位操作系统最多有2^64个内存地址，可以访问的内存更大，运行速率也就随之更快。电脑中的内存被划分为许多个小的内存单元，每个单元都有一个二进制编号，这个编号就是这个内存单元的地址，也就是指针。32位操作系统的内存地址编号有32个二进制位（比特位），因此32位操作系统的指针大小为4个（32/8）字节；
C语言基础 --指针
Edward的专栏
02-01 572
大一时学过数据结构，感觉掌握的不是很好，决定在这个寒假补补。 指针 & 取地址操作 * 去引用操作 下面贴段代码： #include int main(){ double i=1.0; double i1=2.0; double *p; //32位运行平台下指针本身所占的空间是4个字节，用来存放指向数据的地址 printf("size of p is %d\n",sizeof(p))
c语言相关书籍_C语言_资料书籍_指针_
09-29
郝斌老师是国内知名的编程教育专家，他的教学大纲通常涵盖了C语言的基础语法、控制结构、函数、数组、指针等关键主题。通过这份大纲，学习者可以系统地了解C语言的学习路径，同时了解每个主题的重点和难点，为后续...
C.zip_c_指针
09-24
一、指针基础 1. 指针变量：指针变量是用来存储内存地址的特殊变量。声明一个指针变量时，需要指定它将指向的数据类型，如`int *p;`表示`p`是一个指向整型数据的指针。 2. 取地址符（&）：用于获取变量的内存地址，...
指针源代码_C语言_includingtir_
09-29
以上就是C语言中关于指针的一些基础知识点，这些知识在`CalcRadius.c`和`指针源代码`中可能会有所体现，具体实现可能涉及计算圆的半径、处理数据结构或其他复杂的操作。通过实践这些代码，初学者可以更好地理解和...
C_language_view_test.rar_C 面试题_C语言面试题_c语言 项目 报告_面试_面试题
09-14
C语言是计算机编程的基础，广泛应用于系统开发、嵌入式编程、软件开发等多个领域。面试时，对于C语言的掌握程度往往成为评估程序员能力的重要标准。以下是对标题、描述及标签所涉及知识点的详细说明： 1. **基本...
课程思政-C语言程序设计-指针基础
03-25
课程思政-C语言程序设计-指针基础
复盘：下面的这两个随机数组“a”和“b”：请问数组c=a+b的维度是多少
weixin_46838716的博客
07-12 540
1）b（列向量）复制3次，以便它可以和A的每一列相加，所以：c.shape = (2, 3) 3）笔试求AC，可以不考虑空间复杂度，但是面试既要考虑时间复杂度最优，也要考虑空间复杂度最优。
c语言的32位指针加1是多少,c语言中，指针加1的情况.指针变量详细介绍
weixin_28778267的博客
05-19 1202
指针是一个特殊的变量，它里面存储的数值被解释成为内存里的一个地址。要搞清一个指针需要搞清指针的四方面的内容：指针的类型，指针所指向的类型，指针的值或者叫指针所指向的内存区，还有指针本身所占据的内存区。让我们分别说明。先声明几个指针放着做例子：例一：(1)int *ptr;(2)char *ptr;(3)int **ptr;(4)int(*ptr)[3];(5)int*(*ptr)[4];指针的...
指针与内存对齐
terry_wjp的专栏
08-22 2138
指针做强制变换时，需要注意内存是否对齐，否则会
C语言指针方面的理解：（更新中）位对齐
tanglanting12的专栏
09-26 857
int a=5;  26     int *q;  27     q=&a;  28 cout 指针指向的地址就是指针指向的东西的首地址 &q==&a;
针对32位系统和64为系统下sizeof（）的大小,包括指针的长度
热门推荐
lxie0的博客
09-05 1万+
长度 32位系统 64位系统 指针 4字节 8字节 int 4 8 char 1 1 double 8 16 情形一： #include"stdafx.h" #include<iostream> #include<stdio.h> #include<math.h> using ...
系统32位指针变量为4字节系统16位指针变量2个字节
时光漫走
10-05 1647
定义 int **a[3][4], 则变量占有的内存空间为：16位系统24.32位系统中是48. PS：公式：3*4*sizeof（int **）
UEFI——使用标准C库
最新发布
qq_44807736的博客
09-06 492
C标准库是ANSL C标准为C语言定义的标准库。C标准库包含15个头文件：assert.h ctype.h error.h float.h limits.h locale.h math.h setjmp.h signal.h stdarg.h stddef.h stdio.h stdlib.h string.h time.h。使用C标准库开发的应用程序有很强的可移植性，标准库为上层应用程序屏蔽了底层平台的差异，使得这些程序可以在任意平台上通过编译。当我们决定在工程中使用标准库函数的时候，有两种方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值