嵌入式C语言数组，str函数实现

数组 一组数据类型相同的数据 定义方式（数据类型+变量名[常量]）

数组中所有的数据都是相同的数据类型 int a[10]={0}
数组中的元素的首地址都是连续的 a[0]=0x0000;a[1]=0x0004(位数跟数据类型有关)

C语言不允许使用变量的值进行动态定义，
赋初值的方式：

1. 在定义时赋值；
2. 循环赋值

数组与指针的联系：

1. 数组的名字是可以当成指针使用的 （a:数组首元素的地址）
2. 数组作为函数参数被传递的时候，数组名会被弱化成指针

#include<stdio.h>

void fun(int a[10])
{
printf("%d\n",sizeof(a)); //数组名被弱化成指针
}
int main()
{
void fun();
int a[10]={0};
printf("%d\n",sizeof(a));//计算整个数组的大小
printf("%d\n",sizeof(*a));//计算a[0]的大小
printf("%d\n",sizeof(&a));//计算指针的内存大小
fun(a);
}
`
a = &a[0] a+1=&a[1]
&a表示整个数组的首地址 &a+1越过这个数组的下一个地址

二维数组 ：打印杨辉三角

#include<stdio.h>
int main()
{
    int i,j,n;
    int a[100][100];
    printf("需打印几行");
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        a[i][0]=1;//第1列为1
        a[i][i]=1;//每列最后1个为1

        for(j=1;j<=i;j++)//核心算法
             a[i+1][j]=a[i][j]+a[i][j-1];

        for(j=0;j<n-i;j++)//正三角
            printf(" ");

        for(j=0;j<=i;j++)//打印
            printf("%d ",a[i][j]);

        printf("\n");
    }
    return 0;
}

字符数组 char str[]

进行字符串计算时，需要留够字符数组的空间，否则会显示错误

strcmp

:是对两个字符串的逐个字符进行比较。

int mycmp(char* str1,char* str2)
{
    unsigned char c1, c2;
    if(NULL == str2 || NULL == str1)//判断是否为空指针
    {
        return ;
    }
    while (1) {
        c1 = *str1++;
        c2 = *str2++;
        if (c1 != c2)
        {
            if(c1>c2);
                return c1-c2;
            if(c1<c2);
                return c2-c1; 
        }      
        if (!c1&&!c2)
            break;
    }
    return 0;
}

strcat

:是把所指向的字符du串（包括“\0”）复制到dest所指向的字符串后面（删除原先字符串的\0”）下面将str2复制到str1后面

void mycat(char* str1,char* str2)
{
    if(NULL == str2 || NULL == str1)
    {
        return ;
    }
    else
    {
        int len1 = mylen (str1);
        int len2 = mylen (str2);
        int i;
        for(i=len1;i <len1 + len2 ; i++)
        {
            *(str1+i)=*(str2 + (i -len1));
        }
        *(str1+len1+len2)='\0';
    } 
}

strcpy:

将后面的字符串复制到前面

void mycpy(char *str1, char* str2)
{
    if(NULL == str2 || NULL == str1)
    {
        return ;
    }
    else
    {
        int len = mylen(str2);
        int i;
        for(i = 0; i < len ; i++)
        {
            *(str1+i) =*(str2+i);
        }
        *(str1+len) = '\0';
    }
}

strlen:

输出一个字符串长度，不包含’/0‘

int mylen(char *str)
 {
     int count = 0;
     char* tmp = str;
    if ((NULL == str))
    {
        return 0;
    }
    while(*tmp !='\0')
    {
        count ++;
        tmp++;
    }
    return count;
 }

指针数组：int *a[10]

1. 本质是一个数组
2. 每个指针指向的内存是连续的
3. 每个指针的本身的地址也是连续的

#include<stdio.h>
int main()
{
    char *s[10];
    s[0]="suqian";
    s[1]="jiaoyu";
    printf("%c\n",*s[0]);
    printf("%c\n",*(s[0]+1));
    printf("%c\n",*s[0]+1);
    printf("%c\n",*(s[0]+6));
    printf("%c\n",*(s[0]+7));
    printf("%c\n",**(&s[0]+1));
}
结果
s
u
t

j
j：**(&s[0]+1)-**(&s[1])-*s[1]-取s的首个元素地址的值j

数组指针：int（*a）

本质是一个二级指针

#include<stdio.h>
int main()
{
    int a[6]={1,2,3,4,5,6};
    int (*p)[6];
    p=&a;
    printf("%d\n",*(*p+1));
}
结果：2

函数指针：void （*fun）（int）

是一个指针，指向函数

#include <stdio.h>
void function(int i, double d)    //一个函数的声明
{
    printf("函数运行, %d, %lf\n", i, d);
}
void AnotherFunction(int i, double d)    //另外一个函数声明
{
    printf("又一个函数运行, %d, %lf\n", i, d);
}
int main()
{
    void (*pFun)(int, double);    //定义了一个函数指针

    pFun = function;    //让这个函数指针指向第一个函数
    pFun(10, 10.101);    //通过这个函数指针来调用第一个函数
     
    pFun = AnotherFunction;    //让这个函数指针指向第二个函数
    pFun(20, 20.202);    //通过这个函数指针来调用第二个函数
     
    return 0;
}
结果
函数运行, 10, 10.101000
又一个函数运行, 20, 20.202000

指针函数：int* fun（）

带有指针的函数，即其本质是一个函数，只不过这种函数返回的是一个对应类型的地址。指针指向的不能是全局变量

#include<stdio.h>
int *GetDate();  
int * aaa(int,int);
//函数返回的是一个地址值，经常使用在返回数组的某一元素地址上。
int * GetDate(int wk,int dy);  
int main()
{  int wk,dy;
do {  
    printf("Enter week(1-5)day(1-7)\n");  
    scanf("%d%d",&wk,&dy);
}  while(wk<1||wk>5||dy<1||dy>7);
printf("%d\n",*GetDate(wk,dy));  }
int * GetDate(int wk,int dy)  
{
    static int calendar[5][7]=  {
    {1,2,3,4,5,6,7},  {8,9,10,11,12,13,14},
    {15,16,17,18,19,20,21},  {22,23,24,25,26,27,28},
    {29,30,31,-1}  };
    return &calendar[wk-1][dy-1]; 
} 
结果
Enter week(1-5)day(1-7)
4 3
24