关于指针和字符串

 一、指针  

指针简单来说就是一个指向对象的东西，它指向变量的地址。

int main()
{
	int a = 10;
	int b = 20;
	int* p = &a;
	printf("%d %d",&a,&b);  //& 为取地址符号
}

它指向这个对象之后，会随机开辟一块内存，存储对象的地址。当需要使用对象时，就可以直接通过指针进行操作。

访问指针元素并操作，就需要对指针进行解引用。

//*p      ->解引用 间接访问符 访问指针所指的对象
//类型*   ->定义指针变量
//*变量名 ->解引用
//解引用后可以对数据进行操作
int main()
{
	int a, b, c;
	a = 20; b = 30;
	int* p1 = &a;
	int* p2 = &b;
	printf("%d\t%d\n", *p1, *p2);
	*p1 = *p1 + 50; *p2 = *p2 * 3;
	printf("%d\t%d\n", *p1, *p2);
	c = *p1 * *p2;
	printf("%d", c);
}

若要在主函数中使用函数中的操作，并保存下得出的结果就需用到指针定义变量。

void Operate(int a, int b, int* sum, int* mul)
	*sum = a + b;
	*mul = a * b;
}

int main()
{
	int sum, mul;
	Operate(10, 20, &sum, &mul);
	printf("%d\t%d\n", sum, mul);
}

二、指针与数组

指针也可以和数组相结合。

int main()
{
	int arr[] = { 1,2,3,4,5 };
	int* p = arr + 2;  //int* p = &arr[2];以指针形式定义数组元素并进行操作
	printf("%d\n", *(p - 1));  //*(p - 1) <=> arr[2 - 1]即对arr进行解引用并进行操作
}

int* p = NULL;	//NULL->解引用系统崩溃
//指针若指向NULL或数组内存之外的空间，则为野指针，系统会崩溃

以下是对数组与指针结合的简单应用：

//冒泡排序法
void Swap(int* a, int* b)//对a，b地址进行操作，使其交换
{
	int temp = *a;
	*a = *b;
	*b = temp;
}

void BubbleSort(int* arr,int len)
{
	assert(arr != NULL && len > 0);
	bool flag;
	for (int i = 0;i < len; i++)
	{
		flag = false;
		for (int j = 0; j < len - 1 - i; j++)
		{
			if (*(arr + j) > *(arr + j + 1)) 
			{
				Swap(arr + j, arr + j + 1);
				flag = true;
			}
		}
		if (flag != true)
			break;
	}
}

int main()
{
	int arr[] = { 10,9,8,7,6,5,4,3,2,1 };
	BubbleSort(arr, sizeof(arr) / sizeof(arr[0]));
	for (int n = 0; n < sizeof(arr) / sizeof(arr[0]); n++)
		printf("%d\t", arr[n]);
}

三、const与指针

被const修饰的元素将变为常变量，不再能被修改。

就像一把锁，锁谁谁遭殃。

const int *p = &a;  //p不可修改a的值
int* const p = &a;  //p只能指向a,不能指向其他地址
const int a = 10;   //a的值不能被修改

四、字符串

字符串是引用类型，它存储在堆空间中，栈空间存储了它的地址。

字符串并不可变，所以需要用const修饰。给字符串重新赋值则是新开辟了一块内存。

char ch[] = "hello";
const char* ch = "hello";

字符串的结束标志为'\0'字符。

字符串的长度统计有两种方法：

const char* str = "hello";
int len = sizeof(str)/sizeof(str[0])  //这种方法将连同不显示的'\0'一同统计
//以str为例输出的长度为6
int len_string = strlen(str);  //这种方法将统计首个'\0'之前的字符长度
//以str为例输出的长度为5
//若str = "he\0llo"
//则输出的长度为2
//strlen实际操作方法为下：
unsigned int my_strlen(const char* ch)
{
	assert(ch != NULL);
	unsigned int count = 0;
	while (*ch != '\0')
	{
		count++;
		ch++;
	}
	return count;
}

在函数中定义字符串：

void A(const char* ch1, const char* ch2)

五、字符串相关操作

1.比较操作：

比较两个字符串，从首个字符开始比较，若相等则进行下一位的比较，若不相等则输出结果。

int My_strcmp(const char* ch1, const char* ch2)
{
	assert(ch1 != NULL && ch2 != NULL);
	int flag = 0;
	while (*ch1 != '/0' && *ch2 != '/0')
	{
		if (*ch1 == *ch2)
		{
			ch1++;
			ch2++;
		}
		else if (*ch1 > *ch2) 
		{
			flag = 1;
			break;
		}
		else
		{
			flag = -1;
			break;
		}
	}
	return flag;
}

int main()
{
	const char* ch1 = "bba";
	const char* ch2 = "abc";
	int res = My_strcmp(ch1, ch2);
	if (res == -1)
		printf("ch1<ch2");
	else if (res == 1)
		printf("ch1>ch2");
	else
		printf("ch1=ch2");
}

2.连接操作：

连接两个字符串，则需要将一个字符串的首位拼接到另一个字符串的末尾。

char* My_strcat(char* ch1,const char* ch2)
{
	assert(ch1 != NULL && ch2 != NULL);
	int len = strlen(ch1); 
	int i = 0;
	for (i = 0; i < strlen(ch2); i++)
	{
		ch1[len + i] = ch2[i];
	}
	ch1[len + i] = '\0';  //在结束操作后标记上'\0'
	return *ch1;
}

int main()
{
	char ch1[20] = "hello ";
	const char* ch2 = "world!";
	char* result = My_strcat(ch1, ch2);
	printf("%s", result);
}

3.拷贝操作：

拷贝另一个字符串，则需要将第二个字符串的第一个值替换第一个字符串的第一个值，然后进行下一位的操作。

char* My_strcpy(char* ch1, const char* ch2)
{
	assert(ch1 != NULL && ch2 != NULL);
	while(*ch2!='\0')
	{
        *ch1=*ch2;
        ch1++;
        ch2++;
    }
    //以下为数组形式操作
	//int len = strlen(ch1);
	//int i = 0;
	//for (; i < strlen(ch2); i++)
	//{
	//	ch1[i] = ch2[i];
	//}
	ch1[i] = '\0';
	return ch1;
}

int main()
{
	char ch1[20] = "abc";
	const char* ch2 = "qwer";
	char* res = My_strcpy(ch1, ch2);
	printf("%s", res);
}