一、指针和函数：
1.栈 帧：
当函数调用时，系统会在 stack 空间上申请一块内存区域，用来供函数调用，主要存放 形参 和 局部变量（定义在函数内部）。
当函数调用结束，这块内存区域自动被释放（消失）。
这个就像是工地里请了批个工人过来干活，那么要腾出一片空间给这个工人使用，搭棚放工具啥的。如果工期结束了这片空间上的东西就销毁了
2.传值和传址：
2.1传值：
函数调用期间，实参将自己的值，拷贝一份给形参。 不会影响原来实参的值。为什么不会影响呢？因为被调用的函数中，操作的形参和实参是不同的变量，或者说，处于不同的内存空间中，大家是独立的，当然影响不了。
咱们来举个例子，有一次回老家，我一共买了两块肉。一块分给大哥家，一块自己留，这个相当于拷贝。然后大哥家当晚就煮了，他们采用红烧。难道大哥家的肉红烧了，我家也变成红烧了吗。不会的，因为这是两块肉，不会影响到。
（1）下面我就用代码，来测试，并且将实参的地址和形参的地址打了出来。
int swap(int a, int b);
int main()
{
int m ,n;
m = 32;
n = 12;
printf("m 的地址为：%p\n",&m);
printf("n 的地址为：%p\n",&n);
swap(m,n);
printf("m=%d,n=%d\n",m,n);
}
int swap(int a, int b)
{
int tmp = 0;
tmp = a;
a = b;
b = tmp;
printf("a 的地址为：%p\n",&a);
printf("b 的地址为：%p\n",&b);
return 0;
}
（2）运行结果，可以看到地址不一样，操作的值放在不同的变量里面，当然不会有影响。
2.2传址：
函数调用期间，实参将地址值，拷贝一份给形参。 相当于直接操作实参了，因为被调用的函数操作的就是实参所在的内存。【重点】
这个就相当于我叫大哥直接来我家煮我家的肉了，也是红烧的。大哥都直接来到我家操作我家的肉了，肯定会变呀。
（地址值 --》 在swap函数栈帧内部，修改了main函数栈帧内部的局部变量值）
（1）测试代码：
int swap2(int *a, int *b);
int main()
{
int m ,n;
m = 32;
n = 12;
printf("m 的地址为：%p\n",&m);
printf("n 的地址为：%p\n",&n);
//swap(m,n);
swap2(&m,&n);
printf("m=%d,n=%d\n",m,n);
}
int swap2(int *a, int *b)
{
int tmp = 0;
tmp = *a;
*a = *b;
*b = tmp;
printf("a 的地址为：%p\n",a);
printf("b 的地址为：%p\n",b);
return 0;
}
（2）测试结果，被调用函数直接操作实参，因为地址是一样的。
3.指针做函数参数：
int swap2(int *a, int *b);
int swap2(char *a, char *b);
调用时，传有效的地址值。
4.数组做函数参数：
数组传递的时候，我们通常是传递首元素的地址过去就行。因为数组是连续的，利用首元素就可以很方便地操作其他的元素。
如果是讲整个数组传递过去，这样处理很不方便，当数组很大的时候。就相当于你给一个人传信息，你告诉他我传的是100个连续的数字，相邻的数相差1。那你只需要将第一个数传给他就行了，然后说一共有多少个数，其他的让他自己写。这样就很方便，就不用你写完100个数字出来。
void BubbleSort(int arr[10]) == void BubbleSort(int arr[]) == void BubbleSort(int *arr)
重点：传递不再是整个数组，而是数组的首地址（一个指针）。
所以，当整型数组做函数参数时，我们通常在函数定义中，封装2个参数。一个表数组首地址，一个表元素个数。
4.1 注意调用函数与别调用函数中的sizeof(arr);
要注意这个区别，比如说数组是在主函数中定义的，数组名为arr。此时我们使用 sizeof(arr) 求的是数组的大小。如果我们将数组名传给被调用的函数，那么sizeof(arr）是求指针的大小，或者说是求数组类型指针的大小。比如说数组是 int 型，那么在被调用函数中使用sizeof(arr）就等于 sizeof(int *);
（1）测试：
int main() // 主函数
{
int arr[7] = {1,2,3,4,5,6,7};
printf(" 在主函数中 sizeof(arr)=%d\n",sizeof(arr));
}
int PrintfArr(int *arr, int size) // 被调用函数
{
printf(" 在被调用函数中 sizeof(arr)=%d,sizeof(int *)=%d\n",sizeof(arr),sizeof(int *));
}
（2）测试结果：
5.指针做函数返回值：
int *test_func(int a, int b);
指针做函数返回值，不能返回【局部变量的地址值】。因为局部变量会被释放，如果不及时使用，就会被释放，得不到预期的值。所以为了安全考虑，不用局部变量的地址。
6.数组做函数返回值：
C语言，不允许！！！！ 只能写成指针形式。
二、指针和字符串：
通常，在c中我们操作字符串的方式有两种，一种是数组的方式，另一种是指针的方式。
数组就是 ：
str[i];
i++;
指针的方式就是：
（1）*(str1+i);
i++;
（2）*str1;
str1++;
1）
char str1[] = {'h', 'i', '\0'}; 变量，可读可写
char str2[] = "hi"; 变量，可读可写
char *str3 = "hi"; 常量，只读
str3变量中，存储的是字符串常量“hi”中首个字符‘h’的地址值。
str3[1] = 'H'; // 错误！！
char *str4 = {'h', 'i', '\0'}; // 错误！！！
当字符串（字符数组）， 做函数参数时， 不需要提供2个参数。 因为每个字符串都有 ‘\0’。
1.练习：比较两个字符串： strcmp();实现
比较 str1 和 str2， 如果相同返回0， 不同则依次比较ASCII码，str1 > str2 返回1，否则返回-1
1.1数组方式：
int mystrcmp(char *str1, char *str2)
{
int i = 0;
while (str1[i] == str2[i]) // *(str1+i) == *(str2+i)
{
if (str1[i] == '\0')
{
return 0; // 2字符串一样。
}
i++;
}
return str1[i] > str2[i] ? 1 : -1;
}
1.2指针方式：
int mystrcmp2(char *str1, char *str2)
{
while (*str1 == *str2) // *(str1+i) == *(str2+i)
{
if (*str1 == '\0')
{
return 0; // 2字符串一样。
}
str1++;
str2++;
}
return *str1 > *str2 ? 1 : -1;
}
2.练习：字符串拷贝：
2.1数组版本
void mystrcpy(char *src, char *dst)
{
int i = 0;
while (src[i] != 0) // src[i] == *(src+i)
{
dst[i] = src[i];
i++;
}
dst[i] = '\0';
}
2.2指针版
void mystrcpy2(char *src, char *dst)
{
while (*src != '\0') // src[i] == *(src+i)
{
*dst = *src;
src++;
dst++;
}
*dst = '\0';
}
3.练习：在字符串中查找字符出现的位置：
char *myStrch(char *str, char ch)
{
while (*str)
{
if (*str == ch)
{
return str;
}
str++;
}
return NULL;
}
// hellowrld --- 'o'
char *myStrch2(char *str, char ch)
{
int i = 0;
while (str[i])
{
if (str[i] == ch)
{
return &str[i];
}
i++;
}
return NULL;
}
4.练 习：字符串去空格。
void str_no_space(char *src, char *dst)
{
int i = 0; // 遍历字符串src
int j = 0; // 记录dst存储位置
while (src[i] != 0)
{
if (src[i] != ' ')
{
dst[j] = src[i];
j++;
}
i++;
}
dst[j] = '\0';
}
// 指针版
void str_no_space2(char *src, char *dst)
{
while (*src != 0)
{
if (*src != ' ')
{
*dst = *src;
dst++;
}
src++;
}
*dst = '\0';
}
5.注意 arr+i 与 arr++ 的区别
在写程序的时候，就犯了一个低级的错误，引起了段错误。原因就是不注意 arr+i 与 arr++的区别。 循环的时候，arr 始终指向首元素，arr++ ，arr会往后指向。
（1）测试程序：测试 str1++
void DeleteNbspace1(char *str1,int size)
{
printf("str1 = %p\n",str1);
char str2[24];
int i = 0;
while( *str1 )
{
if( *str1 != ' ' )
{
str2[i] = *str1 ;
i++;
}
str1++;
}
str2[i] = '\0';
printf("str1 = %p\n",str1);
查看结果
（2）测试 str1+j：
void DeleteNbspace1(char *str1,int size)
{
printf("str1 = %p\n",str1);
char str2[24];
int i = 0;
int j = 0;
while( *(str1+j) )
{
if( *(str1+j) != ' ' )
{
str2[i] = *(str1+j) ;
i++;
}
j++;
}
str2[i] = '\0';
printf("str1 = %p\n",str1);
查看结果：
三、带参数的main函数：
1.无参main函数：
int main(void) == int main()
2.带参数的main函数：
int main(int argc, char *argv[]) == int main(int argc, char **argv)
参1：表示给main函数传递的参数的总个数。
参2：是一个数组！数组的每一个元素都是字符串 char *
3.测试1：
（1）在Windows命令行中的中，使用gcc编译生成 可执行文件，如： test.exe
test.exe abc xyz zhangsan nichousha
-->
argc --- 5
test.exe -- argv[0]
abc -- argv[1]
xyz -- argv[2]
zhangsan -- argv[3]
nichousha -- argv[4]
（2）在Linux 中，测试代码
int main(int argc, char *argv[])
{
printf("用于测试带参数的主函数。\n");
printf(" argc : 参数的数量。argc = %d\n",argc);
printf(" argv 参数数组。下面将参数打印出来.\n");
int i = 0;
for( i = 0; i<argc; i++ )
{
printf("第 %d 个 参数：%s\n",i,argv[i]);
}
return 0;
}
测试结果：
4.测试2：
在VS中。项目名称上 --》右键--》属性--》调试--》命令行参数 --》将 test.exe abc xyz zhangsan nichousha 写入。
-->
argc --- 5
test.exe -- argv[0]
abc -- argv[1]
xyz -- argv[2]
zhangsan -- argv[3]
nichousha -- argv[4]
四、巩固练习
1.求非空字符串元素个数：
“ni chou sha chou ni za di”
2.字符串逆置： str_inverse
hello -- olleh
void str_inserse(char *str)
{
char *start = str; // 记录首元素地址
char *end = str + strlen(str) - 1; // 记录最后一个元素地址。
while (start < end) // 首元素地址是否 < 最后一个元素地址
{
char tmp = *start; // 三杯水 char 元素交换
*start = *end;
*end = tmp;
start++; // 首元素对应指针后移
end--; // 尾元素对应指针前移
}
}
3.判断字符串是回文：
int str_abcbb(char *str)
{
char *start = str; // 记录首元素地址
char *end = str + strlen(str) - 1; // 记录最后一个元素地址。
while (start < end) // 首元素地址是否 < 最后一个元素地址
{
if (*start != *end) // 判断字符是否一致。
{
return 0; // 0 表示非 回文
}
start++;
end--;
}
return 1; // 1 表示 回文
}
4.字符串处理函数： #include <string.h>
4.1字符串拷贝：
strcpy:
将 src 的内容，拷贝给 dest。 返回 dest。 保证dest空间足够大。【不安全】
char *strcpy(char *dest, const char *src);
函数调用结束 返回值和 dest参数结果一致。
strncpy:
将 src 的内容，拷贝给 dest。只拷贝 n 个字节。 通常 n 与dest对应的空间一致。
默认 不添加 ‘\0’
char *strncpy(char *dest, const char *src, size_t n);
特性： n > src: 只拷贝 src 的大小
n < src: 只拷贝 n 字节大小。 不添加 ‘\0’
4.2 字符串拼接：
strcat:
将 src 的内容，拼接到 dest 后。 返回拼接后的字符串。 保证 dest 空间足够大。
char *strcat(char *dest, const char *src);
strncat：
将 src 的前 n 个字符，拼接到 dest 后。 形成一个新的字符串。保证 dest 空间足够大。
char *strncat(char *dest, const char *src, size_t n);
函数调用结束 返回值和 dest 参数结果一致。
4.3 字符串比较： 不能使用 > < >= <= == !=
strcmp:
比较s1和s2两个字符串，如果相等 返回0.如果不相等，进一步表 s1 和 s2 对应位 ASCII码值。
s1 > s2 返回1
s1 < s2 返回-1
int strcmp(const char *s1, const char *s2);
strncmp:
int strncmp(const char *s1, const char *s2, size_t n);
比较s1和s2两个字符串的前n个字符，
如果相等 返回0。如果不相等，进一步表 s1 和 s2 对应位 ASCII码值。（不比字符串ASCII码的和）
s1 > s2 返回1
s1 < s2 返回-1
4. 4 字符串格式化输入、输出：
sprintf(): s -- string
int sprintf(char *str, const char *format, ...);
对应printf，将原来写到屏幕的“格式化字符串”，写到 参数1 str中。
printf("%d+%d=%d\n", 10, 24, 10+24);
---》
char str[100];
sprintf(str, "%d+%d=%d\n", 10, 24, 10+24); 格式串写入str数组中。
sscanf():
int sscanf(const char *str, const char *format, ...);
对应scanf， 将原来从屏幕获取的“格式化字符串”， 从 参数1 str中 获取。
scanf("%d+%d=%d", &a, &b, &c);
---》
char str[]= "10+24=45";
sscanf(str, "%d+%d=%d", &a, &b, &c); a --> 10, b --> 24, c --> 45
4.5 字符串查找字符、子串：
strchr():
在字符串str中 找一个字符出现的位置。 返回字符在字符串中的地址。
char *strchr(const char *s, int c);
printf("%s\n" strchr("hehehahahoho", 'a')); --> "ahahoho"
strrchr():
自右向左，在字符串str中 找一个字符出现的位置。 返回字符在字符串中的地址。
char *strrchr(const char *s, int c);
printf("%s\n" strrchr("hehehahahoho", 'a')); --> "ahoho"
strstr():
在字符串str中，找子串substr第一次出现的位置。返回地址。
char *strstr(const char *str, const char *substr);
在字符串中找子串的位置。
printf("%s\n" strrchr("hehehahahoho", "ho")); --> "hoho"
printf("%s\n" strrchr("hehehahahoho", "xixi")); --> NULL
scanf("%s", str);
scanf("%[^\n]", str);
4.6 字符串分割：
strtok(): 按照既定的分割符，来拆分字符串。“www.baidu.com” --> "www\0baidu.com"
char *strtok(char *str, const char *delim);
参1： 待拆分字符串
参2： 分割符组成的“分割串”
返回：字符串拆分后的首地址。 “拆分”:将分割字符用 '\0'替换。
特性：
1）strtok拆分字符串是直接在 原串 上操作，所以要求参1必须，可读可写（char *str = "www.baidu.com" 不行！！！）
2）第一次拆分，参1 传待拆分的原串。 第1+ 次拆分时，参1传 NULL.
练习： 拆分 ".itcast.cn$This is a strtok$test"
char str[] = "www.itcast.cn$This is a strtok$test";
char *p = strtok(str， "$ .");
while (p != NULL)
{
p = strtok(NULL, " .$");
printf("p = %s\n", p);
}
4.7 atoi/atof/atol：
使用这类函数进行转换，要求，原串必须是可转换的字符串。
错误使用："abc123" --> 0; "12abc345" ---> 12; "123xyz" -->123
atoi：字符串 转 整数。
int atoi(const char *nptr);
atof：字符串 转 浮点数
atol：字符串 转 长整数
1866
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
