南京seo公司教程_网站推广常用方法包括_app引流推广方法_重庆seo整站优化外包服务

指针数组

#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 * = 4int 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，%oprintf("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);  //12lloprintf("str = %s\n",&str[0] +1); //2lloprintf("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); //ablloprintf("str = %s\n", p);  // &str[0]+1 //blloprintf("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所指向的内存拷贝内容，字符串拷贝了bufstrcpy(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'; //errp2 = NULL; //okreturn 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'; //修改 //errchar *p3 = "hello";//4、p3指向文字常量区，不能改strcpy(p3,"abc"); //errreturn 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; //okp = "hello"  //okchar *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个所以+1printf("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为48char 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'