Day 09
文章目次[*]
[*]指针数组
[*]指针和函数
[*]技能名词表明
[*]技能细节
[*]课堂笔记
指针数组
#include<stdio.h>
int main()
{
int a = {0,1,2};
//指针数组，它是数组，每个元素都是指针
int *p;
p = &a;
p = a;
p = &a;
p = a+1;
p = &a;
p = a+2;
//sizeof(p):3个元素，int*(32位)
//3 * 4 = 12
//sizoef(p):第0给元素，int * = 4
int n = sizeof(p)/sizeof(p);
int i =0;
for(i = 0;i < n;i++)
{
p = &a; //a+i
}
for(i = 0;i < n;i++)
{
//printf("%d\n",*p)
printf("%d\n", *(*(p+i)));
//p等价于*(p+i)
}
return 0;
}
指针和函数
通过函数交换两个变量
#include<stdio.h>
void swap(int m, int n)
{
int tmp;
tmp = m;
m = n;
n = tmp;
printf("m = %d,n = %d\n",m,n);
}
int main()
{
int a = 11;
int b = 22;
swap(a,b);//值传递
printf("a = %d,b = %d\n",a,b);
return 0;
} 地址通报
#include<stdio.h>
void swap(int *m, int *n)
{
int tmp;
tmp = *m;
*m = *n;
*n = tmp;
}
int main()
{
int a = 11;
int b = 22;
//值传递，不管这个变量什么类型，只要是变量本身传递，就是值传递
//swap(a,b);//值传递
swap(&a,&b);//地址传递，变量的地址
printf("a = %d,b = %d\n",a,b);
return 0;
}
形参中的数组01
#include<stdio.h>
int main()
{
int a[] = {1,-2,3,-4,5,-6,7,-8,9};
int i = 0;
int n = sizeof(a)/sizeof(*a);
printf("排序前\n");
for(i = 0;i < n;i++)
{
printf("%d ", a);
}
printf("\n");
//冒泡排序
int j = 0;
int tmp;
for(i = 0;i < n-1;i++)
{
for(j = 0;j < n-i-1;j++)
{
if(a > a)//升序
{
tmp = a;
a = a;
a = tmp;
}
}
}
printf("排序后\n");
for(i = 0;i < n;i++)
{
printf("%d ", a);
}
printf("\n");
形参中的数组02
#include<stdio.h>
//1、形参中的数组，不是数组，它是普通指针变量
//2、形参数组:int a，int a[]，int *a对编译器而已，没有任何区别
//3、编译器都是当做int*处理
//4、形参中的数组和非形参数组区别:形参中的数组是指针变量，非形参数组就是数组
//void print array(int a)
//void print array(int a[])
void print_array(int a[], int n)
{
int i = 0;
//64位系统，sizeof(a)，a是指针变量，结果为8
//sizeof(a)第0个元素，是int类型，结果为4
/*int n = sizeof(a)/sizeof(a);
printf("sizeof(a) = %d\n". sizeof(a));
printf("sizeof(a = %d\n),sizeof(a)");
*/
for(i = 0;i < n;i++)
{
printf("%d, ",a); //等价于*(a + i)
}
printf("\n");
//a = NULL; //形参中的数组，不是数组，它是普通指针变量
}
int main()
{
int a[] = {1,-2,3,-4,5,-6,7,-8,9};
//print_array(a);//传递的是，数组的首元素地址，&a
//a = NULL;
int n = sizeof(a)/sizeof(*a);
print_array(a,n); //应该把数组元素个数传递过去
return 0;
}
返回局部变量的地址
#include<stdio.h>
int *fun()
{
int a;//Linux64位，不允许返回局部变量的地址
return &a;
}
int main()
{
int *p = NULL;
p = fun(); //接受函数返回的地址
//到上一步使用完fun()，fun（）内的a，自动释放，下面操作野指针
*p = 100; //操作指针所指向的内存
return 0;
} 返回全局变量的地址
#include <stdio.h>
int a; // 明确注释全局变量的用途
int *fun() {
return &a; // 函数名更明确
}
int main() {
int *p = fun();
*p = 100;
printf("*p = %d, a = %d\n", *p, a); // 合并输出
*(fun()) = 111;
printf("a = %d\n", a);
return 0;
}
指针和字符串
字符串打印阐明
#include<stdio.h>
int main()
{
char str[] = "hello mike";
//1、%s,从首元素开始打印，直到结束符位置
//2、%s,操作的是指针所指向的内容
//printf("str = %s\n", str);
//2、str是首元素地址，如果想打印str本身的值，%p，&x，&d，%o
printf("str = %p\n",str);//一个个打印出来，地址
//3、str代表第0个元素,它是char
//printf("str3 = %s\n", *str);
printf("str3 = %c\n", *str);
int i = 0;
while(str != '\0')//while(*(str+i) != '\0'))
{
printf("%c",str);
i++;
}
printf("\n");
return 0;
}
字符指针
#include<stdio.h>
int main()
{
char str[] = "hello";
str = '1';
*(str + 1) = '2';
//printf("str = %s\n", str);//12llo
printf("str = %s\n",&str +1); //2llo
printf("str = %s\n",str+1); //2llo
//定义一个指针，指向首元素
char *p = NULL;
p= &str;
p= str; //数组名就是首元素地址
*p = 'a';
p++;//p = p +1
*p = 'b';
printf("str = %s\n", str); //abllo
printf("str = %s\n", p);// &str+1 //bllo
printf("str = %s\n",p-1);
return 0;
}
字符串拷贝问题
#include<stdio.h>
#include<string.h>
int main()
{
char buf;
char *p = buf;
//1、p指向buf的首元素
//2、strcpy()是给p所指向的内存拷贝内容，字符串拷贝了buf
strcpy(p,"hello mike abc");
printf("p = %s, buf = %s\n",p,buf);
return 0;
}
int main01()
{
char *p;
//1、不是给p变量拷贝内容
//给p所指向的内存拷贝内容
//3、P是野指针，给野指针所指向的内存拷贝内容，结果导致段错误
strcpy(p, "hello mike abc");
return 0;
}
字符串拷贝函数
#include<stdio.h>
//void my_strcpy(char dst[].char src[])
void my_strcpy(char *dst, char *src)
{
int i = 0;
while(*(src+i)!='\0')
{
*(dst+i) = *(src+i);
i++
}
//结束符
*(dst + i) = 0;
int main()
{
char src[] = "hello mike";
char dst;
char *p = buf;
my_strcpy(p,src);//自定义拷贝函数
printf("dst = %s\n",dst);
return 0;
} const修饰的字符指针
#include<stdio.h>
int main()
{
char buf[] = "hello";
char *p1 = buf;
*p1 = 'a'; //改变指针所指向的内存
p1 = NULL;//改变指针变量本身
//const修饰*,指针所指向的内存不能修改
const char *p2 = buf;
//*p2 = 'a'; //err
p2 = NULL; //ok
return 0;
} 字符串常量
#include<stdio.h>
void fun()
{
printf("fun s2 = %p\n","hello mike");
}
intmain()
{
//1、每个字符串都是一个地址，这个地址是指字符串首元素地址
//2、字符串常量放在data区，文字常量区
printf("s1 = %s\n","hello mike");
printf("s2 = %s\n","hello mike");
printf("s3 = %s\n","hello mike"+1);
//fun();
return 0;
}
文字常量区不答应修改01
https://i-blog.csdnimg.cn/direct/ca337a1351504f39b9f47e1de93c7e6f.png
#include<stdio.h>
#include<string.h>
int main()
{
//1、字符串常量就是字符串的首元素地址
printf("s1 = %p\n","hello mike");
char *p1 = "hello mike";
printf("p1 = %p\n",p1);
char *p2 = "hello mike";
printf("p2 = %p\n",p2);
//2、字符串常量，文字常量区的字符串，只读，不能修改
printf("*p1 = %c\n",*p1); //读，ok
//3、p1指向字符串常量，字符串常量为只读，不能修改
//*p1 = 'a'; //修改 //err
char *p3 = "hello";
//4、p3指向文字常量区，不能改
strcpy(p3,"abc"); //err
return 0;
}
文字常量区不答应修改02
#include<stdio.h>
void fun(char *tmp)
{
*tmp = 'a'; //err
}
int main()
{
char *p = NULL; //p是变量
"hello mike" //字符串常量，首元素地址
p = "hello mike"; //p指向字符串
//*p = 'a'; //err,指向文字区常量，文字常量区内容只读
p = NULL; //ok
p = "hello"//ok
char *p2 = "abc";
fun(p2); //p2的值，是“abc”首元素地址
return 0;
} https://i-blog.csdnimg.cn/direct/eeafecfdc50f4b01af432b4f542259a1.png
字符串常量初始化问题
#include<stdio.h>
int main()
{
//1、p指针保存了“hello”的地址
//2、指针所指向的内存不能修改
char *p = "hello";
//1、把"hello"一个一个字符放在buf数组中
//2、数组的元素可以修改
char buf[] = "hello";
return 0;
} main形参利用阐明
#include<stdio.h>
//argv[]:它是数组，数组每个元素都是char*，每个元素都是字符地址
//argc:argv[]元素个数
//main()函数参数，需要用户传递
int main(int argc,char *argv[])
{
int i =0;
for(i = 0;i < argc;i++)
{
printf("test = %s\n",argv);
}
return 0;
}
https://i-blog.csdnimg.cn/direct/905c0d3a627a4025b8a5d4ec55f2019b.png
字符指针数组
#include<stdio.h>
//void fun(int a[])
//void fun(int a)
void fun()
{
}
//void print_array(char * p,int n)
void print_array(char *p[], int n)
//void print_arrauy(char **p, int n)
{
int i = 0;
for(i = 0;i < n;i++)
{
printf("%s\n",p);
}
}
int main()
{
char *p1 = "hello";
char *p2 = "abc";
char *p3 = "mike";
char *p[] = {"hello", "abc", "mike"};
int n = sizeof(p)/sizeof(*p);
int i = 0;
for(i = 0;i < n;i++)
{
printf("%s\n", p);
}
return 0;
}
查找匹配字符串出现的次数
#include<stdio.h>
#include<string.h>
int main()
{
char *p = "11abcd11122abcd333abcd3322abcd3333322qqq";
int i = 0; //累加器
char *tmp = NULL;
while(1)
{
//查找匹配字符串，如果找到，返回匹配字符串的地址，没有找到返回空
tmp = strstr(p, "abcd");
if(tmp == NULL)
{
break;//跳出循环
}
else //找到
{
i++; //累加
//重新设置新的起点
p = tmp + strlen("abcd");
}
}
printf("出现abcd的次数为； %d\n", i);
return 0;
}
两头堵类型
#include<stdio.h>
#include<string.h>
int main()
{
char *p = "123456789 ";
char *start = p; //首元素地址
char *end = p + strlen(p) - 1; //尾元素地址
//从左往右
while(*start == ' ' && *start != '\0')
{
start++;
}
while(*end == ' ' && end != p)
{
end--;
}
int n = end-start+1;//5-1=4,但是实际上元素由5个所以+1
printf("n = %d\n", n);
char buf="aaaaaaaaaaa";
strncpy(buf,start,n);
buf = 0; //结束符
printf("buf = %s\n",buf);
return 0;
} 课堂笔记
void fun(int b); //ok
void fun(int **p); //err,二维数组不是二级指针
int *fun(); //返回值是指针类型，指针函数
0 数字0，和'\0'等价
'\0'
'0'
'0'字符'0'，不是结束符，ascii为48
char a[] = {'a', 'b'};
printf("%s\n",a); //乱码，没有结束符
char a = {'a', 'b'}; //后面自动补0
printf("%s\n",a); //正常
char a[] = {'a', 'b', 0};
char a[] = {'a', 'b','\0'};
printf("%s\n",a);//正常
char a[] = {'a','b','0'};
printf("%s\n",a); //乱码，没有结束符
char buf[] = "hello"; //以字符串初始化，自动隐藏结束符'\0'
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
页:
[1]