/**
* 字符串的两种实现方式 
*/ 
#include <stdio.h> 
/* 使用字符数组实现 */ 
void fun() 
{ 
// 定义伪字符串 
char str[] = "I Love Your!"; 
printf("%s\n",str); 
}
/* 使用字符指针实现 */ 
void fun1() 
{ 
// 定义伪字符串 
char *str = "I Love Your!"; 
printf("%s\n",str); 
}
int main() 
{ 
fun(); 
fun1(); 
return 0; 
} 

字符数组和字符指针的联系

• 字符数组由元素组成，每个元素中存放一个字符，而字符指针变量中存放的是地址，也能作为函数参数。
• 只能对字符数组中的各个元素赋值，而不能用赋值语句对整个字符数组赋值。
• 字符数组名虽然代表地址，但数组名的值不能改变。因为数组名是常量。
• 对于字符串中字符的存取，可以用下标法，也可以用指针法。

案例：

/**
* 字符数组和字符指针的联系 
*/ 
#include <stdio.h> 
int main() 
{ 
// 使用两种方式定义字符串 
char str1[] = "你好，马杰克！"; 
char *str2 = "您好，马应龙！"; 
// 测试赋值 
// str1 = "你好,龙瑞！"; // 不能对字符数组整体赋值，如果要赋值，请使用string.h中strcpy() 
str2 = "你好,药可！"; 
// 打印输出 
printf("%s\n%s\n",str1,str2); 
char a[] = "I love you!"; 
char *b = "I love you!"; 
// 使用下标法和指针法访问字符串 
printf("%c\n%c\n",a[4],*(b+4));// v v 空格也是占位的 
return 0; 
} 

字符串作为形式参数

• 实参与形参都可以是字符数组
• 实参用字符数组，形参用字符指针（在函数内部不能对字符串中的字符做修改

  • test5(char *arr,int len) 
    { 
    arr[2] = 'A'; // 错误，字符串常量一旦创建，就不能被改变 
    }
    main(){ 
    char arr[] = "abc"; // 字符串常量，常量是不可修改的 
    test(arr,3); 
    } 
    

    • 实参和形参都是指针变量（在函数内部不能对字符串中的字符做修改）

    test(char *arr,int len) 
    { 
    arr[2] = 'A'; // 错误 
    }
    main() 
    { 
    char arr[] = "abc"; 
    char *p = arr;// &arr[0] 
    test(p,3); 
    } 
    

    • 实参是指针类型，形参是字符数组

    注意：

            1. 字符数组在创建的时候，会在内存中开辟内存空间，内存空间可以存放字符数据；字符指针在创建的时候，需要依赖于字符数组，字符指针在内存中开辟的内存空间中，存放的是数组元素的内存地址。字符指针的创建依赖于字符数组，字符数组可以独立存在，而字符指针不能独立存在。

            2. 字符数组可以初始化，但是不能赋值；字符指针可以初始化，也可以赋值。

    // 字符数组 
    char str1[11] = "I love You!"; 
    str1 = "Home"; // 错误 
    str1[] = "home"; // 错误 
    // 字符指针 
    char *str2 = "I love You!"; 
    str2 = "home";// 正确 
    

案例1：

/**
* 字符指针作为函数参数：用函数调用实现字符串，复制以及计算字符串长度。 
*/ 
#include <stdio.h> 
/* 定义一个函数，传递拷贝的字符串，返回字符串长度 */ 
int str_copy(char *str1,char *str2) 
{ 
int i = 0; // 循环变量 
while(str1[i]!='\0') 
{ 
// 实现拷贝 
str2[i] = str1[i]; 
i++; 
}
// 拷贝结束之后，一定要给字符串加上结束符号\0 
str2[i] = '\0'; 
return i; 
}
int main() 
{ 
// 定义两个数组，从键盘录入字符串 
char str1[20],str2[20]; 
printf("请输入一个字符串：\n"); 
scanf("%s",str1); 
printf("str1=%s\n",str1); 
int len = str_copy(str1,str2); 
printf("str2=%s\n",str2); 
printf("len=%d\n",len); 
return 0; 
} 

案例2：

/**
* 给定一个字符串，截取start到end之间字符串，含头不含尾 
*/ 
#include <stdio.h> 
/* 字符串截取函数 */ 
int str_split(char *str,int start,int end,char *temp) 
{ 
// 定义一个循环变量 
int i = 0,k = 0; 
// 定义一个字符指针，用来接收str中截取到字符串 
// 循环遍历每一个字符 
while(str[i]!='\0') 
{ 
if(i>= start && i < end) 
{ 
temp[k] = str[i]; 
k++; 
}
i++; 
}
temp[k] = '\0'; 
// 更新str中的数据 
printf("%s\n",temp); 
return k; 
}
int main() 
{ 
char *str = "abcdefg"; 
char temp[100]; 
int len = str_split(str,2,5,temp); 
printf("str=%s,len=%d\n",temp,len); 
return 0; 
} 

函数指针与指针函数

函数指针

• 定义：函数指针本质是指针，它是函数的指针（定义一个指针变量，变量中存储了函数的地址）。函数都有一个入口地址，所谓指向函数的指针，就是指向函数的入口地址。这里函数名就代表入口地址。

返回值类型（*变量名）(形式参数列表)；

int (*p) (int a,int b);

// 得先有函数，才能定义这个函数的指针 
int fun(int a,int b){..} 
// 定义函数指针并给它赋值 
int (*p) (int a,int b) = fun;// fun不能跟() 

// 得先有函数，才能定义这个函数的指针 
float fun(int a,double b,char c){..} 
// 先定义函数指针 
float (*p) (int a,double b,char c); 
// 赋值 
p = fun; 

/**
* 函数指针：指向函数的指针变量就是函数指针 
需求：求a，b两个数的最大值 
*/ 
#include <stdio.h> 
int max(int a,int b) 
{ 
if(a > b) 
{ 
return a; 
}
return b; 
}
int main() 
{ 
int a = 3,b = 2,c; 
// 普通函数调用 
c = max(a,b); 
printf("%d,%d两个数中的最大值是：%d\n",a,b,c); 
// 通过指针变量访问它指向的函数 
// 创建指针并初始化 
int (*p)(int,int) = max; 
// 调用函数指针 
c = p(a,b); 
printf("%d,%d两个数中的最大值是：%d\n",a,b,c); 
// 调用函数指针 
c = (*p)(a,b); 
printf("%d,%d两个数中的最大值是：%d\n",a,b,c); 
return 0; 
}

指针类型 函数名(形参列表)
 { 
函数体; 
return 指针变量;
 }

int *get(int a)
 { 
int *b = &a; 
// return &a; // 编译报警告 
return b;
 }

/**
* 指针函数：函数的返回值是指针类型 
需求：有若干个学生的成绩（每个学生有４门课程），要求在用户输入学生序号以后，能输出该学生的全部成绩。用 
指针函数来实现。 
*/ 
#include <stdio.h> 
/* 定义一个函数，传入学生的序号，返回这个学生的所有课程成绩 */ 
float *search(float (*p)[4],int n) 
{ 
// 定义一个指针，用来接收查询到的某个学生的所有课程 
float *pt; 
pt = *(p+n);// p[n] 
return pt; 
}
int main() 
{ 
// 准备所有学生的成绩 
float score[][4]={{60,70,80,90},{56,66,76,76},{35,68,90,37}}; 
int i,m; 
float *p; 
printf("请输入学生序号(0~2)：\n"); 
scanf("%d",&m); 
printf("第%d个学生的成绩：\n",m); 
p = search(score,m);// 函数返回值为行的首地址 
// 遍历 
for(i = 0; i < 4;i++) 
printf("%5.2f\t",*(p+i)); 
printf("\n"); 
return 0; 
} 

野指针、空指针

野指针

• 定义：访问了一个已经销毁或者访问受限的内存区域外的指针，这个指针就是野指针。
• 野指针产生的场景：

1.变量未初始化，通过指针访问该变量

int a;
int *p = &a;// p就是野指针

ptf(*p); // 访问野指针，但是数据不安全

2.指针变量未初始化

int *p = NULL; //此时P也是野指针
ptf (*p);

3.指针指向的内存空间被（free函数）回收了

4.指针函数中直接返回了局部变量的地址。

5.指针指向数组以外的地址（下标越界）

• 如何避免野指针：

写代码要养成两个习惯（通过编码规范避免）

1.指针变量要及时初始化，如果暂时没有对应的值，建议赋值为NULL；

2.数组操作（遍历，指针运算）时，注意数组的长度，避免越界

3.指针指向的内存空间被回收，建议给这个指针变量赋值为NULL;

int *p = (int*)malloc(10);//动态内存分配
free(p);//动态内存释放
p = NULL;p不指向任何空间

4.指针变量使用之前要检查他的有效性（以后开发中要做非空校验）

int *p = NULL;
if(!p)
{
return -1;
}

说明：NULL是空常量，它的值是0，这个NULL一般存放在内存中的0x00000000位置，这个地址只能存放NULL，不能被其它程序修改。

空指针

空指针，又称为悬空指针：当一个指针的值是NULL，这个指针被称为空指针；对空指针访问会运行报错（段错误）

二极指针

定义:二极指针，又被称作多重指针，引用以及指针的地址，此时这个指针变量就得定义成二极指针

int a = 10;
int *p = &a;
int **w = &p;

定义格式：

数据类型 **变量名 = 指针数组的数组名或者一级指针的地址

//指针数组
int array = {1,2,3};
int *arr = {&array[0],&array[1],&array[2]};

//一级指针
int a = 10;
int *p = &a;//一级指针

举例：

//字符型指针数组
char *arr[3] = {"abc","aaa034"."12a12"};//等效与 char arr[3][6]= {"abc","aaa034","12a12"}
//定义二极指针并赋值(指针需要跟依赖的源同类型)
char **p = arr;

int a = 90;
int *p = &a;//一级指针
int **k = &p; //二极指针

结论：

1.二级指针和指针数组是等效的，和二维数组不等效

2.二维数组和数组指针是等效的,和二级指针不等效

二级指针的用法：

1.如果是字符的二级指针，可以像遍历字符串数组一样遍历它

2.如果是其他的二级指针，就需要解引用两次访问它所指向的数据

案例：

/**
* 二级指针案例：使用指向指针数据的指针变量。 
*/ 
#include <stdio.h> 
void fun1() 
{ 
char *name[]={"Follow me","BASIC","Great Wall","FORTRAN","Computer design"}; 
// 定义一个二级指针 
char **p; 
// 定义循环变量 
int i = 0; 
// 遍历指针数组 
do
{ 
p = name + i; 
printf("%s\n",*p); 
i++; 
}while(i < 5); 
printf("\n"); 
}
void fun2() 
{ 
int arr1[5] = {11,12,13,14,15}; 
// 创建一个指针数组 
int *arr[] = {&arr1[0],&arr1[1],&arr1[2],&arr1[3],&arr1[4]}; 
int **p = arr,i = 0; 
// 遍历 
for(;i < 5; i++) 
{ 
// printf("%5d",**(p+i)); 
printf("%5d",**p); 
p++; 
}
printf("\n"); 
}
int main() 
{ 
fun1(); 
fun2(); 
} 

• main函数的原型

• 定义：main函数有多种定义格式，main函数也是函数，函数相关的结论对main函数也有效（也可以定义main函数的函数指针）。
• main函数的完整写法：

int main(int argc,char *argv[]){} 
int main(int argc,char **argv){}

• 扩展写法

int main(){} 
int main(void){} 
void main(){} 
main(){} ---- int main(){} 
void main(void){} 
int main(int a){} 
int main(int a,int b,int c){} 
... 

•          argc：存储了参数的个数
  • argv：存储了所有参数的字符串形式

• 注意：如果一个函数没有写返回值类型，这个函数的默认返回类型是int。

案例：

/**
* main函数 
*/ 
#include "stdio.h" 
int main(int argc,char **argv) 
{ 
int k; 
for (k=1;k < argc;k++) 
printf("%s\n",argv[k]); 
} 

常量指针与指针常量

常量：分为字面量和只读常量，字面量（就是我们平时直接操作的如：printf("12")|printf("hello");只读常量使用关键字const修饰，凡是被这个关键字修饰的变量，一旦赋值，值就不能改变

语法：

//字面常量举例,字面常量是一种匿名的常量
printf（12）；
printf（"请输入一个数：\n"）;

//只读常量
const int a = 10;
a = 21;//编译错误，因为此时这个变量是只读常量，所以不可更改其值

常量指针

定义：常量的指针，本质是一个指针，指针指向的数据不能改变

定义格式：

const 数据类型 *变量名；

举例：

const int *p; //p就是常量指针

结论：

1.常量指针指向的数据不能改变（不能解引用间接修改数据）

2.常量指针的地址可以改变

应用场景：作为形式参数，实际参数需要给一个常量。

案列：

#include <stdio.h> 
/* 常量指针 */ 
void test1() 
{ 
// 定义变量 
int a = 10; 
// 定义常量指针 
const int *p = &a; 
// *p = 100; // 编译报错，常量的值不能修改（常量指针指向地址空间的数值不能修改） 
printf("%d\n",*p);// 10 
int b = 90; 
p = &b; // 编译通过，常量的地址可以修改（常量指针指向的地址空间可以发生改变） 
printf("%d\n",*p);// 90 
}
int main() 
{ 
test1(); 
} 

指针常量

定义：指针的常量，指针的指向不能改变

定义格式：

数据类型 *const 变量名；

举例：

int* const p;//指针常量

结论：

1.指针常量的指向不能被改变（不能给指针变量重新赋地址值）

2.指针常量指向的数据可以改变

注意：指针常量在定义时就要赋值；不能先定义后赋值，否则编译报错

案例：

/**
* 常量指针与指针常量 
*/ 
#include <stdio.h> 
/* 指针常量 */ 
void test2() 
{ 
// 定义变量 
int a = 10; 
// 定义指针变量 
int* const p = &a; 
// 错误写法：先定义，后赋值（编译报错） 
// int* const p; 
// p = &a; 
// 间接取数据 
pirntf("%d\n",*p); 
// int b = 200; 
// p = &b;// 编译报错，地址不能改变 
*p = 200; 
printf("%d\n",*p);// 200 
}
int main() 
{ 
test2(); 
} 

常量指针常量

• 定义语法：

 const 数据类型* const 变量名;

举例：

 const int* const p; // 常量指针常量