指针数组
#include<stdio.h>
int main()
{
int a[3] = {0,1,2};
//指针数组，它是数组，每个元素都是指针
int *p[3];
p[0] = &a[0];
p[0] = a;
p[1] = &a[1];
p[1] = a+1;
p[2] = &a[2];
p[2] = a+2;
//sizeof(p):3个元素，int*(32位)
//3 * 4 = 12
//sizoef(p[0]):第0给元素，int * = 4
int n = sizeof(p)/sizeof(p[0]);
int i =0;
for(i = 0;i < n;i++)
{
p[i] = &a[i]; //a+i
}
for(i = 0;i < n;i++)
{
//printf("%d\n",*p[i])
printf("%d\n", *(*(p+i)));
//p[i]等价于*(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[i]);
}
printf("\n");
//冒泡排序
int j = 0;
int tmp;
for(i = 0;i < n-1;i++)
{
for(j = 0;j < n-i-1;j++)
{
if(a[j] > a[j+1]) //升序
{
tmp = a[j];
a[j] = a[j+1];
a[j+1] = tmp;
}
}
}
printf("排序后\n");
for(i = 0;i < n;i++)
{
printf("%d ", a[i]);
}
printf("\n");
形参中的数组02
#include<stdio.h>
//1、形参中的数组，不是数组，它是普通指针变量
//2、形参数组:int a[100000]，int a[]，int *a对编译器而已，没有任何区别
//3、编译器都是当做int*处理
//4、形参中的数组和非形参数组区别:形参中的数组是指针变量，非形参数组就是数组
//void print array(int a[100000])
//void print array(int a[])
void print_array(int a[], int n)
{
int i = 0;
//64位系统，sizeof(a)，a是指针变量，结果为8
//sizeof(a[0])第0个元素，是int类型，结果为4
/*int n = sizeof(a)/sizeof(a[0]);
printf("sizeof(a) = %d\n". sizeof(a));
printf("sizeof(a[0] = %d\n),sizeof(a[0])");
*/
for(i = 0;i < n;i++)
{
printf("%d, ",a[i]); //等价于*(a + i)
}
printf("\n");
//a = NULL; //形参中的数组，不是数组，它是普通指针变量
}
int main()
{
int a[] = {1,-2,3,-4,5,-6,7,-8,9};
//print_array(a); //传递的是，数组的首元素地址，&a[0]
//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[i] != '\0') //while(*(str+i) != '\0'))
{
printf("%c",str[i]);
i++;
}
printf("\n");
return 0;
}
字符指针
#include<stdio.h>
int main()
{
char str[] = "hello";
str[0] = '1';
*(str + 1) = '2';
//printf("str = %s\n", str); //12llo
printf("str = %s\n",&str[0] +1); //2llo
printf("str = %s\n",str+1); //2llo
//定义一个指针，指向首元素
char *p = NULL;
p = &str[0];
p = str; //数组名就是首元素地址
*p = 'a';
p++; //p = p +1
*p = 'b';
printf("str = %s\n", str); //abllo
printf("str = %s\n", p); // &str[0]+1 //bllo
printf("str = %s\n",p-1);
return 0;
}
字符串拷贝问题
#include<stdio.h>
#include<string.h>
int main()
{
char buf[100];
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[100];
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");
}
int main()
{
//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
#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;
}
字符串常量初始化问题
#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[i]);
}
return 0;
}
字符指针数组
#include<stdio.h>
//void fun(int a[])
//void fun(int a[100])
void fun()
{
}
//void print_array(char * p[100],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[i]);
}
}
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[i]);
}
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[100]="aaaaaaaaaaa";
strncpy(buf,start,n);
buf[n] = 0; //结束符
printf("buf = %s\n",buf);
return 0;
}
课堂笔记
void fun(int b[10][10]); //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[10] = {'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'
