11.12

指标与const

  1. char a[]="test";
  2. char *b="test";
  3. const char *c="test";
  5. a[0]='T';   
  6. b[0]='T';    //未定义行为，一般要加const
  7. C[0]='T';    //编译失败
  9. a=b;     //阵列不能直接赋值
  10. a=c;     //同上
  11. b=a;     //合法
  12. b=c;     //不合法，如果把c给b,那么就可以通过b来修改c,const不能把值给一个能被修改的值
  13. c=a;     //合法，a会显隐性转型为指标，在转换为带const的指标
  14. c=b;     //与c=a同理

可以把字元指标转换为const字元指标，从可读可写变为只可读

字串的复制

  1. #include<stdio.h>
  2. #include<string.h>
  4. int main(){
  5.     char source[5]="test";
  6.     char *destination;
  7.                       //浅复制，实则是同一份
  8.     destination=source;   //利用了隐形转型
  10.     printf("%s\n",destination);
  11.     return 0;
  12. }

使用strcpy来复制字串

  1. #include<stdio.h>
  2. #include<string.h>
  4. int main(){
  5.     const char *source="test";   //==char sourse[5]="test"
  6.     char *destination;   //是错误的，没有宣告存字元的空间，而直接存了位置
  7.     strcpy(destination,source);
  8.     return 0;
  9. }
  1. #include<stdio.h>
  2. #include<string.h>
  4. int main(){
  5.     const char *source="test";   //==char sourse[5]="test"
  6.     char destination[5]; 
  7.     strcpy(destination,source);  //隐形转型后传进来
  8.     return 0;
  9. }

指标阵列

int v[3];

int *p[3]={&v[0],&v[1],&v[2]};

  1. int v[3];
  2. int *p=v;
  4. int i;
  5. for(i=0;i<3;i++){
  6.     p[i]=0;      //令阵列中的每一个都等于0   ==*p[i]=0;
  7. }

指标阵列中可存乱序的阵列位置，可存几个整形的地址，可存几个阵列的开头位置等

  1. int a[4];
  2. int b[2];
  3. int c[2];
  5. int *p[3]={a,b,c}    //隐形转型
  7. int i,j;
  8. for(i=0;i<3;i++){
  9.     for(j=0;j<2;j++){     //循序存取
  10.         p[i][j]=0;
  11.     }
  12. }
  13. //随机存取
  14. p[0][2]=9;    //p[0]指a[0],(p[0])[2]就相当于(a[0])[2]==a[2],即a[2]=9
  15. p[1][2]=10;  //不存在b[2]，是未定义行为

阵列的指标

  1. int v[3]={1,2,3};
  3. int (*q)[3]=&v;
  4. int i,j;
  5. for(i=0;i<3;i++){
  6.     (*q)[i]=0
  7. }
  8. (*q)[2]=5;
  1. #include<stdio.h>
  2. void print(int (*q)[3]);
  4. int main(){
  5.     int v[3]={1,2,3};
  6.     print(&v);
  7.     return 0; 
  8. }               //其实就是传递阵列
  10. void print(int (*q)[3]){
  11.     int i;
  12.     for(i=0;i<3;i++){
  13.         printf("%d",(*q)[i]);
  14.     }
  15. }

在函式间传递阵列

  1. #include<stdio.h>
  2. void print(int (*q)[5]);
  4. int main(){
  5.     int v[5]={1,2,3,4,5};
  6.     print(&v);
  7.     return 0;
  8. }
  9. void print(int (*q)[5]){
  10.     int i;
  11.     for(i=0;i<sizeof(*q)/sizeof((*q)[0]);i++){
  12.         printf("%d",(*q)[i]);
  13.     }
  14. }