const的使用方法：

有时候我们希望定义这样一种变量，它的值不能被改变，在整个作用域中都保持固定。例如，用一个变量来表示班级的最大人数，或者表示缓冲区的大小。为了满足这一要求，可以使用const关键字对变量加以限定。

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>


typedef struct MyStruct
{
	int a;
	int b;
}MyStruct;

void fun(MyStruct* p)
{
	//指针可修改
	//p = NULL;//ok
	//指针指向的内存可修改
	//p->a = 10;//ok

}
void fun1(MyStruct const* p)
{
	//p = NULL;//ok
	//p->a = 10;//err
}
void fun2(MyStruct* const  p)
{
	//p = NULL;//err
	//p->a = 10;//ok
}
//p只读
void fun3(const MyStruct* const  p)
{
	MyStruct temp;
	temp.a = p->a;
}
int main()
{
	//const修饰一个变量为只读
	const int a = 10;
	//a = 100;//err  不可修改

	//指针变量，指针指向的内存是不同的概念
	char buf[] = "asdqwer";
	
	//从左往右看，跳过类型，看修饰哪个字符
	//如果是*，说明指针指向的内存不可修改
	//如果是指针变量，说明指针的指向不可修改

	const char* p = buf;
	//char const* p2 = buf; 与上等价
	//p[1] = '2';//err
	p = "qqqqwwww";//ok

	char* const p2 = buf;
	p2[1] = '3';
	//p2 = "asdasd";//err

	//p3为只读，指向不可修改，指向的内存也不可修改
	const char* const p3 = buf;
	//如何引用其他.c文件中的const 的变量
	extern const int aa;//不能赋值，只能声明
	printf("aa=%d\n", aa);

	//const修饰的变量 定义时初始化
	//c语言中 const通过间接赋值可以被修改
	const int b = 10;
	//b=100;//err
	int* q = &b;
	*q = 22;
	printf("%d,%d\n", b, *q);
    return 0;
}

二级指针作为函数参数的输出特性

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>

int getMem(char*p)
{
    p = (char*)malloc(sizeof(char) * 100);
    if (p==NULL)
    {
        return -1;
    }
    strcpy(p, "asd");
    printf("p=%s\n", p);
    return 0;

}


int getMem2(char** p)
{
    if (p==NULL)
    {
        return -1;
    }
    char* temp = (char*)malloc(100);
    if (temp==NULL)
    {
        return -2;
    }
    strcpy(temp, "Aaaaaaaa");
    *p = temp;
   
    return 0;
}


int main()
{
    char* p = NULL;
    int ret = 0;

    ret = getMem2(&p);
    if (ret!=0)
    {
        printf("getMem err:%d\n", ret);
        return ret;
    }
    printf("p=%s\n", p);

    if (p != NULL)
    {
        free(p);
        p = NULL;
    }
    return 0;
}

二级指针作为输入的内存模型①

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>


int main0401()
{
    //每个类型都是 char*
    char* p0 = "111111";
    char* p1 = "222222";
    char* p2 = "aaaaaa";
    char* p3 = "wwwwwww";
   
    //指针数组，指针的数组，它是一个数组，每个元素都是指针
    char* p[] = { "111111","222222","aaaaaa","wwwwwww" };
    //p[0]="111111"
    int n = sizeof(p) / sizeof(p[0]);//   16/4=4
    printf("sizeof(p)=%d\nsizeof(p[0])=%d\n", sizeof(p), sizeof(p[0]));

    for (int i=0 ; i < n; i++)
    {
        printf("%s\n", p[i]);
    }

    char* q[10] = { "111111","222222","aaaaaa","wwwwwww" };
    printf("sizeof(q)=%d\nsizeof(q[0])=%d\n", sizeof(q), sizeof(q[0]));// 40   4

    return 0;
}


int main0402()
{

    //指针数组，指针的数组，它是一个数组，每个元素都是指针
	char* p[] = { "222222","111111","wwwwwww","aaaaaa" };
    //char**q = { "222222","111111","wwwwwww","aaaaaa" };//err
    //p[0]="111111"
    int n = sizeof(p) / sizeof(p[0]);
    int i = 0;
    int j = 0;
    int* temp = NULL;

    printf("排序前：\n");
    for (i = 0; i < n; i++)
    {
        printf("%s ,", p[i]);
    }
    printf("\n");
    //选择法排序
    for (i = 0; i < n - 1; i++)
    {
        for (j = i + 1; j < n; j++)
        {
            if (strcmp(p[i], p[j]) > 0)
            {
                temp = p[i];
                p[i] = p[j];
                p[j] = temp;
            }
        }
    }
    printf("\n排序后：\n");
    for (i = 0; i < n; i++)
    {
        printf("%s ,",p[i]);
    }
    printf("\n");
    return 0;
}

//void test(int a[])
void test(int* a)
{

}

void fun()
{
    int a[10];
    test(a);

}

//void print_Array(char* p[],int n)
void print_Array(char** p, int n)
{
    for (int i = 0; i < n; i++)
    {
        printf("%s ，", p[i]);
    }
    printf("\n");
}


void sort_Array(char** p, int n)
{
    char* temp;
    for (int i = 0; i < n - 1; i++)
    {
        for (int j = i + 1; j < n; j++)
        {
            if (strcmp(p[i], p[j]) > 0)
            {
                temp = p[i];
                p[i] = p[j];
                p[j] = temp;
            }
        }
    }
}

int main()
{
    //指针数组，指针的数组，它是一个数组，每个元素都是指针
    char* p[] = { "222222","111111","wwwwwww","aaaaaa" };
    //char**q = { "222222","111111","wwwwwww","aaaaaa" };//err
    //p[0]="111111"
    int n = sizeof(p) / sizeof(p[0]);

    printf("排序前：\n");
    print_Array(p, n);

    sort_Array(p, n);

    printf("排序后：\n");
    print_Array(p, n);

    return 0;
}

二级指针作为输入的内存模型②

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>


int main0501()
{
    char a0[30] = "1111111111111";
    char a1[30] = "222222222222222";
    char a3[30] = "sssssssssssssss";
    char a4[30] = "cccccccccccccccc";

    //4个a[30]的一维数组
    //二维数组，可以省略第一个[]数组括号中的值，前提需要初始化完成
    //a代表首行地址，首行地址与首行首元素地址有区别，值相同g
    //区别：步长不同
    char a[][30] = { "1111111111111" ,"222222222222222" ,
    "sssssssssssssss" ,"cccccccccccccccc" };
    //a[0] = "111111111111111111111"
    printf("a:%d,a+1:%d\n", a, a + 1);

    char b[30];
    printf("&b:%d,&b+1:%d\n", &b, &b + 1);//相差30
    printf("b:%d,b+1:%d\n", b, b + 1);


    for (int i = 0; i < 4; i++)
    {
        printf("a[%d]=%s\n",i, *(a+i));//首行地址与首行首元素的地址相同
    }
    int n = sizeof(a) / sizeof(a[0]);
    printf("n=%d\n", n);

    return 0;
}


void print_Array(char a[][30],int n)
{
    printf("a:%d,a+1:%d\n",a,a+1);//步长30
    for (int i = 0; i < 4; i++)
    {
        printf("a[%d]=%s\n", i, *(a + i));//首行地址与首行首元素的地址相同
    }

}

void sort_Array(char a[][30], int n)
{
    char temp[30];
    for (int i = 0; i < n - 1; i++)
    {
        for (int j = 0; j < n; j++)
        {
            if (strcmp(a[i], a[j]) > 0)
            {
                //交换的是内存块
                strcpy(temp, a[i]);
                strcpy(a[i], a[j]);
                strcpy(a[j], temp);
            }
        }
    }

}

int main()
{
    char a[][30] = { "1111111111111" ,"222222222222222" , 
                    "sssssssssssssss" ,"cccccccccccccccc" };
    int n = sizeof(a) / sizeof(a[0]);

    printf("排序前:\n");
    print_Array(a,n);

    sort_Array(a, n);

    printf("排序后:\n");
    print_Array(a, n);

    return 0;
}

二级指针做输入的内存模型③

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>


int main0501()
{
    char a0[30] = "1111111111111";
    char a1[30] = "222222222222222";
    char a3[30] = "sssssssssssssss";
    char a4[30] = "cccccccccccccccc";

    //4个a[30]的一维数组
    //二维数组，可以省略第一个[]数组括号中的值，前提需要初始化完成
    //a代表首行地址，首行地址与首行首元素地址有区别，值相同g
    //区别：步长不同
    char a[][30] = { "1111111111111" ,"222222222222222" ,
    "sssssssssssssss" ,"cccccccccccccccc" };
    //a[0] = "111111111111111111111"
    printf("a:%d,a+1:%d\n", a, a + 1);
    char b[30];
    printf("&b:%d,&b+1:%d\n", &b, &b + 1);//相差30
    printf("b:%d,b+1:%d\n", b, b + 1);
    for (int i = 0; i < 4; i++)
    {
        printf("a[%d]=%s\n",i, *(a+i));//首行地址与首行首元素的地址相同
    }
    int n = sizeof(a) / sizeof(a[0]);
    printf("n=%d\n", n);
    return 0;
}
void print_Array(char a[][30],int n)
{
    printf("a:%d,a+1:%d\n",a,a+1);//步长30
    for (int i = 0; i < 4; i++)
    {
        printf("a[%d]=%s\n", i, *(a + i));//首行地址与首行首元素的地址相同
    }
}
void sort_Array(char a[][30], int n)
{
    char temp[30];
    for (int i = 0; i < n - 1; i++)
    {
        for (int j = 0; j < n; j++)
        {
            if (strcmp(a[i], a[j]) > 0)
            {
                //交换的是内存块
                strcpy(temp, a[i]);
                strcpy(a[i], a[j]);
                strcpy(a[j], temp);
            }
        }
    }
}
int main()
{
    char a[][30] = { "1111111111111" ,"222222222222222" 
                    , "sssssssssssssss" ,"cccccccccccccccc" };
    int n = sizeof(a) / sizeof(a[0]);
    printf("排序前:\n");
    print_Array(a,n);
    sort_Array(a, n);
    printf("排序后:\n");
    print_Array(a, n);
    return 0;
}

两个小练习：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>


/*
键值对（"key= value"）字符串，在开发中经常使用
要求1：请自己定义一个接口，实现根据key获取
要求2：编写测试用例
要求3：键值对中间可能有n多空格，请去除空格
注意：键值对字符串格式能如下
keyl= valuel ;
key2=       value2;
key3=value3;
key4      = value4;
key5     =      ;
key6      =;

int getKeyByValue(char *keyvaluebuf, char *keybuf,
char *valuebuf, int valuebuflen)
*/


int trimSpace(char* inbuf, char* outbuf)
{
    if (inbuf==NULL||outbuf==NULL)
    {
        return -1;
    }
    char* p = inbuf;
    int begin = 0;
    int end = strlen(p) - 1;
    int n = 0;;

    if (end<0)
    {
        return -2;
    }

    //从左往右移动，如果当前字符为空，而且没有结束
    while (p[begin]==' '&&p[begin]!=0)
    {
        begin++;//右移一位
    }
    //从右往左移动，如果当前字符为空
    while (p[end]==' '&&end>0)
    {
        end--;
    }
    if (end==0)
    {
        return -3;
    }
    n = end - begin + 1;//非空元素个数
    strncpy(outbuf, p+begin, n);
    outbuf[n] = 0;
    return 0;

}


int getKeyByValue(char* keyvaluebuf, char* keybuf,
    char* valuebuf, int* valuebuflen)
{
    /*
    keyvaluebuf="key4      = value4"
    keybuf="key4"    
    */
    if (keybuf==NULL||keyvaluebuf==NULL||
        valuebuf==NULL||valuebuflen==NULL)
    {
        return -1;
    }
    char* p = NULL;
    int ret = 0;
    //查找匹配键值
    // "key4      = value4"  寻找key4，找到返回首地址
    p = strstr(keyvaluebuf, keybuf);
    if (p==NULL)
    {
        return -2;
    }
    //如果找到了，重新设置起点位置，跳过"key4"
    //p= "      = value4"
    //"key4      = value4"->"      = value4"
    p = p + strlen(keybuf);
    
    //查到=
    p = strstr(p,"=");
    if (p == NULL)
    {
        return -3;
    }
    //如果找到，从新设置起点位置，跳过"="
    //p="= value4"
    //"= value4"->" value4"
    p = p + strlen("=");
    
    //取非空字符
    ret = trimSpace(p, valuebuf);
    if (ret!=0)
    {
        printf("trimSpace err:%d\n", ret);
        return ret;
    }
    //获取长度，通过*间接赋值
    *valuebuflen = strlen(valuebuf);

    return 0;
}

int main()
{
    char* keyVal = "key4      = value4";
    char* key = "key4";
    char value[100] = { 0 };
    int len = 0;
    int ret = 0;
    ret = getKeyByValue(keyVal, key, value, &len);
    if (ret != 0)
    {
        printf("getKeyByValue  err:%d\n", ret);
        return ret;
    }
    printf("val:%s\n", value);
    printf("len:%d\n", len);

#if 0
    char* p = "         saadsqwd         ";
    char buf[100] = { 0 };
    int ret = 0;
    ret = trimSpace(p, buf);
    if (ret!=0)
    {
        printf("trimSpace err:%d\n", ret);
    }
    printf("buf=%s\n", buf);
#endif

    return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>

/*
有一个字符串1a2b3d4z
要求写一个函数实现如下功能
功能1：把偶数位字符挑选出来，组成一个字符串1
功能2：把奇数位字符挑选出来，组成一个字符串2
功能3：把字符串1和字符串2，通过函数参数，传送给main，并打印。
功能4：主函数能测试通过
int getStrlStr2 （char *source, char *bufl, char *buf2）
*/
int getStrlStr2(char* source, char* buf1, char* buf2)
{
    if (source == NULL || buf1 == NULL || buf2 == NULL)
    {
        return -1;
    }

    int n = strlen(source);//字符串长度
    int i = 0;
    for (i = 0; i < n; i++)
    {
        //如果是奇数为
        if ((i%2)!=0)
        {
            *buf1=source[i];//*(source+i)
            buf1++;
        }
        else  //如果是偶数位
        {
            *buf2 = source[i];//*(source+i)
            buf2++;
        }
    }
    //没有结束符
    *buf1 = 0;
    *buf2 = 0;
    return 0;
}

int main()
{
    char* p = "1a2b3d4z";
    char buf1[50] = { 0 };
    char buf2[50] = { 0 };
    int ret = 0;
    ret = getStrlStr2(p, buf1, buf2);
    if (ret != 0)
    {
        printf("getStrlStr2 err:%d\n",ret);
        return ret;
    }
    printf("buf1=%s\n", buf1);
    printf("buf2=%s\n", buf2);
    return 0;
}