C语言指针基础

#define _CRT_SECURE_NO_WARNINGS 1
#include


//编号 == 地址 == 地址在C语言中也就是指针



//int main()
//{
//	int a = 10;//变量创建的本质是：在内存上开辟空间
//	//要想内存申请4个字节的空间，存放数据10
//
//	printf("%p", &a);
//	//对于a来说拿到的是a所占4个字节的第一个字节的地址（地址较小的那个字节的地址）
//	int* ptr = &a;//ptr叫做指针变量（因为是存放指针的变量，所以叫做指针变量）
//	//编号 == 地址 == 指针
//
//
//	return 0;
//}


//
//int main()
//{
//	int a = 10;
//	int* p = &a;
//	printf("%d\n", a);
//	*p = 0;//叫做解引用操作符（间接访问操作符）
//		//*p的意思就是通过p中存放的地址，找到地址指向的空间，*p就是a
//	printf("%d\n", a);
//	
//	//*  说明p是指针变量
//	//int 说明p指向的对象是int类型的
//
//
//	//指针变量就是用来存放地址的
//	//存放在指针变量中的值，都会被当成地址使用
//
//
//
//	return 0;
//}


//#include
//#include
//int main() {
//    char str[10001] = { '\0' };//初始化字符串
//    while (gets(str))//注：这里不能使用scanf("%d",str)函数，含空格字符串会被视为多组输入。
//    {  
//        int len = strlen(str);//检测字符串长度
//        for (int i = len - 1; i >= 0; i--) //遍历字符串
//        {
//            printf("%c", str[i]);//逆序输出
//        }
//        printf("\n");
//    }
//}


//int main()
//{
//	printf("%zd\n", sizeof(char*));
//	printf("%zd\n", sizeof(short*));
//	printf("%zd\n", sizeof(int*));
//	printf("%zd\n", sizeof(double*));
//	return 0;
//}



//代码1
//int main()
//{
//	int n = 0x11223344;
//	int* pi = &n;
//	*pi = 0;
//	
// 	return 0;
//}
// 
// 
//
//int main()
//{
//	int n = 0x11223344;
//	char* pc = (char*)&n;
//	*pc = 0;
//	return 0;
//}

//int main()
//{
//	int n = 10;
//	char* pc = (char*)&n;
//	int* pi = &n;
//	printf("%p\n", &n);//006FF954
//    printf("%p\n", pc);//006FF954
//	printf("%p\n", pc + 1);//006FF955
//	printf("%p\n", pi);//006FF954
//	printf("%p\n", pi + 1);//006FF958
//	return 0;
//}
//
指针的类型决定了指针向前或者向后走多大（距离）

//int main()
//{
//	int a = 0;
//	const int m = 10;
//	a = 10;//a 是可以被修改的
//	//m = 20;    m是不能被修改的
//	printf("%d\n", a);
//	return 0;
//}

//int main()
//{
//	const int n = 0;
//	printf("n = %d\n", n);
//	int* p = &n;
//	*p = 20;//通过修改n的地址就可以修改n的值了
//	printf("n = %d\n", n);
//	return 0;
//}

//const 修饰指针变量


//const如果放在* 的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。但是指针变量本⾝的内容可变。
// const如果放在* 的右边，修饰的是指针变量本⾝，保证了指针变量的内容不能修改，但是指针指向的内容，可以通过指针改变。
//void test1()
//{
//	int n = 10;
//	int m = 20;
//	int* p = &n;
//	*p = 20;//ok?
//	p = &m; //ok?
//}
//
//void test2()
//{
//	int n = 10;
//	int m = 20;
//	const int* p = &n;//左边
//	*p = 20;//ok?
//	p = &m; //ok?
//}
//
//void test3()
//{
//	int n = 10;
//	int m = 20;
//	int* const p = &n;//右边
//	*p = 20; //ok?
//	p = &m; //ok?
//}
//
//void test4()
//{
//	int n = 10;
//	int m = 20;
//	int const* const p = &n;
//	*p = 20; //ok?
//	p = &m; //ok?
//}
//int main()
//{
//	//测试⽆const修饰的情况
//	test1();
//	//测试const放在*的左边情况
//	test2();
//	//测试const放在*的右边情况
//	test3();
//	//测试*的左右两边都有const
//	test4();
//	return 0;
//}


//int main()
//{
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
//	int* p = &arr[0];//*p==arr[0]
//	int i = 0;
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	for (i = 0; i < sz; i++)
//	{
//		//printf("%d ", *(p + i));//p+i 这⾥就是指针+整数
//		//*(p+i)==arr[0+i]
//		printf("%d ", *p);
//		p++;
//	}
//	return 0;
//}


//int my_strlen(char* s)
//{
//	char* p = s;
//	while (*p != '\0')
//		p++;
//	return p - s;
//}
//
//int main()
//{
//	printf("%d\n", my_strlen("absqc"));
//	return 0;
//}
//
// 
// 
//int main()
//{
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
//	int* p = &arr[0];
//	int i = 0;
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	while (p < arr + sz) //指针的⼤⼩⽐较
//	{
//		printf("%d ", *p);
//		p++;
//	}
//	return 0;
//}

//野指针
//1.指针未初始化
//2.指针越界访问
//3.指针指向的空间释放


//如何规避野指针
//1.指针初始化
//2.小心指针越界访问
//3.指针变量不再使⽤时，及时置NULL，指针使⽤之前检查有效性

//int main()
//{
//	int arr[10] = { 1,2,3,4,5,67,7,8,9,10 };
//	int* p = &arr[0];
//	for (i = 0; i < 10; i++)
//	{
//		*(p++) = i;
//	}
//	//此时p已经越界了，可以把p置为NULL
//	p = NULL;
//	//下次使⽤的时候，判断p不为NULL的时候再使⽤
//	//...
//	p = &arr[0];//重新让p获得地址
//	if (p != NULL) //判断
//	{
//		//...
//	}
//	return 0;
//}

//指针-指针（地址-地址）的前提是两个指针指向同一块空间	
//指针减指针得到的是指针元素之间的个数


int my_strlen(char* str)
{
	char* start = str;
	while (*str != '\0')
		str++;
	return str - start;
}

int main()
{
	char arr[] = "abcdef";
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}