指针和函数

函数形参改变实参的值

#include <stdio.h>

void swap1(int x, int y)
{
int tmp;
tmp = x;
x = y;
y = tmp;
printf("x = %d, y = %d\n", x, y);
}

void swap2(int *x, int *y)
{
int tmp;
tmp = *x;
*x = *y;
*y = tmp;
}

int main()
{
int a = 3;
int b = 5;
swap1(a, b); //值传递
printf("a = %d, b = %d\n", a, b);

a = 3;
b = 5;
swap2(&a, &b); //地址传递
printf("a2 = %d, b2 = %d\n", a, b);

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

数组名做函数参数

• 数组名做函数参数，函数的形参会退化为指针,指针的sizeof值为4或者8：
  在传递数组时需要传递数组的个数

#include <stdio.h>

//void printArrary(int a[10], int n)
//void printArrary(int a[], int n)
void printArrary(int *a, int n)
{
int i = 0;
for (i = 0; i < n; i++)
{
printf("%d, ", a[i]);
}
printf("\n");
}

int main()
{
int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int n = sizeof(a) / sizeof(a[0]);

//数组名做函数参数
printArrary(a, 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

指针做为函数的返回值

#include <stdio.h>

int a = 10;

int *getA()
{
return &a;
}


int main()
{
*( getA() ) = 111;
printf("a = %d\n", a);

return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

函数指针

• 函数指针定义方式(先定义函数类型，根据类型定义指针变量);
• 先定义函数指针类型，根据类型定义指针变量;
• 直接定义函数指针变量;

int my_func(int a,int b){
printf("ret:%d\n", a + b);
return 0;
}

//1. 先定义函数类型，通过类型定义指针
void test01(){
typedef int(FUNC_TYPE)(int, int);
FUNC_TYPE* f = my_func;
//如何调用？
(*f)(10, 20);
f(10, 20);
}

//2. 定义函数指针类型
void test02(){
typedef int(*FUNC_POINTER)(int, int);
FUNC_POINTER f = my_func;
//如何调用？
(*f)(10, 20);
f(10, 20);
}

//3. 直接定义函数指针变量
void test03(){

int(*f)(int, int) = my_func;
//如何调用？
(*f)(10, 20);
f(10, 20);
}
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

函数指针数组

• 函数指针数组，每个元素都是函数指针。

void func01(int a){
printf("func01:%d\n",a);
}
void func02(int a){
printf("func02:%d\n", a);
}
void func03(int a){
printf("func03:%d\n", a);
}

void test(){

#if 0
//定义函数指针
void(*func_array[])(int) = { func01, func02, func03 };
#else
void(*func_array[3])(int);
func_array[0] = func01;
func_array[1] = func02;
func_array[2] = func03;
#endif

for (int i = 0; i < 3; i ++){
func_array[i](10 + i);
(*func_array[i])(10 + i);
}
}
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

函数指针做函数参数(回调函数)

• 函数参数除了是普通变量，还可以是函数指针变量。

//形参为普通变量
void fun( int x ){}
//形参为函数指针变量
void fun( int(*p)(int a) ){}
函数指针变量常见的用途之一是把指针作为参数传递到其他函数，指向函数的指针也可以作为参数，以实现函数地址的传递。
//加法计算器
int plus(int a,int b){
return a + b;
}

//减法计算器
int minus(int a,int b){
return a - b;
}

//计算器
#if 0
int caculator(int a,int b,int(*func)(int,int)){
return func(a, b);
}
#else
typedef int(*FUNC_POINTER)(int, int);
int caculator(int a, int b, FUNC_POINTER func){
return func(a, b);
}
#endif
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

注意：函数指针和指针函数的区别：

• 函数指针是指向函数的指针；
• 指针函数是返回类型为指针的函数；

指针和字符串

字符指针

#include <stdio.h>

int main()
{
char str[] = "hello world";
char *p = str;
*p = 'm';
p++;
*p = 'i';
printf("%s\n", str);

p = "mike jiang";
printf("%s\n", p);

char *q = "test";
printf("%s\n", q);

return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

字符指针做函数参数

#include <stdio.h>

void mystrcat(char *dest, const char *src)
{
int len1 = 0;
int len2 = 0;
while (dest[len1])
{
len1++;
}
while (src[len2])
{
len2++;
}

int i;
for (i = 0; i < len2; i++)
{
dest[len1 + i] = src[i];
}
}

int main()
{
char dst[100] = "hello mike";
char src[] = "123456";

mystrcat(dst, src);
printf("dst = %s\n", dst);

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

• 注意
  • 字符数组创建的变量,可以修改值
  • 指针字符串创建的是常量,不能修改
    

const修饰的指针变量

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

int main(void)
{
//const修饰一个变量为只读
const int a = 10;
//a = 100; //err

//指针变量， 指针指向的内存， 2个不同概念
char buf[] = "aklgjdlsgjlkds";

//从左往右看，跳过类型，看修饰哪个字符
//如果是*， 说明指针指向的内存不能改变
//如果是指针变量，说明指针的指向不能改变，指针的值不能修改
const char *p = buf;
// 等价于上面 char const *p1 = buf;
//p[1] = '2'; //err
p = "agdlsjaglkdsajgl"; //ok

char * const p2 = buf;
p2[1] = '3';
//p2 = "salkjgldsjaglk"; //err

//p3为只读，指向不能变，指向的内存也不能变
const char * const p3 = buf;

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

指针数组做为main函数的形参

int main(int argc, char *argv[]);

• main函数是操作系统调用的，第一个参数标明argv数组的成员数量，argv数组的每个成员都是char *类型
• argv是命令行参数的字符串数组
• argc代表命令行参数的数量，程序名字本身算一个参数

#include <stdio.h>

//argc: 传参数的个数（包含可执行程序）
//argv：指针数组，指向输入的参数
int main(int argc, char *argv[])
{

//指针数组，它是数组，每个元素都是指针
char *a[] = { "aaaaaaa", "bbbbbbbbbb", "ccccccc" };
int i = 0;

printf("argc = %d\n", argc);
for (i = 0; i < argc; i++)
{
printf("%s\n", argv[i]);
}
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

项目开发常用字符串应用模型

strstr中的while和do-while模型

• 利用strstr标准库函数找出一个字符串中substr出现的个数。

while模型

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

int main(void)
{
char *p = "11abcd111122abcd333abcd3322abcd3333322qqq";
int n = 0;

while ((p = strstr(p, "abcd")) != NULL)
{
//能进来，肯定有匹配的子串
//重新设置起点位置
p = p + strlen("abcd");
n++;

if (*p == 0) //如果到结束符
{
break;
}

}

printf("n = %d\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

do-while模型

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

int main(void)
{
char *p = "11abcd111122abcd333abcd3322abcd3333322qqq";
int n = 0;

do
{
p = strstr(p, "abcd");
if (p != NULL)
{
n++; //累计个数

//重新设置查找的起点
p = p + strlen("abcd");

}
else //如果没有匹配的字符串，跳出循环
{
break;
}
} while (*p != 0); //如果没有到结尾

printf("n = %d\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

两头堵模型

• 求非空字符串元素的个数

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

int fun(char *p, int *n)
{
if (p == NULL || n == NULL)
{
return -1;
}

int begin = 0;
int end = strlen(p) - 1;

//从左边开始
//如果当前字符为空，而且没有结束
while (p[begin] == ' ' && p[begin] != 0)
{
begin++; //位置从右移动一位
}

//从右往左移动
while (p[end] == ' ' && end > 0)
{
end--; //往左移动
}

if (end == 0)
{
return -2;
}

//非空元素个数
*n = end - begin + 1;

return 0;
}

int main(void)
{
char *p = "      abcddsgadsgefg      ";
int ret = 0;
int n = 0;

ret = fun(p, &n);
if (ret != 0)
{
return ret;
}
printf("非空字符串元素个数：%d\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

字符串反转模型(逆置)

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

int inverse(char *p)
{
if (p == NULL)
{
return -1;
}
char *str = p;
int begin = 0;
int end = strlen(str) - 1;
char tmp;

while (begin < end)
{
//交换元素
tmp = str[begin];
str[begin] = str[end];
str[end] = tmp;

begin++;  //往右移动位置
end--;    //往左移动位置
}

return 0;
}

int main(void)
{
//char *str = "abcdefg"; //文件常量区，内容不允许修改
char str[] = "abcdef";

int ret = inverse(str);
if (ret != 0)
{
return ret;
}

printf("str ========== %s\n", str);
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

指针小结