DAY02
- 指针强化
- 字符串基本操作
- 字符串一级指针内存模型
- 字符串做函数参数
1 指针强化
- 指针也是一种数据类型,指针变量也是一种变量,只不过指针存储的是地址。和 int a本质是一样的。指针变量也有空间,32位程序大小为4个字节,指针的步长和定义的数据类型有关。
int *p = 0x1122;
*
操作符,*
相当于钥匙,通过*
可以找到指针所指向的内存区域。
int a = 10;
int *p = NULL;
p = &a; /* 指针指向谁,就把谁的地址赋值给指针 */
*p = 22; /* *放在=左边,给内存赋值,写内存 */
int b = *p; /* *放在=右边,取内存的值,读内存 */
- 指针变量和指针指向的内存是两个不同的概念
char *p = NUL;
char buf[] = "abcdef;
/* 改变指针变量的值 */
p = buf;
p = p + 1; /* 改变了指向变量的值,改变了指针的指向 */
*p = 'm'; /* 改变指针指向的内存,并不会影响到指针的值 */
- 写内存时,一定要确保内存可写
char *buf2 = "fsadfsafas"; /* 文字常量区,内存不可改 */
buf2[2] = '1'; //err
2 间接赋值(*p)是指针存在最大意义
2.1 间接赋值三大条件
a) 两个变量
b) 建立关系
c) 通过 * 操作符进行间接赋值
1)
int a;
int *p; //两个变量
p = &a; //建立关系
*p = 100; //通过 * 操作符进行间接赋值
2)
int b;
fun(&b); //两个变量之一:实参,给函数传参时,相当于建立关系
//p = &b
void fun(int *p) //两个变量之一:形参参
{
*p = 100; //通过 * 操作符进行间接赋值
}
2.2 如何定义合适类型的指针变量
/**
* 某个变量的地址需要定义一个怎么样类型的变量保存
* 在这个类型的基础上加一个 *
*/
int b;
int *q = &b;
int **t = &q;
注意:如果想通过函数形参改变实参的值,必须传地址
值传递,形参的任何修改不会影响到实参
地址传递,形参(通过*操作符)的任何修改会影响到实参
用1级指针形参,去间接修改了0级指针(实参)的值
用2级指针形参,去间接修改了1级指针(实参)的值
用3级指针形参,去间接修改了2级指针(实参)的值
用n级指针形参,去间接修改了n-1级指针(实参)的值
int ***p3 = NULL;
int ****p4 = &p3;
int a = 10;
fun(a); //值传递
void fun(int b)
{
b = 20;
}
fun2(&a);//地址传递
void fun2(int *p)
{
*p = 20; //通过*操作内存
}
int *p = 0x1122;
void fun3(p);//值传递
void fun3(int *p)
{
p = 0x2233;
}
void fun4(&p);//地址传递
void fun4(int **p)
{
*p = 0xaabb; //通过*操作内存
}
2.3 不允许向NULL和未知非法地址拷贝内存
char *p = NULL;
//给p指向的内存区域拷贝内容
strcpy(q, "1234"); //err
//静态
char buf[100];
p = buf;
strcpy(q, "1234"); //ok
//动态
p = (char *)malloc(sizeof(char) * 10 );
strcpy(q, "1234"); //ok
char *q = "123456";
strcpy(q, "abcd"); //err
2.4 void *指针的使用
void *p = 0x1122; //可以这么做,不建议,一般赋值为NULL
char buf[1024] = "abcd";
p = (void *)buf; //指向 char
printf("p = %s\n", (char *)p); //使用时转化为实际类型指针
int a[100] = { 1, 2, 3, 4 };
p = (void *)a; //指向 int
int i = 0;
for (i = 0; i < 4; i++)
{
//使用时转化为实际类型指针
int *tmp = (int *)p;
printf("%d ", *(tmp+i));
printf("%d ", tmp[i]);
printf("%d ", *( (int *)p + i ) );
}
void * 常用于函数参数:memset(), memcpy()
2.5 栈区返回变量的值和变量的地址区别
int fun()
{
int a = 10;
return a;
}
int *fun2()
{
int a = 10;
return &a;
}
int *fun3()
{
static int a = 10;
return &a;
}
int b = fun(); //ok, b的值为10
//也ok, p确实也保存了fun2()内部a的地址
//但是,fun2完毕,a就释放,p就指向未知区域
int *p = fun2();
//ok,fun3()中的a在全局区,函数运行完毕,a的空间不释放
int *q = fun3();
2.6 .c -> 可执行程序过程
预处理:宏定义展开、头文件展开、条件编译,这里并不会检查语法。
编译:检查语法,将预处理后文件编译生成汇编文件。
汇编:将汇编文件生成目标文件(二进制文件)
链接:将目标文件链接为可执行程序
程序只有在运行才加载到内存(由系统完成),但是某个变量具体分配多大,是在编译阶段就已经确定了。换句话说,在编译阶段做完处理后,程序运行时系统才知道分配多大的空间,所以,很多时候说,这个变量的空间在编译时就分配(确定)了。
2.7 指针做函数参数的输入输出特性
输入:主调函数分配内存
输出:被调函数分配内存
//结合内存四区模型图
main()
{
char buf[100] = "123456";
fun1(buf); //输入
char *p = NULL;
fun2(&p); //输出
//因为p在fun2()动态分配空间了,使用完毕应该释放
if(p != NULL)
{
free(p);
p = NULL;
}
}
void fun1(char *p /*in*/)
{
strcpy(p, "1234")
}
void fun2(char **p /*out*/)
{
char *tmp = malloc(100);
strcpy(tmp, "1234");
*p = tmp; //间接赋值是指针存在最大意义,通过*操作内存
}
2.8 变量内存的值和变量的地址
int a = 0;
a变量内存的值为0
a变量的地址(&a)绝对不为0,只要定义了变量,系统会自动为其分配空间(一个合法不为0的地址)
3 字符串操作
3.1 字符串初始化
/* C语言没有字符串类型,用字符数组模拟
C语言字符串以数字0,或字符 '\0' 结尾,数字 0 和字符 '\0' 等价 */
char str1[100] = { 'a', 'b', 'c', 'd' }; //没赋值的自动以数字0填充
char str2[] = { 'a', 'b', 'c', 'd' }; //数组长度为4,结尾没有数字0
char str4[] = "abcdef"; //常用赋值方式,栈区
char *p = "abcdef"; //文字常量区,内容不允许被修改
char *buf = (char *)malloc(100); //堆区
strcpy(buf, "abcd"); //"abcd"拷贝到buf指向的内存区域中
3.2 sizeof和strlen区别
//使用字符串初始化,常用
char buf8[] = "abc";
//strlen: 测字符串长度,不包含数字0,字符'\0'
//sizeof:测数组长度,包含数字0,字符'\0'
printf("strlen = %d, sizeof = %d\n", strlen(buf8), sizeof(buf8));
char buf9[100] = "abc";
printf("strlen = %d, sizeof = %d\n", strlen(buf9), sizeof(buf9));
3.3 ‘\0’ 后面最好别跟数字,因为几个数字合起来有可能是一个转义字符
//\012相当于\n
char str[] = "\0129";
printf("%s aaaa\n", str);
3.4 字符’\0’, 数字0, 字符’0’, NULL的区别
a) 字符'\0' ASCII码值为 0 的字符
字符'\0' 和 数字 0 是等级的,'\0'中'\'是转义字符
char buf[100];
//下面是等级,在数组第10个位置设置字符串结束符
buf[10] = 0;
buf[10] = '\0';
b) 字符'0'是字符串的某个字符内容为'0', ASCII码值为 48 的字符
char buf[100];
buf[0] = '0'; //第0个字符为字符 '0'
c) NULL 标准头文件(stdio.h)的宏 其值为数字 0
3.4 数组法、指针法操作字符串
char buf[] = "abdgdgdsg"
char *p = buf; //buf是数组首元素地址,它也是指针
for (i = 0; i < strlen(buf); i++)
{
//[] 和 * 操作是等价的,也是操作指针指向内存
printf("%c ", buf[i]); //符合程序员习惯
printf("%c ", p[i]); //符合程序员习惯
printf("%c ", *(p+i));
printf("%c ", *(buf + i));
}
注意:数组名也是指针,数组首元素地址,但是,它是一个只读常量
p++; //ok
buf++; //err
3.5 字符串拷贝函数
int my_strcpy(char *dst, char *src)
{
if (dst == NULL || src == NULL){
return -1;
}
//辅助变量把形参接过来
char *to = dst;
char *from = src;
//*dst = *src
//dst++, src++
//判断 *dst是否为0, 为0跳出循环
while (*to++ = *from++) ;
return 0;
}
4 项目开发常用字符串应用模型
4.1 利用strstr标准库函数找出一个字符串中substr出现的个数
char *p = "11abcd111122abcd333abcd3322abcd3333322qqq";
int n = 0;
do {
p = strstr(p, "abcd");
if (p != NULL)
{
n++; //累计个数
//重新设置查找的起点
p = p + strlen("abcd");
}
else //如果没有匹配的字符串,跳出循环
{
break;
}
} while (*p != 0); //如果没有到结尾
4.2 两头堵模型
char *p = " abcddsgadsgefg ";
int begin = 0;
int end = strlen(p) - 1;
int n = 0;
if(end < 0){
return;
}
//从左往右移动,如果当前字符为空,而且没有结束
while (p[begin] == ' ' && p[begin] != 0)
{
begin++; //位置从右移动一位
}
//从右往左移动,如果当前字符为空
while (p[end] == ' ')
{
end--; //往左移动
}
n = end - begin + 1; //非空元素个数
strncpy(buf, p + begin, n);
buf[n] = 0;
//如何证明strncpy()拷贝不会自动加字符串结束符'\0'
char dst[] = "aaaaaaaaaaaaaaa";
strncpy(dst, "123", 3);
printf("dst = %s\n", dst); //dst = "123aaaaaaaaaaaa"