C语言学习日记Day06指针与数组

最新推荐文章于 2023-06-25 17:17:45 发布
最新推荐文章于 2023-06-25 17:17:45 发布
阅读量79 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/J_bz_Redio/article/details/111310783
版权

在这里插入图片描述

#define  _CRT_SECURE_NO_WARNINGS 
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>



int main0101()
{
    //int arr[] = {1,2,3,4,5,6,7,8,'a','b','c'};//ok
	int arr[] = {1,2,3,4,5,6,7,8,'a','b','c'};
	//数组名是一个常量 不允许赋值
	//数组名是数组首元素地址
	//arr = 100; //error
	int* p = arr;
	printf("%p\n", p);
	printf("%p\n", arr);
	printf("%d\n", *p);


	for (int i = 0; i < 10; i++)
	{
		
		//printf("%d\n", arr[i]);
		//printf("%d\n", *(arr+1));//*(arr+1)  等效于  arr[1]      指针类型变量 + 1   等同于    内存地址 + sizeof（int）
		//printf("%d\n", *(arr + i));//*(arr+i)  等效于  arr[i]    指针类型变量 + 1   等同于    内存地址 + sizeof（int）
		//printf("%d\n", *(p + i));
		//printf("%d\n", p[i]);//*(arr+1)  等效于  arr[1]   等效于 p[i]    
		printf("%d\n", *p++);
	}
	printf("%p\n", p);//00D7F71C
	printf("%p\n", arr);//00D7F6F4       最终 p 与 arr相差40， 不在数组元素指针范围内了  成为了一个野指针
	int step = p - arr;//
	printf("%d\n", step);//10   两个指针的相减 得到的结果是两个指针的偏移量 为sizeof(int)   所有指针类型相减 ，得到的结果都是int类型
	return 0; 
}

int main0102()
{
	
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	
	int* p = arr;//p是指向数组的指针  
	//p[i]   ==  *p(i+1)
	//区别在于    p是变量  arr是长量
	//p是一个指针，4个字节大小      arr是一个数组 ，40个字节大小
	
	return 0;
}
//数组作为函数参数 会退化为指针，丢失数组的精度 sizeof（arr） =4 而不是40了   相当于传过来的int arr[] 变为了 int* arr
void maopaopao(int arr[], int len)
{
	int temp;
	for (int i = 0; i < len; i++)
	{
		for (int j = 0; j < len-1-i; j++)
		{在这里插入图片描述

			if (arr[j] > arr[j + 1])
			{
				temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
			/*if (*(arr+j) > *(arr+j+1))
			{
				temp = *(arr + j);
				*(arr + j) = *(arr + j + 1);
				*(arr + j + 1) = temp;
			}*/  //不建议这种写法  麻烦
		}
	}
}
int main()
{
 
	int arr[] = { 9,1,5,3,8,10,2,7,4 ,20};

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

在这里插入图片描述

#define  _CRT_SECURE_NO_WARNINGS 
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>

void My_Strcopy(char* dest, char* str)
{
	int i = 0;
	//while (str[i] != '\0')
	//while (str[i] != 0)//说明是真的值才可以进循环那就等效于如下
	while (str[i])
	{
		dest[i] = str[i];
		i++;
	}
	dest[i] = 0;
}

void My_Strcopy01(char* dest, char* str)  
{
	int i = 0;
	while (*(str + i))
	{
		*(dest + i) = *(str + i);
		i++;
	}
	*(dest + i) = 0;
}

void My_Strcopy02(char* dest, char* str)
{
	while (*str)
	{
		*dest = *str;
		dest++;
		str++;
	}
	*dest = 0;
}

void My_Strcopy03(char* dest, char* str)
{
	while (*dest++ = *str++);
}
int main0201()
{
	char str[] = "hello world";
	char dest[100];
	//My_Strcopy(dest, str);
	My_Strcopy01(dest, str);
	printf("%s\n", dest);
	return 0;
}


int main0202()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	//char* p;
	int* p = arr;
	//arr[-1]//数组下标越界
	p = &arr[3];
	//p--;//指针加减运算和指针类型有关    
	//p--;
	//p--;


    //内存地址相差是12/ sizeof（int） = 偏移量
	//int step = p - arr;//结果为3


	//指针操作数组允许下标是负数
	printf("%d\n", p[-2]);//等效于*(p-2)


	printf("%p\n", p);
	printf("%p\n", arr);
	printf("%d\n", p-arr);
	
	
	return 0; 
}

int main0203()
{
	//指针和运算符的操作
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = arr;


	//p = p + arr;//error
	//p = p * arr;//error
	//p = p * 4;//error
	//p = p / arr;//error
	//p = p % 4;//error

	//指针不允许，乘除，取余，指针加指针，允许加偏移，允许减偏移，允许减野指针但没意义
	if (p > arr)
	{
		printf("真\n");
	}
	

		if (p && arr)
		{
			print("真");
		}
	
	printf("%s\n", dest);
	return 0;
}

在这里插入图片描述

在这里插入图片描述

#define  _CRT_SECURE_NO_WARNINGS 
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>


int main0301()
{
	//定义数组 数据类型 数据名[元素个数] = ｛值1，值2，值3｝
	//int* arr[3];//定义指针数组
	int a = 10; 
	int b = 20;
	int c = 30;
	int *arr[3] = { &a,&b,&c };
	for (int i = 0; i < sizeof(arr)/ sizeof(arr[0]); i++)
	{
		printf("%d\n", *arr[i]);
	}
	printf("指针数组大小：%d\n", sizeof(arr));
	printf("指针元素大小：%d\n", sizeof(arr[0]));
	return 0;
}


int main0303()
{
	//
	//指针数组里面元素存储的都是指针
	int a[] = { 1,2,3 };
	int b[] = { 4,5,6 };
	int c[] = { 7,8,9 };
	int* arr[3] = { a,b,c };  //指针数组是一个特殊的二维数组模型   相当于一个二级指针模型
	//指针数组对应于二级指针//指针数组对应于二级指针//指针数组对应于二级指针//指针数组对应于二级指针
	
	//指针数组核二级指针建立关系
	int** p = arr; 


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

	printf("%p\n", arr);//arr是指针数组首地址
	printf("%p\n", &arr[0]);
	printf("%p\n", arr[0]);
	printf("%p\n", a);
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		for (int j = 0; j < 3; j++)
		{
			//二维数组形式打印
			//printf("%d", arr[i][j]);
			
			//printf("%d", *(arr[i]+j));//形式二 

			printf("%d", *(*(arr+i)+j));//形式三
		}
		puts(" ");
	}
	printf("指针数组大小：%d\n", sizeof(arr));
	printf("指针元素大小：%d\n", sizeof(arr[0]));
	return 0;
}

在这里插入图片描述

#define  _CRT_SECURE_NO_WARNINGS 
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>


int main0401()
{
	
	int a[] = { 1,2,3 };
	int b[] = { 4,5,6 };
	int c[] = { 7,8,9 };
	int* arr[3] = { a,b,c };  //指针数组是一个特殊的二维数组模型   相当于一个二级指针模型
	//指针数组对应于二级指针//指针数组对应于二级指针//指针数组对应于二级指针//指针数组对应于二级指针

	//指针数组核二级指针建立关系
	int** p = arr;

	printf("%d\n", **p);//  相当于 arr[0][0]  以及 a[0]
	//二级指针偏移量相当于跳过了一个一维数组
	printf("%d\n", **(p+1));//----->4
	//一级指针偏移量相当于跳过了一个元素 
	printf("%d\n", *(*p + 1)); //arr[0][1]--->2

	printf("%d\n", *(*(p + 1)+1)); //arr[1][1]----->5

	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		for (int j = 0; j < 3; j++)
		{
			//二维数组形式打印
			//printf("%d", p[i][j]);

			//printf("%d", *(p[i]+j));//形式二 

			printf("%d", *(*(p + i) + j));//形式三
		}
		puts(" ");
	}

	return 0;
}

int main0402()
{

	int a = 10;
	int b = 20;
	int* p = &a;
	int** pp = &p;
	int*** ppp = &pp;

	//*ppp==pp==&p
	//**ppp==*pp==p==&a
	//***ppp==**pp==*p==&a

	//*pp = &b;//等价于  p = &b;
	**pp = 100;//等价于 a = 100；
	// *pp = 100；//error  野指针
	printf("%d\n", a);
	printf("%d\n", *p);
	printf("%d\n", **pp);
	printf("%d\n", ***ppp);
	return 0;
}

地址传递 函数形参改变实参的值

#define  _CRT_SECURE_NO_WARNINGS 
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>

//void swap(int a, int b)
//{
//	int temp = a;
//	a = b;
//	b = a;
//	return;
//}

//指针作为函数参数传递
void swap(int* a, int* b)
{
	int temp = *a;
	*a = *b;
	*b = temp;
	return;
}
int main()
{
	int a = 10;
	int b = 20;
	//值传递   形参不影响实参的值
	//swap(a, b);


	//地址传递  形参可以改变实参的值
	swap(&a, &b);
	printf("%d\n", a);
	printf("%d\n", b);

	return 0;
}

在这里插入图片描述

#define  _CRT_SECURE_NO_WARNINGS 
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>


void my_strcat1(char* a, char* b)
{
	//strlen(a);
	int i = 0;
	while (a[i] != '\0')
	{
		i++;
	}
	/*printf("%d\n", i);
	printf("%d\n", strlen(a));
	*/
	int j = 0;
	while (b[j] != '\0')
	{
		a[i + j] = b[j];
		j++;
	}
	a[i + j] = 0;
	printf("%s\n", a);
}
void my_strcat2(char* a, char* b)
{
	//strlen(a);
	int i = 0;
	while (*(a+i) != '\0')
	{
		i++;
	}
	/*printf("%d\n", i);
	printf("%d\n", strlen(a));*/

	int j = 0;
	while (*(b+j) != '\0')
	{
		*(a+i + j) = *(b+j);
		j++;
	}
	*(a + i + j) = 0;
	printf("%s\n", a);
}


void my_strcat3(char* a, char* b)
{
	//strlen(a);
	/*while (*a)
	{
		a++;
	}*/
	/*while (*a++);
		a--;*/
	while (*a)a++;
	while (*b)
	{
		*a = *b;
		a++;
		b++;	
	}
	*a = 0;
	
}
void my_strcat4(char* a, char* b)
{
	while (*a)a++;
	while (*a++ = *b++);

}
int main()
{
	char a[100] = "hello";
	char b[] = "world";
	my_strcat4(a, b);
	//printf("%d\n", b);
	printf("%s\n", a);
	return 0;
}

字符串去空格

#define  _CRT_SECURE_NO_WARNINGS 
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>int main0601()

void remo_space1(char* a)
{
	char b[100] = { 0 };
	char* p = b;
	int i = 0;
	int j = 0;
	while (a[i])
	{
		if (a[i] != ' ')
		{
			b[j] = a[i];
			j++;
		}
		i++;
	}
	printf("%s\n", b);
	while (*a++ = *p++);
	return;
}
void remo_space2(char* a)
{
	char b[100] = {0};
	char* s = a;
	char* p = b;
	char* p1 = b;
	while (*s)
	{
		if (*s != ' ')
		{
			*p = *s;
			p++;
		}
		s++;
	}
	while (*a++ = *p1++);
}
void remo_space3(char* a)
{
	char* p = a; //遍历字符串
	char* pp = a;//记录非空格字符串
	while (*p)
	{
		if (*p != ' ')
		{
			*pp = *p;
			pp++;
		}
		p++;
	}
	*pp = 0;
}
int main()
{
	char a[] = "   h  e   l  l   o  ";
	remo_space2(a);
	printf("%s\n", a);
	return 0;
}

在这里插入图片描述

字符串查找字符

#define  _CRT_SECURE_NO_WARNINGS 
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>


char* My_Search(char* a, char b)
{
	
	while (*a)
	{
		if (*a == b)
		{
			return a;
		}
		a++;
	}
	return NULL;
}

int main()
{
	char a[] = "   h  e   l  l   o   wolrd";
	char* p = My_Search(a, 'l');
	if (p == NULL)
	{
		printf("未找到\n");
	}
	else 
	{
		printf("%s\n",p);
	}
	
	return 0;
}

字符串查找字符串

#define  _CRT_SECURE_NO_WARNINGS 
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>

char* My_Search1(char* a, char* b )
{
	char* fa = a;//记录相同字符串其实地址
	char* ra = a;//遍历源字符串指针
	char* tb = b;
	while (*ra)
	{
		fa = ra;
		while (*fa == *tb && *fa != '\0')
		{
			fa++;
			tb++;	
		}
		if (*tb == '\0')
		{
			return fa;
		}
		//回滚
		tb = b;//目标字符串更新到起始位置
		ra++;
	}
	return NULL;
}

int main()
{
	char a[] = "hello w olrd";
	char b[] = "llo";
	char* p = My_Search1(a, b);
	printf("%s\n", p);
}
J_bz_Redio
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
返回链表中间节点指针
StaticMan
03-25 5223
如果个数是奇数就返回中间节点，如果是偶数，就返回任意一个。 主要是能想到用2个指针，一个指针一次走一步，另一个指针一次走2步 #include #include typedef struct node{ int a; struct node *link; }mynode; int creat_tail(mynode *head,int
指针基础之简单的使用与指针运算
qq_42846107的博客
09-21 195
指针基础之简单的使用与指针运算 1.指针应用的方面 对于变量可以使用的地方，都可以使用指针进行处理 2.一般来说，会用到函数参数上，会对实参产生改变 3.指针运算是跳其类型的对应的字节数 int arr[10]={1,2,3,4,5,6} 4.nt *p=arr;//数组名代表数组首元素首地址 printf("pa=%p pa+3=%p",pa,pa+3); //跳过的字节数为 3*4 5.指针和数组是可以相互转换的 *(p+n)=p[n]=a[n]=n[p] *p[n]=a[n] ...
指针类型的参数和返回值
hailushijie的专栏
04-09 1892
本文来自LinuxC，一下整理为
关于C函数返回指针
发呆的程序猿
01-05 3053
你真的理解C语言函数返回类型是指针的情况吗？ 2021-01-05 14:41:15 char *test1() { char b[10]="abc"; return b; } char *test2() { static char b[10]="abc"; return b; } char *test3() { char b[10]="abc"; char *pb=b; return pb; } char *test4() { char *b="abc"; return b; } 才
C语言函数返回指针问题
仰天大笑出门去
06-23 1019
C语言函数返回指针问题 今天写代码时想用一个函数返回一个结构体指针，结果出错了，然后做一个总结。 下面是出错的示例： int *fun( ) { int a ; return &a; // 返回局部变量的地直，返回后这个变量已不存在了 } 局部变量是保存在栈中的，随着函数的结束，局部变量也被释放，当函数执行完毕后，指针指向的地址是存在的，但它指向的数据已经不在了。 总结 子函数想要返回指针，指针必须指向一个确定的地址，一般有两种 1）静态变量（全局静态或局部静态），这种变量不会随着子函数的结
C语言与单机--指针与数组
08-27
我们反复强调数组的声明过程其实是内存中分配一段连续的地址。指针是指向地址的一个变量。二者中联系吗？
详解C语言中的指针与数组的定义与使用
01-21
指针的特点 他就是内存中的一个地址 指针本身运算 指针所指向的内容是可以操作的 操作系统是如何管理内存的 栈空间 4M~8m的大小 当进入函数的时候会进行压栈数据 堆空间 4g的大小 1g是操作系统 全局变量 内存...
C语言 指针与数组的详解及区别
01-01
C语言 指针与数组的详解及对比 通俗理解数组指针和指针数组 数组指针： eg:int( *arr)[10]; 数组指针通俗理解就是这个数组作为指针，指向某一个变量。 指针数组： eg:int*arr[10]; 指针数组简言之就是存放指针的数组...
c语言编程题之双指针有序数组的平方.zip
最新发布
03-31
c语言编程题之双指针有序数组的平方
简单分析C语言中指针数组与数组指针的区别
01-20
首先来分别看一下，指针数组的一个小例子： #include #include <string> int lookup_keyword(const char*key, const char* table[], const int size) { int ret = -1; int i = 0; for(i=0; i<size; i++)...
C语言——从函数返回指针
weixin_38849487的博客
01-19 7241
函数返回指针 #include <stdio.h> int *getRandom( ) { static int r[10]; int i; for ( i = 0; i < 5; ++i) { r[i] += i; printf("%d\n", r[i] ); } return r;//返回的实际是数组r的首地址 } /* 要调用上面定义函数的主函数 */ int main () { /* 一个指向整数的指针
C语言返回指向栈Or指向堆的指针区别(四十八)
Android系统攻城狮
05-06 362
#include <stdio.h> #include <stdlib.h> #include <string.h> void oxx(char* dest) { dest = (char*)malloc(30); strcpy(dest, "content has been modied"); } void oxx2(char* dest) { strcpy(dest, ".
python指针参数,Python，如何传递参数到函数指针参数？
weixin_30851655的博客
11-26 117
I only just started learning Python and found out that I can pass a function as the parameter of another function. Now if I call foo(bar()) it will not pass as a function pointer but the return value ...
【C语言】14-返回指针的函数与指向函数的指针
James_bobo的博客
12-03 158
说明：这个C语言专题，是学习iOS开发的前奏。也为了让有面向对象语言开发经验的程序员，能够快速上手C语言。如果你还没有编程经验，或者对C语言、iOS开发不感兴趣，请忽略 前言 前面我们花了接近3个章节学习指针，应该都感受到指针的强大了吧。指针可以根据地址直接操作内存中的数据，使用得当的话，不仅能使代码量变少，还能优化内存管理、提升程序性能。关于指针的内容还非常多，比如指针数组、指向数组的指针、指向...
C语言中堆和栈的区别以及不能返回指向局部变量的指针
心中的日月的博客
07-24 1101
C语言中堆和栈的区别 一.引言： 可执行程序在存储时（没有调到内存）分为代码区（text）、数据区（data）和未初始化数据区（bss）3个部分。 （1）代码区（text segment）。存放CPU执行的机器指令。通常，代码区是可共享的（即另外的执行程序可以调用它），因为对于频繁被执行的程序，只需要在内存中有一份代码即可。代码区通常是只读的，使其只读的原因是防止程序意外地修改它的指令。另外...
数组和指针微妙关系，你知道多少
qq_36698189的博客
03-23 289
每次学习都能比之前理解得更好一些，说到底，还是自己运用的不够多。加油加油，冲冲冲！ 数组 数组名的值是一个指针常量，也就是数组第1个元素的地址。它的类型取决于数组元素的类型：若是int类型，那么数组名的类型就是“指向int的常量指针”；若是其他类型，则数组名的类型是“指向其他类型的常量指针” 特殊：只有在两种场合下，数组名并不用指针常量来表示： 1.当数组名作为sizeof操作符，sizeof返回整个数组的长度，而不是指向数组的指针的长度。即返回整个数组所占用的字节而不是一个指针所占用的字节。 2.单目操
第二章 数组名是一个指针常量吗？
迷茫的小莱
11-24 2249
数组名是一个指针常量这种观点来源于数组名在表达式计算中与指针的结果等效性。例如下面的代码： int a[10], *p = a, *q;q = a + 1;q = p + 1; 在效果上看，a + 1与 p + 1是相同的，这很容易给人一种a就是p的假象，但，这仅仅是假象。鉴于指针常量包含了指针和常量两类概念，我们可以把这个问题分开两部分进行讨论。 一、数组名是指针
如何理解int (*(*(*pfunc)(int *))[5])(int *)；
weixin_47156484的博客
06-25 181
它表示pfunc是一个指向函数的指针，这个函数接受一个int *类型的参数，并返回一个指向数组的指针，这个数组有5个元素，每个元素都是一个指向函数的指针，这些函数都接受一个int *类型的参数，并返回一个int类型的值。// 定义一个新的类型pfunc_type，它是一个指向函数的指针，这个函数接受一个int *类型的参数，并返回一个array_ptr类型的值。// 定义一个新的类型func_ptr，它是一个指向函数的指针，这个函数接受一个int *类型的参数，并返回一个int类型的值。
C++ 快速理解数组名为何是常指针
Q_3603的博客
09-22 564
小白对数组名为何是常指针而感到疑惑？本人通过动态分配、数组指针实例带你在几分钟内重新认识
C语言指针数组与数组指针
09-22
C语言中，指针数组和数组指针是两种不同的概念。 指针数组是指一个数组中的每个元素都是一个指针。这意味着每个元素存储的是一个内存地址，可以指向其他变量或数据。指针数组的声明形式为：`类型 *数组名[数组大小]...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值