指针笔试题

1.

2.

3.

int main()
{
    int a[4] = { 1, 2, 3, 4 };
    int *ptr1 = (int *)(&a + 1);
    int *ptr2 = (int *)((int)a + 1);
    printf( "%x,%x", ptr1[-1], *ptr2);
    return 0;
}
1
2
3
4
5
6
7
8

4.

#include <stdio.h>
int main()
{
    int a[3][2] = { (0, 1), (2, 3), (4, 5) };
    int *p;
    p = a[0];
    printf( "%d", p[0]);  //1
 return 0;
}
1
2
3
4
5
6
7
8
9

5.

int main()
{
    int a[5][5];
    int(*p)[4];
    p = a;
    printf( "%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
    return 0;
}
1
2
3
4
5
6
7
8

6.

int main()
{
    int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    int *ptr1 = (int *)(&aa + 1);
    int *ptr2 = (int *)(*(aa + 1));
    printf( "%d,%d", *(ptr1 - 1), *(ptr2 - 1));
    return 0;
}
1
2
3
4
5
6
7
8

7.

#include <stdio.h>
int main()
{
	char* a[] = { "work","at","alibaba" };
	char** pa = a;
	pa++;
	printf("%s\n", *pa);
	return 0;
}
1
2
3
4
5
6
7
8
9

8.

int main()
{
	char* c[] = { "ENTER","NEW","POINT","FIRST" };
	char** cp[] = { c + 3,c + 2,c + 1,c };
	char*** cpp = cp;
	printf("%s\n", **++cpp);
	printf("%s\n", *-- * ++cpp + 3);
	printf("%s\n", *cpp[-2] + 3);
	printf("%s\n", cpp[-1][-1] + 1);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

字符串函数

strlen

size_t strlen ( const char * str );

字符串已经 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包
含 ‘\0’ )。

参数指向的字符串必须要以 ‘\0’ 结束。
注意函数的返回值为size_t，是unsigned int.

strlen使用中的易错点

strlen 模拟实现

//1.计数器
#include <assert.h>
size_t my_strlen(const char* str)
{
	assert(str);
	size_t count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}
int main()
{
	char arr[] = "abcdef";
	size_t n=my_strlen(arr);
	printf("%u\n", n);//6
	return 0;
}

//2.指针-指针
#include <assert.h>
size_t my_strlen(const char* str)
{
	assert(str);
	char* start = str;
	size_t count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}
	char* end = str;
	return end-start;
}
int main()
{
	char arr[] = "abcdef";
	size_t n = my_strlen(arr);
	printf("%u\n", n);
	return 0;
}

//3.递归
#include <assert.h>
size_t my_strlen(const char* str)
{
	assert(str);
	if (*str != '\0')
	{
		str++;
		return (1 + my_strlen(str));
	}
	else
		return 0;
}
int main()
{
	char arr[] = "abcdef";
	size_t n = my_strlen(arr);
	printf("%u\n", n);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

strcpy

char * strcpy ( char * destination, const char * source );

Copies the C string pointed by source into the array pointed by destination, including the
terminating null character (and stopping at that point).

源字符串必须以 ‘\0’ 结束。
会将源字符串中的 ‘\0’ 拷贝到目标空间。
目标空间必须足够大，以确保能存放源字符串。
目标空间必须可变。
学会模拟实现。

int main()
{
	char name[20] = { 0 };
	name = "zhangsan";//err,name数组名是地址，地址是常量值，不能修改，不能被赋值
	printf("%s\n", name);
	return 0;
}
1
2
3
4
5
6
7

目标空间必须可变。

int main()
{
	const char* p = "abcdef";//err,常量字符串不能修改
	char arr[] = "bit";
	strcpy(p, arr);
	return 0;
}
1
2
3
4
5
6
7

指向字符串的指针不能用来修改此字符串，会出错。

这是因为：
char *p=“hello”; 等价于 const char *m=“hello”;
对于指针p,无非就是一个地址的拷贝，也就是"hello"地址的拷贝。
"hello"保存在静态的存储区，该数据不能修改。
故不能通过指针p修改数据区的值

为何char a[ ]可以修改字符串

这是因为: “hello” 保存在栈空间数组里，数组名为a, 数组名为数组的首地址。
char a[]=“hello”; 是从静态存储区(常量区)复制内容副本(即hello)到栈里给了 a[] 所以
所以a[] 本身有一个自己的 hello 副本，可以对其进行想要的合法操作，例如:改变字符串的内容。

strcpy 模拟实现

strcat

char * strcat ( char * destination, const char * source );
源字符串必须以 ‘\0’ 结束。
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改。

strcat 模拟实现

字符串自己给自己追加，如何？

不可行，因为拷贝字符串过程中’\0’被覆盖，自身的内容被破坏，缺少’\0’，陷入死循环。