11.11

11.11

计算字串的长度

#include<stdio.h>
 int  str_len(char str[]){
     int i=0;
     while(ste[i]!='\0'){
         i++;
     }
     return i;
 }
int main(){
    char str_[i]="hello world";  //当字串数字恰好等于不加'\0'是的长度时，即i=11时，语法合法，但此阵列不能运用于函式中。当i=15时，系统将会自动补'\0'。
    printf("length:%zu\n",sizeof(str));   //有的版本用%u或%lu
    printf("length:%d\n",str_len(str));
    return 0;
}

输入一段字串

#include<stdio.h>
void readch(char[]);
int main(){
    char str[15];
    readch(str);
    printf("%s\n",str);
    return 0;
}
void readch(char str[]){
    int i=0;
    while(1){
        scanf("%c",&str[i]);
        if(str[i]=='\n')
          break;
        i++;
    }
    str[i]='\0';     //将\n换为\0
}

当输入字串时，没有立马存入记忆体中，而是先存在stdin中，当按enter后，scanf会去stdin中找新录入的东西

解决溢位的问题

#include<stdio.h>
void readch(char[],int);
int main(){
    char str[15];
    readch(str,14);
    printf("%s\n",str);
    return 0;
}
void readch(char str[],int){
    int i=0;
    for(i=0;i<n;i++){
        scanf("%c",&str[i]);
        if(str[i]=='\n')
          break;
    }
    str[i]='\0';
}

但是scanf会忽视空格

当输入格式错误时

#include<stdio.h>
int main(){
    int num;
    whilr(scanf("%d",&number)!=1){
       printf("Error: invalid input\n");
    }
    printf("%d\n",num);
    return 0;
}

但失败后，错误的格式仍然留在stdin中，再次输入时仍然会错误

字串在函式中传递时也不能复制，且也不能a=v直接将字串赋值

指标

指标是一种资料型别，用来存储记忆体位址

宣告语法

int *a; 存储int值得位置

int **b; 存储*b的位置即存储存储b位置的位置

double *c=&d 找出d的位置存储在*c里

取址运算子：&

间接运算子：*

A=8

*Aaddr 中*是一个运算，取Aaddr所存的记忆体的位址上的值，即取得以该记忆体位址起始得变数

即*Aaddr==8

Aaddr=9 时，A的值也会改变，即此时A==9

*&*&*&*&*&A *&可以相消

当函式中复制的是位置是，就可以把本尊改掉

#include<stdio.h>
void swap(int *a,int *b);
int main(){
    int a=3,b=5;
    swap(&a,&b);
    printf("%d,%d",a,b);
    return 0;
}              //交换两个值
void swap(int *a,int *b){
    int t;
    t = *a;
    *a = *b;
    *b = t;
}

#include<stdio.h>
void sort(int *,int *);
void swap(int *,int *);
int main(){
    int a,b;
    scanf("%d %d",&a,&b);
    sort(&a,&b);
    printf("%d,%d\n",a,b);
    return 0;
}
void sort(int *a,int *b){     //排序
    if(*a>*b){
        swap(a,b); 
    }
}
void swap(int *a,int *b){
    int t;
    t = *a;
    *a = *b;
    *b = t;
}

能复制值就不要复制位置

int a[5];
&a[0]+1==&a[1];
&a[1]-1==&a[0];
&a[0]+&a[1];      //不合法
&a[5]-&a[2]==3;    //合法，表示有几个间隔

阵列性别可隐形转换为该阵列第一个元素记忆体位址的指标

int v[5];
int *n=v;
n  ==&v[0];        *n    ==v[0];// *n=0即v[0]=0
n+1==&v[1];        *(n+1)==v[1];
n+2==&v[2];        *(n+2)==v[2];

循序存取阵列元素

#include<stdio.h>
int main(){
    intv[5]={1,2,3,4,5};
    int *n=v;
    while(n!=){
        printf("%d\n",*n++);    //*（p++）
    }
    return 0;
}

a[b]就是*（a+b）阵列在函式间的传递就是利用次

int v[5];
int *n=v;
n[0]==*n;   //等同于v[0]
n[1]==*(n+1);

int main(){
    int v[5];
    int *p=v;
    while(p!=v+5){    //v+5:v隐形转型成了指标，就相当于&v[5]
        *p++=0;
    }
    return 0;
}

双引号可直接隐形转型为指标

指标与字符串

char strA[]="test";  //宣告了一个字串
char *strB = "test";  //没有宣告，直接取了地址，系统会自动分配一个位置来存储这个字串

strA[0] ='T';  
strB[0] ='T';  //  是未定义行为，因为是系统给分配的空间，只能读取，不能改动，但能整串换掉

strA ="Test";  //编译失败，，阵列不能直接赋值，阵列变数不能放到等号的左边
strB ="Test";  //会在存储一份，而不是覆盖原来的

const修饰字

资料型别被const修饰的变数在初始化之外不能再被赋值

const int b = 5;

const int b[3]={5,6,7};