#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include "socketclient.h"

int main()
{
    
    
    printf("\n");
    system("pause");
    return 0;
}

#include<stdlib.h>
#include<stdio.h>
#include<string.h>

int main()
{
    int a[]={10,7,1,9,4,6,7,3,2,0};
    int n;
    int i=0;
    
    n=sizeof(a)/sizeof(a[0]);	//元素个数
    
    printf("排序前：")；
    for(i=0;i<n;i++)
    {
        printf("%d ",a[i]);
        
    }
    printf("\n");
    
    //选择法排序：每一次把当前序列中最小的数放到当前序列最前面
    for(i=0;i<n-1;i++)
    {
        for(int j=i+1;j<n;j++)
        {
            if(a[i]>a[j])
            {
                int temp=a[i];
                a[i]=a[j];
                a[j]=temp;
            }
        }
    }
    
    printf("排序后：")；
    for(i=0;i<n;i++)
    {
        printf("%d ",a[i]);
        
    }
    
    printf("\n");
    system("pause");
    return 0;
}

void print_array(int a[10],int n)		//在这里，数组形参使用 int a[10], int a[2], int a[] 或者 int* a都是一样的，传入的都是数组的首地址
{
	return;
}

int main()
{
    int a;			//告诉编译器分配 4 个字节
    int b[10];		//告诉编译器分配 4*10 个字节
    //类型的本质是固定大小内存的别名
    
    printf("sizeof(a)=%d\nsizeof(b)=%d\n",sizeof(a),sizeof(b));		//4 40
    
    //打印地址
    printf("b:%d	&b:%d\n",b,&b);		//数组名字就是数组首元素地址，数组首地址		两个输出一样的
    
    
    //b 和 &b 的数据类型不一样
    //b，数组首元素地址，一个元素 4 字节，+1 -> +4
    //&b，整个数组的首地址，一个数组 4*10=40字节，+1 -> +40
    printf("b+1:%d	&b+1:%d\n",b+1,&b+1);		//14678444 14678480
    
    //指针类型长度，32位为4, 64位为8
    char *****************p=NULL;
    int *q=NULL;
    printf("%d %d\n",sizeof(p),sizeof(q));		//32位：4 4		64位：8 8
    
    return 0;
}

typedef unsigned int u32;

//typedef 通常和结构体一起使用
typedef struct	myStruct		//这里的 myStruct 可写可不写
{
    int a;
    int b;
}TMP;
int mian()
{
    u32 t;				//unsigned int t;
    return 0;
}

int main()
{
    int a;
    
    //变量相当于门牌号，内存相当于房间
    //直接赋值
    a=10;
    
    pringf("a=%d\n",a);		//10
    
    //间接赋值
    pringf("&a=%p\n",&a);		// a的地址
    p=&a;
    pringf("p=%p\n",p);		// a的地址
    
    *p=22;
    pringf("a=%d\n",a);		//22
    pringf("*p=%d\n",*p);		//22
    
    return 0;
}

char *get_str1()
{
    char *p="abcdef";		//文字常量区
    return p;
}

char *get_str1()
{
    char *q="abcdef";		//文字常量区
    return q;
}

int main()
{
    char *p=NULL;
    char *q=NULL;
    
    p=get_str1();
    
    //%s，打印指针指向的内存区域的内容
    //%d，打印 p 本身的值
    printf("p=%s, p %d\n",p,p);			//p=abcdef,p=一串地址
    
    q=get_str2();
    printf("q=%s, q %d\n",q,q);			//q=abcdef,q=一串地址，且这个地址和p的地址一样
    
    //主函数里面的p和 get_str1里面的p对应不同的内存
    //全局区相同的常量只存在一份，因此主函数里面的 p 和 q 指向同一块内存
    
    return 0;
}

char* get_str()
{								//字符串 "sdskcnckjana" 是存放在全局区
    char str[]="sdskcnckjana";		//栈区，函数结束，内存销毁，主函数中复制内存的内容，因此复制到的内容是不确定的，可能是原本的内容，也可能是乱码
    							
    							//这里在 char str[]="sdskcnckjana" 之后，会拷贝一份字符串到栈区
    return str;
}

int main()
{
    char* buffer[128]={0};
    
    strcpy(buffer,get_str());
    printf("%s\n",buffer);		//打印的结果：不确定，即乱码,这里还有可能输出 sdskcnckjana，是因为这里拷贝的时候可能 get_char 还没有销毁
    return 0;
}

char* get_str()
{								//字符串 "sdskcnckjana" 是存放在全局区
    char str[]="sdskcnckjana";		//栈区，函数结束，内存销毁，主函数中复制内存的内容，因此复制到的内容是不确定的，可能是原本的内容，也可能是乱码
    printf("%s\n",buffer);		//打印的结果：sdskcnckjana
    							
    							//这里在 char str[]="sdskcnckjana" 之后，会拷贝一份字符串到栈区
    return str;
}

int main()
{
    char* buffer[128]={0};
    
    char* p=NULL;
    p=get_str();
    printf("%s\n",buffer);		//打印的结果：不确定，即乱码
    
    return 0;
}

char* get_str()
{								//字符串 "sdskcnckjana" 是存放在全局区
    char str[]="sdskcnckjana";		//栈区，函数结束，内存销毁，主函数中复制内存的内容，因此复制到的内容是不确定的，可能是原本的内容，也可能是乱码
    printf("%s\n",buffer);		//打印的结果：sdskcnckjana
    							
    							//这里在 char str[]="sdskcnckjana" 之后，会拷贝一份字符串到栈区
    return str;
}

char* strget2()
{
    char *temp=(char*)malloc(100);		//堆区分配空间
    
    if(temp==NULL)
        return NULL;
    strcpy(tmp,"snjcscsdmkcs");
    //在这里，字符串"snjcscsdmkcs"存放在全局区，temp存放在栈区，指向一块堆区的内存，strcpy之后，会拷贝一份字符串"snjcscsdmkcs"到temp指向的堆区内存
    //get_str2函数运行完毕之后，p也会指向temp指向的堆区内存，并且会释放指针temp，但是temp指向的内存不会释放，需要手动释放
    return temp;
}
int main()
{
    char* buffer[128]={0};
    
    char* p=NULL;
    p=get_str2();
    if(!p)
    {
        printf("%s\n",buffer);		//打印的结果：snjcscsdmkcs
        free(p);		//释放p之前，这块堆内存使用权归p，释放之后，使用权归操作系统，但是内部的内容依然存在，直到下次被写才会改变，并且释放p之后，p依然指向这块堆区域，只是p指向的堆内存可以由系统支配了，所以一般指针释放之后，会将其指向空指针
        p=NULL;
    }
    	
    
    return 0;
}

int *getA()
{
    static int a=10;	//a是一个局部的静态变量，函数结束，内存不释放，因此只要把地址传出去，就可以通过地址使用这个内存了
    return &a;
}

int main()
{
    int *p=getA();		//通过地址使用局部静态变量
    
    return 0;
}

int main()
{
    int a=100;
    int *p=NULL;
    int p1=NULL;
    char *********q=0x1111;
    
    //指针指向谁，就把谁的地址赋值给指针
    p1=&a;
    //通过星号可以找到指针指向的内存区域，操作的还是内存
    //星号放在等号的左边，给内存赋值，写内存
    //星号放在等号的右边，取内存赋值，读内存
    *p1=22;
    
    printf("%d %d\n",sizeof(p),sizeof(q));		//32位系统：4 4
    return 0;
}

int main()
{
    void* p;
    char buf[1024]="aancnciwce";
    p=buf;
    //void* 类型的指针在使用的时候需要转换成实际的类型
    printf("%s\n",(char*)p);
    
    int a[100]={1,2,3,4};
    p=a;
    int i=0;
    //void* 类型的指针在使用的时候需要转换成实际的类型
    for(i=0;i<4;i++)
    {
        printf("%d ",*((int*)p+i));
    }
    
    int b[3]={1,2,3};
    int c[3];
    memcpy(c,b,sizeof(b));		//void* 类型的指针转换成了 int*
    for(i=0;i<3;i++)
    {
        printf("%d ",c[i]);
    }
    
    char *q=NULL;			//#define NULL ((void*)0)，这里实际上q没有具体的指向，所以给q指向的内存赋值就会报错
    
    /*
    //加上这样两句，就可以给q 一个具体的指向，再给其指向的内存赋值，就没问题了
    char str2[100]={0};
    q=str2;
    */
    
    //给 q 指向的内存区域赋值
    strcpy(q,"1234");		//err
    
    return 0;
}

//防止头文件重复包含
#pragma once

//例如，有两个头文件 a.h 和 b.h，且在 a.h 中包含了 b.h，在 b.h 中包含了 a.h，那么会出现头文件包含的死循环，导致文件包含过多的错误

//不添加兼容 C++，使用 C++ 语言的程序调用 C 语言的程序的语句，编译的时候不会有问题，但是使用的时候会有问题。添加了之后，可以不做任何改动，直接使用

char *buf="nscnscnwsicw";	//指针直接指向文字常量区
buf2[2]='l';			//err，因为这个字符串存放在文字常量区，内容不可改

char str[]="nsijacnicwc";	//字符串常量本身存放在文字常量区，但是由于字符数组赋值，会复制一份存放在栈区
str[2]='l';				//OK，由于 str 是存放在栈区的字符数组，因此是可修改的

char *p3=NULL;
strcpy(p3,"lll");		//err，如果给 p3 赋值为某一个具体的非法地址，如 0x0001，也会出错，因为这个内存不允许使用
//给 p3 指向的内存区域拷贝内存，但是 p3 为空，没有指向任何有效的内存，因此内存拷贝会出错

int main()
{
    int a=100;
    int *p=NULL;
    
    //建立关系，指针指向谁，就把谁的地址赋给指针了
    p=&a;
    
    //通过 *  操作内存；
    *p=32
        
    return 0;
}

int get_a()
{
    int a=10;
    return a;
}

void get_a2(int a)
{
    a=22;
}

void get_a3(int *a)
{
    *a=33;		//通过星号操作内存
}

void get_a4(int *a1,int *a2,int *a3,int *a4)
{
    *a1=33;		//通过星号操作内存
    *a2=44;
    *a3=55;
    *a4=66;
}

int main()
{

    int a=get_a();
    printf("%d\n",a);		//输出为：10

    get_a2(a);
    printf("%d\n",a);		//输出为：10
    
    //如果想通过形参改变实参的值，必须地址传递
    //实参，形参
    get_a2(a);				//在函数调用时，建立关系
    printf("%d\n",a);		//输出为：33
    
    int a1,a2,a3,a4;
    get_a4(&a1,&a2,&a3,&a4);
    printf("%d %d %d %d\n",a1,a2,a3,a4);
    
    
    
    return 0;
}

void func1(int *p)
{
    p=0xaabb;
    printf("%p\n",p);		//0000aabb
}

void func2(int **p)
{
    *p=0xeeff;				//需要深入理解
    printf("%p\n",p);		//0000eeff
}

int main()
{
    /*
    //一个变量应该定义一个什么类型的指针保存它的地址
    //在原来的基础上再多加一个*
    int a=10;
    int *p=&a;
    int **q=&p;
    
    int *********t=NULL;
    int **********tp=&t;
    */
    int *p=0x1122;
    printf("%p\n",p);		//00001122
    
    func1(p);				//值传递,传递的是指针变量的值
    printf("%p\n",p);		//000011222
    
    func2(&p);				//地址传递，传递的是指针变量的地址
    printf("%p\n",p);		//0000eeff
    
    return 0;
}

void func(char* p)
{
    //给p指向的内存区域拷贝，实际上就是main中的buf
    strcpy(p,"ssvcscac");
}

void func1(char **p,int *len)
{
    if(p==NULL)
        return;
    
    char* tmp=(char*)malloc(100);
    if(tmp==NULL)
        return;
    strcpy(tmp,"cscnsncscna");
    
    //间接赋值
    *p=tmp;
    *len=strlen(tmp);    
}

int main()
{
    //输入：主调函数分配内存
    char buf[100]={0};
    func(buf);
    printf("%s\n",buf);		//ssvcscac
    
    char *p=NULL;
    func(p);		//err，不能给空或者非法未知内存拷贝
    
    //输出：被调用函数分配内存,要想进行内存修改，必须进行地址传递
    char *p1=NULL;
    int len=0;
    func1(&p1,&len);
    if(p)
    	printf("%s	%d\n",p,len);		//cscnsncscna 11
    
    
    return 0;
}

int main()
{
    //不指定长度，且没有结束符
    char buf[]={'a','b','c'};
    printf("%s\n",buf);				//输出完 abc 之后，会输出一串乱码，是因为没有字符数组没有指定长度，且末尾没有字符串结束符
    //指定长度，后面没有赋值的元素会自动补零
    char buf1[100]={'a','b','c'};
    printf("%s\n",buf1);			//输出：abc
    
    //所有元素都赋为零
    char buf3[100]={0};
    
    char buf4[2]={'a','b','c'};		//err，数组越界
    
    char buf5[50]={'1','a','b',0,'7'};		//{'1','a','b','\0','7'} 这样赋值也是一样的结果
    printf("%s\n",buf6);			//输出：1ab
    
    //常用的字符串初始化
    char buf6[]="sdnsjkcnsjcs";
    //strlen 计算字符串长度，不包括字符串结束符
    //sizeof 计算的是数组长度
    printf("strlen=%d\n,sizeof=%d\n",strlen(buf6),sizeof(buf6));		//12 13
    
    char buf7[100]="sdnsjkcnsjcs";
    printf("strlen=%d\n,sizeof=%d\n",strlen(buf7),sizeof(buf7));		//12 100
    
    return 0;
}

int mian()
{
	char buf[]="sdncscwckamcaskc";
    
    //数组方式访问字符串元素
    int i=0;
    for(i=0;i<strlen(buf);i++)
    {
        printf("%c",buf[i]);
    }
    printf("\n");
    
    //指针方式访问字符串元素
    //数组名就是数组首地址
    char *p=buf;
    for(i=0;i<strlen(buf);i++)
    {
        printf("%s",*(p+i));		//这种写法也可以：printf("%s",p[i]);
    }
    printf("\n");
    
    for(i=0;i<strlen(buf);i++)
    {
        printf("%s",*(buf+i));
    }
    printf("\n");
    
    //p和buf完全等价吗？
    //并不是，buf是一个指针常量，不能修改，而p可以修改，这是为了保证数组的内存可以回收（编译器实现就这么规定的）
    p++;		//OK
    buf++；		//err
        
    
    return 0;
}

void my_strcpy(char *dst,char *src)
{
    int i=0;
    
    for(i=0;isrc[i]!=0;i++)
    {
        dst[i]=src[i]
    }
    dst[i]=0;
}

void my_strcpy1(char *dst,char *src)
{
    while(*src)
    {
        *dst=*src;
        src++;
        dst++
    }
    *dst=0;
}

void my_strcpy2(char *dst,char *src)
{
    while(*src)
    {
        *dst=*src;
        src++;
        dst++
    }
    *dst=0;
}

void my_strcpy5(char *dst,char *src)
{
    while(*dst++=*src++);		//先用了再加，写代码不能盲目追求代码简洁，而是应该让代码有足够好的性能和可读性
    *dst=0;
}

//完善字符串拷贝函数
//成功返回0，失败返回非零
//1、判断形参指针是否为空
//2、最好不要直接使用形参
int my_strcpy(char *dst,char *src)
{
    if(!dst||!src)
        return -1;
    
    //赋值变量，把形参备份
    char *to=dst;
    char *from=src;
     while(*from)
    {
        *to=*from;
        from++;
        to++
    }
    *to=0;
   return 0; 
}

int main()
{
    char src[]="ncscnsjicdjv";
    char dst[100];
    
    int ret=my_srtcpy(dst,src);
    if(ret)
    {
        printf("my_strcpy5 err: %d\n",ret);
        return ret;
    }
        
    return 0;
}

int main()
{
    char *p="ncsjcscszmnascnscuicakcnsucn";
    int cnt=0;
    /*
    do
    {
        p=strstr(p."xnasx");
        if(p!=NULL)
        {
            n++;				//累计个数
            //重新设计查找的起点
            p=p+strlen("xnasx");
        }
        else		//如果没有匹配的字符串，跳出循环
        {
            break;
        }
    }while(*p!=0);
    */
    char *p;
    while((p=strstr(p,"xnasx")!=NULL))
    {
        p=p+strlen("xnasx");
        cnt++;
        if(*p==0)
            break;
    }
    printf("%d\n",cnt);
    return 0;
}

typedef struct
{
    int a;
    int b;
}myStruct;
void func(myStruct *p)
{
    //指针能变
    //指针指向的内存的内容也可变
    p->a=10;		//OK
    
}
void func2( const myStruct* p)
{
    p=NULL;		//OK
    p->a=10;		//err
}
void func2(myStruct*   const p)
{
    p=NULL;		//err
    p->a=10;		//OK
}
void func2(const myStruct*   const p)
{
    myStruct tmp;
    p=NULL;		//err
    p->a=10;		//err
    tmp.a=p->a;		//OK
    
}
int main()
{
    //const：修饰一个变量为只读
    const int a=10;
    a=100;			//err
    
    //指针变量，指针指向的内存，2个不同的概念
    char buf[]="nsjcksic sdjhc";
    //从左往右看，跳过类型关键字，如果 const 后面是 *，说明指针指向的内存内容不可以修改；如果 const 后面是指针变量，说明指针变量的值不能修改
    const char* p=buf;		//这个和上面的 char buf[]="nsjcksic sdjhc"; 写法是一致的，都是指针变量可以修改，但是指针指向的内存的内容不可以修改
    //char const *p=buf; 这种写法和上面的是一致的
    p[1]='2';		//err
    p="ncjndscslkcm";		//OK
        
    char* const p2=buf;
    p2[1]="c";			//OK
    p2="cmsdcmsdics";		//err
    
    //p3为只读，指向不能变，指向的内容也不能变
    const char* const p3=buf;
    
    return 0;
}

//如何引用另一个 .c 文件中的 const 变量
extern const int a;		//只能声明，不能再赋值
printf("%d\n",a);

int main()
{
    //无法通过a来修改值，但是可以通过指针来修改
    const int a=10;
    a=100;		//err
    int *p=&b;
    *p=22;
    printf("%d %d\n",a,*p);		//22 22
    
    return 0;
}

int getNUm(char* p)
{
    p=(char*)malloc(sizeof(char)*100);
    if(p==NULL)
        return-1;
    strcpy(p,"cnscnc");
    printf("p=%s\n",p);				//输出：cnscnc
    return 0;						//运行完毕，虽然堆空间没有释放，但是函数中指向堆空间的指针已经销毁，而主函数中的实参并没有指向堆空间，因此在主函数中输出的字符串仍旧为空
}
int getNUm(char** p)		//形参是指向 main 函数中的p的指针，
    //tmp 指向堆空间中的内存，并将文字常量区的字符串复制到 tmp 指向的堆空间，最后使 p 也指向这块堆空间，因此在 main 函数中可以输出这个字符串
{
    if(p==NULL)
        return-1;
    char *tmp=NULL;
    tmp=(char*)malloc(sizeof(char)*100);
    if(p==NULL)
        return-2;
    strcpy(tmp,"cnscnc");
    *p=tmp;
    printf("p=%s\n",p);				//输出：cnscnc
    return 0;						
}

int main()
{
    char *p=NULL;
    int ret=0;
    /*
    ret=getNUm(p);				//值传递，传递的是指针变量
    //值传递，形参的任何改变都不会影响到实参
    */
    
    ret=getNum2(&p);			//地址传递，传递的是指针变量的地址
    //形参修改会影响到实参
    if(ret!=0)
    {
        printf("getNum err:%d\n",ret);
        return ret;
    }
    printf("p=%s\n",p);				//输出：cnscnc
    if(p!=NULL)
    {
        free(p);
        p=NULL;
    }
    return 0;
}

int main()
{
    //指针数组，指针的数组，是一个数组，每一个元素都是指针
    //每个元素都是相同类型的指针
    char *p[]={"11111111","22222222","333333333","44444444"};		//数组 p 有四个元素，每个元素四个字节大小
    char **q={"11111111","22222222","333333333","44444444"};		//err，因为q是一个指针，不能同时指向多个内存，q可以作为形参，但是不可以这么定义赋值
    int n=sizeof(p)/sizeof(p[0]);		// 16/4=4
    printf("%d\n",n);		// 4
    int i=0;
    for(i=0;i<4;i++)
    {
        printf("%s\n",p[i]);		//四个字符串逐一输出
    }
    
    char *q[10]={"11111111","22222222","333333333","44444444"};	
    int m=n=sizeof(q)/sizeof(q[0]);		// 40/4=4
    printf("%d\n",m);		// 10
    char *tmp;
    //选择法对p进行排序
    for(i=0;i<n-1;i++)
    {
        for(int j=i+1;j<n;j++)
        {
            if(strcmp(p[i],p[j])>0)
            {
                tmp=p[i];
                p[i]=p[j];
                p[j]=tmp;
            }
        }
    }
    
    return 0;
}

int test(int a[],int n);
//等价于：
int test(itn* a,int n);

int func(int *p[],int n);
//等价于：
int func(int **p,int n);

void printf_array(char **a,inr n)		//二维数组作为参数，这么写不对
{
    for(int i=0;i<n;i++)
    {
        printf("%s\n",a[i]);		//err
    }
}
void printf_arry1(char a[][30],int n)	//二维数组作为参数，可以这么写
{
    for(int i=0;i<n;i++)
    {
        printf("%s\n",a[i]);		//OK
    }
}

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

char a[4][30]={"111111111","222222222","333333333","444444444"};
//a，首行地址；a+i，第 i 行地址
//a代表首行地址，首行首元素地址有区别，但是值是一样的，区别是地址的步长不一样
//首行地址 +1，移动30 个字节，首行首元素地址 +1，移动 1 个字节
//首行地址和首元素地址是一样的，注意 *(a+i),a[i],a+i的区别

int n=sizeof(a)/sizeof(a[0]);		//n=4

//二位是数组的第一个维度可以不写，但是必须满足一定的条件：必须在二维数组定义的时候初始化
char b[][30]={"111111111","222222222","333333333","444444444"};		//OK
char c[][30];			//err

printf_array(a,n);

int main()
{
    char *p=NULL;
    p=(char*)malloc(100);
    strcpy(p,"nsjkcnsics");
    
    //10 个 char*，每个都是NULL
    char *p1[10]={0};
    for(int i=0;i<10;i++)
    {
        p[i]=(char*)malloc(100);
        strcpy(p[i],"cnijcns");
    }
    int a[10];
    int *q=(int*) malloc(10*sizeof(int));		//相当于是 q[10]
    
    //动态分配一个数组，数组每个元素都是 char*
    //char* ch[10]
    int n=3;
    char **buf=(char**)malloc(sizeod(char*)*n);		//相当于 char* buf[3];
    if(buf==NULL)
        return -1;
    for(i=0;i<n;i++)
    {
        buf[i]=(char*)malloc(30*sizeof(char));
        char str[30];
        strcpy(buf[i],"fcnijcnjwi");	
        //strcpy(buf[i],str);	
    }
    for(i=0;i<n;i++)
    {
        printf("%s\n",buf[i]);
    }
    
    
    //内存释放，先释放内层，再释放外层
    for(i=0;i<n;i++)
    {
        free(buf[i]);
        buf[i]=NULL;
    }
    if(buf!=NULL)
    {
        free(buf);
        buf=NULL;
    }
    
    return 0;
}

char **getMem(int n)
{
    int i=0;
    char **buf=(char**)malloc(sizeod(char*)*n);		//相当于 char* buf[3];
    if(buf==NULL)
        return NULL;
    for(i=0;i<n;i++)
    {
        buf[i]=(char*)malloc(30*sizeof(char));
        char str[30];
        strcpy(buf[i],"fcnijcnjwi");	
        //strcpy(buf[i],str);	
    }
    for(i=0;i<n;i++)
    {
        printf("%s\n",buf[i]);
    }
    return buf;
}

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

void free_buf(char **buf,int n)
{
    int i;
    for(i=0;i<n;i++)
    {
        free(buf[i]);
        buf[i]=NULL;
    }
    if(buf!=NULL)
    {
        free(buf);
        buf=NULL;
    }
}
int main()
{
    char **buf=NULL;
    int n=3;
    buf=getMem(n);
    if(buf==NULL)
    {
        printf("getMem err\n");
        return -1;
    }
    print_buf(buf,n);		//值传递
    free_buf(buf,n);		//值传递
    buf=NULL;
    return 0;
}

int a[]={1,2,3,4,5,6,7,8};
//int b[];	//err,不指定长度，在定义的时候必须初始化
int c[100]={1,2,3,4};		//没有赋值的元素都为 0 

int n=0;
//sizeof，计算变量的类型所占的空间
//sizeof(a)=4*8=32	// 数组类型的大小，由元素个数、元素类型决定
n=sizeof(a)/sizeof(a[0]);		//n=8

//元素访问：a[i], *(a+i), 两种写法等价
//a+i 代表第 i 个元素的地址

int a[]={1,2,3,4,5,6,7,8};
//a 代表首元素地址，&a 代表整个数组的首地址，和首元素地址一样，但是他们的步长不一样
//a+1 跳一个元素，&(a+1) 跳整个数组长度
pritnf("%d %d\n",a,a+1);			// +4
pritnf("%d %d\n",&a,&(a+1));		// +32

//通过 typedef 定义一个数组类型
//有 typedef 是类型，没有 typedef 是变量
typedef int A[8];			//代表是一个数组类型，这里的 A 是一个数据类型，不是变量
//等价写法：typedef int (A)[8];

A b;		//等价于 int b[8]; 关于 b 的各种操作，与 int b[8] 的各种操作是一致的
//取了 typedef，b 替换到 A 的位置，就是他的含义

for(int i=0;i<8;i++)
{
    b[i]=i;
}

int main()
{
    int a[10]={0};
    //定义数组指针变量
    //1、先定义数组类型，根据类型定义指针
    typedef int A[10];		//[10]代表步长
    A *p=NULL;				//p 是一个数组指针变量
    p=&a;		//OK, &a 代表整个数组的首地址
    //p=a;		//不会报错，但是会有警告，这么写不准确，p是指针数组，而a 是数组首元素的地址
    //但是 a 和 &a 一样，a 最终也会被当做 &a，但是这么写不好
    pritnf("%d %d\n",p,p+1);		//输出的两个地址相差 40 ，步长为整个数组的长度 
    
    for(int i=0;i<10;i++)
    {
        //a[]
        //p=&a;		*p=*&a -> a
        (*p)[i]=i+1;
    }
    for(int i=0;i<10;i++)
    {
        printf("%d ",(*p)[i]);			//输出：1 2 3 4 5 6 7 8 9 10
    }
    printf("%d\n",sizeof(p));			// 4   
    return 0;
}

int main()
{
    int a[10]={0};
    //和指针数组写法很类似，但是多了 ()
    //() 和 [] 优先级一样，从左往右
    //() 内有指针，说明他是一个指针，[]说明是一个数组，因此是一个数组指针，前面有 typedef，说明是类型 -> 数组指针类型
    typedef int (*P)[10];			
    P q;				//数组指针类型变量
    q=&a;
    for(int i=0;i<10;i++)
    {
        //a[]
        //p=&a;		*p=*&a -> a
        (*p)[i]=i+1;
    }
    for(int i=0;i<10;i++)
    {
        printf("%d ",(*p)[i]);			//输出：1 2 3 4 5 6 7 8 9 10
    }
    printf("%d\n",sizeof(p));			// 4  
    return 0;
}

int main()
{
    int a[10]={0};
	int (*q)[10];		//数组指针变量	
    q=&a;				//指向 a 数组
    for(int i=0;i<10;i++)
    {
        //a[]
        //p=&a;		*p=*&a -> a
        (*p)[i]=i+1;
    }
    for(int i=0;i<10;i++)
    {
        printf("%d ",(*p)[i]);			//输出：1 2 3 4 5 6 7 8 9 10
    }
    printf("%d\n",sizeof(p));			// 4  
    return 0;
}

int main(int argc,char* argv[])		//argv，也是有个指针数组
    //argc 传参的个数，包括执行的可执行程序本身
    //argv 传入的参数字符串数组
{
    //[] 比 *  的优先级高，a 是一个指针数组
	char* a[]={"aaaaaaaa","bbbbbbbb","cccccccc"};
    
    for(int i=0;i<argc;i++)
    {
        printf("%s\n",argv[i]);		//命令行中运行：xxx.exe a b c dddd
        //输出：xxx.exe a b c dddd 共五个字符串
    }
    
    
    return 0;
}

int main()
{
    int a[10]={0};
    a[11]=0;			//可能不会报错，只是因为刚好这个空间没有被使用，但是一旦工程项目大了，这个空间被使用了，就会报错
    return 0;
}

int main()
{
    int a1[3][4]=
    {
        {1,2,3,4},
        {5,6,7,8},
        {9,10,11,12}
    };		//等价于：int a1[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
    printf("%d %d\n",a1,a1=1);		//相差 16
    //二维数组名，代表的是第 0 行的首地址（区别于第 0 行首元素地址，虽然他们的值一样，但是他们的步长不一样）
    printf("%d %d\n",*(a1+0)，*(a1+1));		//第 0 行首元素地址,第 1 行首元素地址，相差 16	等价于：printf("%d %d\n",a1[0],a1[1]);
    printf("%d\n",*(a1+0)+1);		//第 0 行 第一个元素地址		等价于：printf("%d\n",a[0]+1);
    //a，代表第 0 行首地址
    //a+i，代表第 i 行首地址
    //*(a+i)，等价于 a[i]，代表第 i 行首元素地址
    //*(a+i)+j，等价于 &a[i][j]，代表第 i 行第 j 列元素的地址
    //*(*(a+i)+j)，等价于 a[i][j]，代表第 i 行第 j 列的元素

    return 0;
}

int main()
{
    int a1[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
    int n=sizeof(a)/sizeof(a[0][0]]);
    for(int i=0;i<n;i++)
    {
        printf("%d ",a[i]);		//输出结果：1 2 3 4 5 6 7 8 9 10 11 12
    }
    return 0;
}

int main()
{
    //3 个 a[4] 的一维数组
    int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
    
    //定义数组指针
    int (*p)[4];
    p=a;		//指向首行首地址，步长为二维数组的一行的长度，p 的等价于数组名
    //p=&a;		//指向整个二维数组的首地址，步长为整个数组的长度
    printf("%d %d\n",p,p+1);		//相差 16，步长为二维数组的一行的长度
    for(int i=0;i<3;i++)
    {
        for(int j=0;j<4;j++)
        {
            printf("%d ",*(*(p+i)+j));		//等价于：printf("%d ",p[i][j]);
        }
        printf("\n");
    }
    
    return 0;
}

int t[]={1,2,3,4,5,6,7,8,9,10};
primtf("%d %d\n",sizeof(t),sizeof(&t));		// 40 4	，分别是首行首元素地址和首行首地址

int a[2][10];
pritnf("%d %d\n",sizeof(a[0]),sizeof(&a[0]));		// 40 4	，分别是首行首元素地址和首行首地址

void printArray(int a[3][4])
{
    for(int i=0;i<3;i++)
    {
        for(int j=0;j<4;j++)
        {
            printf("%d ",a[i][j]);
        }
    }
}

//数组指针
typedef int(*P)[]
void printArray1(int a[][4])
{
    for(int i=0;i<3;i++)
    {
        for(int j=0;j<4;j++)
        {
            printf("%d ",a[i][j]);
        }
    }
}

//数组做形参，会退化为指针
void printArray2(int (*a)[4])
{
    for(int i=0;i<3;i++)
    {
        for(int j=0;j<4;j++)
        {
            printf("%d ",a[i][j]);
        }
    }
}


int main()
{
    int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
    printArray(a);
    printArray1(a);
    printArray2(a);
    
    return 0;
}

typedef struct Teacher
{
    char name[50];
    int age;
}Teacher1;

//结构体类型定义
//struct 关键字，struct Teacher 合在一起才是类型
//{} 后面有分号
struct Teacher
{
    char name[50];
    int age;
};
//结构体变量定义，全局变量
struct Teacher t;
int main()
{
    //结构体变量定义，局部变量
    struct Teacher t2={"lili",18};
    printf("%s %d\n",t2.name,t2.age);
    
    strcpy(t2.name,"xiaoming");
    t2.age=22;
    
    struct Teacher *p=NULL;		//指针指向空，无法对其成员进行操作
    p=&t2;					
    strcpy(p->name,"xiaoming");
    p->age=22;			//等价于：(*p).age=22;
    printf("%s %d\n",p->name,p->age);
    
    return 0;
}

//定义结构体类型时。不要直接给成员赋值
//结构体只是一个类型，还没有分配空间
//只有根据类型定义变量时，才分配空间，有空间后才能赋值
typedef struct Teacher
{
    char name[50];
    //int age=50;		//err
    int age;
}Teacher;

void copyTeacher(Teacher to,Teacher from)
{
    to=from;
}

void copyTeacher1(Teacher *to,Teacher *from)
{
    *to=*from;
}

int main()
{
    Teacher t1={"lily","22"};
    
    //相同类型的两个结构体变量，可以相互赋值
    //把 t1 成员变量内存的值拷贝给 t2 成员变量的内存
    //t1 和 t2 在内存上没有关系，类似于：int a=10;   int b=a;	
    Teacher t2=t1;
    printf("%s %d\n",t2.name,t2.age);		//lily 22
    
    Teacher t3;
    memset(&t3,0,sizeof(t3));
    copyTeacher(t3,t1);			//t1 拷贝给 t3
    printf("%s %d\n",t3.name,t3.age);		// 0		值传递
    
    copyTeacher1(&t3,&t1);			//t1 拷贝给 t3
    printf("%s %d\n",t3.name,t3.age);		// lily 22		地址传递
    
    return 0;
}

typedef struct Teacher
{
    char name[50];
    int age;
}Teacher;
int main()
{
    //结构体数组初始化方法1：
    Teacher a[3]=
    {
        {"a",18},  
        {"a",18},  
        {"a",18}
    };
    
    //结构体数组初始化方法2：
    //这种属于是静态结构体数组
    Teacher b[3]={"a",18,"a",18};		//剩下没有赋值的部分会自动初始化为 0 
    for(int i=0;i<3;i++)
    {
        printf("%s %d\n",b[i].name,b[i].age);
    }
    
    return 0;
}

typedef struct Teacher
{
    char name[50];
    int age;
}Teacher;
int main()
{
    //类似于：Teacher p[3];
    Teacher* p=(Teacher*)malloc(3*sizeof(Teacher));
    if(p==NULL)
        return -1;
    char buf[50];
    for(int i=0;i<3;i++)
    {
        sprintf(buf,"name%d%d%d\n",i,i,i);
        strcpy(p[i].name,buf);
        p[i].age=20+i;
    }
    for(int i=0;i<3;i++)
    {
        printf("%s %d\n",p[i].name,p[i].age);
    }
    if(p!=NULL)
    {
        free(p);
        p=NULL;
    }
    
    return 0;
}

typedef struct Teacher
{
    char *name;
    int age;
}Teacher;
int main()
{
    char* name=NULL;
    //strcpy(name,"lily");		//err，因为 name 指向空，无法对其进行拷贝
    name=(char*)malloc(sizeof(char)*30);
    strcpy(name,"lily");
    if(name!=NULL)
    {
        free(name);
        name=NULL;
    }
    
    //1.
    Teacher t;
    t.name=(char*)malloc(sizeof(char)*30);
    strcpy(t.name,"lily");
    t.age=22;
    printf("%s %d\n",t.name,t.age);		//lily 22
    if(t.name!=NULL)
    {
        free(t.name);
        t.name=NULL;
    }
    
    //2.
    Tearcher *p=NULL;
    p=(Teacher*)malloc(sizeof(Teacher)*1);
    p->name=(char*)malloc(sizeof(char)*30);
    strcpy(p->name,"lily");
    p->age=22;
    printf("%s %d\n",p->name,p->age);		//lily 22
    if(p->name!=NULL)
    {
        free(p->name);
        p->name=NULL;
    }
    if(p!=NULL)
    {
        free(p);
        p=NULL;
    }
    
    //3.
    Teacher *q=NULL;
    q=(Teacher*)malloc(sizeof(Teacher)*3);		//Teacher q[3];
    char buf[30];
    for(int i=0;i<3;i++)
    {
        q[i].name=(char*)malloc(sizeof(char)*30);
        sprintf(buf,"name%d%d%d",i,i,i);
        strcpy(q[i].name,buf);
        q[i].age=20+i;
    }
    for(int i=0;i<3;i++)
    {
        printf("%s %d\n",q[i].name,q[i].age);		
    }
    for(int i=0;i<3;i++)
    {
        if(q[i].name!=NULL)
        {
            free(q[i].name);
            q[i].name=NULL;
        }
    }
    if(q!=NULL)
    {
        free(q);
        q=NULL;
    }
    
    
    return 0;
}

typedef struct Teacher
{
    char *name;
    int age;
}Teacher;
void showTeacher(Taecher *q,int n)
{
    int i=0;
    for(i=0;i<n;i++)
    {
        printf("%s %d\n",q[i].name,q[i].age);		
    }
}

void freeTeacher(Teacher *q,int n)
{
    int i=0;
    for(int i=0;i<3;i++)
    {
        if(q[i].name!=NULL)
        {
            free(q[i].name);
            q[i].name=NULL;
        }
    }
    if(q!=NULL)
    {
        free(q);
        q=NULL;
    }
}

Teacher* getMem(int n)
{
    Teacher *q;
    q=(Teacher*)malloc(sizeof(Teacher)*n);		//Teacher q[3];
    char buf[30];
    for(int i=0;i<n;i++)
    {
        q[i].name=(char*)malloc(sizeof(char)*30);
        sprintf(buf,"name%d%d%d",i,i,i);
        strcpy(q[i].name,buf);
        q[i].age=20+i;
    }
    return q;
}

int getMem1(Teacher **tmp,int n)
{
    if(tmp==NULL)
        return -1;
    Teacher *q;
    q=(Teacher*)malloc(sizeof(Teacher)*n);		//Teacher q[3];
    char buf[30];
    for(int i=0;i<n;i++)
    {
        q[i].name=(char*)malloc(sizeof(char)*30);
        sprintf(buf,"name%d%d%d",i,i,i);
        strcpy(q[i].name,buf);
        q[i].age=20+i;
    }
    *tmp=q;
    
    return 0;
}
int main()
{
    Teacher *q=NULL;
    //q=getMem(3);		//值传递，返回值
    
    int ret=0;
    ret=getMem1(&q,3);		//地址传递
    if(ret!=0)
        return ret;
    
    showTeacher(q,3);
    
    freeTeacher(q,3);
    q=NULL;
    
    
    return 0;
}

typedef struct Teacher
{
    char **stu;		//一个老师有多个学生
}Teacher;

int main()
{
    //1.
    Teacher t;		
    //t.stu[3]
    //char *t.stu[3]
    int n=3;
    int i=0;
    t.stu=(char**)malloc(sizeof(char*)*n);
    for(i=0;i<n;i++)
    {
        t.stu[i]=(char*)malloc(30);
        strcpy(t.stu[i],"lily");
    }
    for(i=0;i<n;i++)
    {
        printf("%s\n",t.stu[i]);
    }
    for(i=0;i<n;i++)
    {
        if(t.stu[i]!=NULL)
        {
            free(t.stu[i]);
            t.stu[i]=NULL;
        }
    }
    if(t.stu!=NULL)
    {
        free(t.stu);
        t.stu=NULL;
    }
        
    
    //2.
    Teacher *p=NULL;
    //p->stu[3]
    p=(Teacher*)malloc(sizeof(Teacher));
    p->stu=(char**)malloc(sizeof(char*)*n);
    for(i=0;i<n;i++)
    {
        p->stu[i]=(char*)malloc(30);
        strcpy(p->stu[i],"lily");
    }
    for(i=0;i<n;i++)
    {
        printf("%s\n",p->stu[i]);
    }
    for(i=0;i<n;i++)
    {
        if(p->stu[i]!=NULL)
        {
            free(p->stu[i]);
            p->stu[i]=NULL;
        }
    }
    if(p->stu!=NULL)
    {
        free(t.stu);
        p->stu=NULL;
    }
    if(p!=NULL)
    {
        free(p);
        p=NULL;
    }
    
    
    //3.
    Teacher *q=NULL;
    //Teacher q[3]
    //q[i].stu[3]
    q=(Teacher*)malloc(sizeof(Teacher)*n);		//Teacher q[3]
    for(i=0;i<n;i++)
    {
        (q+i)->stu=(char**)malloc(n*sizeof(char*));  //char *stu[3];
        for(int j=0;j<3;j++)
        {
            (q+i)->stu[j]=(char*)malloc(30);
            char buf[30];
            sprintf(buf,"name%d%d%d",i,i,i);
            strcpy((q+i)->stu[j],buf);
        }
    }
    for(i=0;i<3;i++)
    {
        for(int j=0;j<3;j++)
        {
            printf("%s\n",(q+i)->stu[j]);
        }
    }
    //free
    for(i=0;i<3;i++)
    {
        for(int j=0;j<3;j++)
        {
            if((q+i)->stu[j]!=NULL)
            {
                free((q+i)->stu[j]);
                (q+i)->stu[j]=NULL;
            }
        }
        if(q[i].stu!=NULL)
        {
            free(q[i].stu);
            q[i].stu=NULL;
        }
    }
    if(q!=NULL)
    {
        free(q);
        q=NULL;
    }
    
    
    return 0;
}

typedef struct Teacher
{
    char **stu;		//一个老师有多个学生
}Teacher;

//n1 老师数量，n2 每个老师的学生数量
int creatTeacher(Teacher **tmp,int n1,int n2)
{
    int i=0;
    if(tmp==NULL)
        return -1;
    
    Teacher *q=(Teacher*)malloc(sizeof(Teacher)*n1);		//Teacher q[3]
    for(i=0;i<n1;i++)
    {
        (q+i)->stu=(char**)malloc(n2*sizeof(char*));  //char *stu[3];
        for(int j=0;j<n2;j++)
        {
            (q+i)->stu[j]=(char*)malloc(30);
            char buf[30];
            sprintf(buf,"name%d%d%d",i,i,i);
            strcpy((q+i)->stu[j],buf);
        }
    }
    //间接赋值
    *tmp=q;
    
    return 0;
}

void showTeacher(Teacher *q,int n1,int n2)
{
    if(q==NULL)
    {
        return;
    }
    for(int i=0;i<n1;i++)
    {
        for(int j=0;j<n2;j++)
        {
            printf("%s\n",(q+i)->stu[j]);
        }
    }
}

void freeTeacher(Teacher **tmp,int n1,int n2)
{
    if(tmp==NULL)
        return;
    Teacher *q=*tmp;
    //free
    for(int i=0;i<n1;i++)
    {
        for(int j=0;j<n2;j++)
        {
            if((q+i)->stu[j]!=NULL)
            {
                free((q+i)->stu[j]);
                (q+i)->stu[j]=NULL;
            }
        }
        if(q[i].stu!=NULL)
        {
            free(q[i].stu);
            q[i].stu=NULL;
        }
    }
    if(q!=NULL)
    {
        free(q);
        q=NULL;
        *tmp=NULL;
    }
}

int main()
{   
    //3.
    Teacher *q=NULL;
    int ret=0;
    ret=creatTeacher(&q,3,3);
    if(ret!=0)
        return -1;
    //Teacher q[3]
    //q[i].stu[3]
    showTeacher(q,3,3);
    
    freeTeacher(&q,3,3);
    
    
    return 0;
}

typedef struct Teacher
{
    int age;
    char **stu;		//一个老师有多个学生
}Teacher;

void sortTeacher(Teacher *q,int n)
{
    if(q==NULL)
        return -1;
    int i=0;
    int j=0;
    Teacher tmp;
    for(i=0;i<n-1;i++)
    {
        for(j=i+1;j<n;j++)
        {
            if(p[i].age<p[j].age)
            {
                tmp=p[i];
                p[i]=p[j];
                p[j]=tmp;
            }
        }
    }
}